Ruby on Rails Debugger Tool
Call Stacking - Solve production bugs faster


  
  

        
        

          Solve production bugsfast.
          
            What does an hour of downtime cost you?
            (use our calculator to find out)
          
          
            Decode even the most convoluted Ruby on Rails production incidents with our
            debugger's powerful visualization, guiding you through the labyrinth of call chains and data flow.
          

        

        
        
          
            
            Your browser does not support the video tag.
          
        

      

  

  
  

          
          
          
            
              🏆
              
              
            
            
              AWARD WINNING
              Rails Hackathon 2022 Winner
            
            
          

          

        


  
  

        
        
          Production issues are hard to debug
          
            Instantly see in production every method call, parameter and return value, for a given request.
            You have hundreds, thousands, millions of lines of code to deal with.
            For every bug, there's only a few hundred lines that are relevant.
            Stop using the Rails console to debug critical issues. Fix your outage in minutes, not hours.
          
        

        
        
        
        
        

        
            
            
              
                Full, On-demand Tracing
                Capture all relevant application method calls for any given endpoint. Turn it off when not needed.
              
            
            
              
                Visibility for argument values for each method call.
                When a method call is five layers deep, it can be difficult to manually trace down the value being passed. This value may be coming from the database or being calculated in a parent method several levels up in the call stack, which can require significant effort to trace through the code to identify the source.
              
            
            
              
                Visual nesting of the method calls
                You can quickly see which methods are called within each parent method, so you can see the exact execution path the app took for a given endpoint. 
              
            
            
              
                Search
                Quickly search for any called method or class.
              
            
          


      

  


  
  

        
        
          
            A visual is worth a
            1,000 words
          
        

        
        

      

  


  
  

        
        
          An ecosystem of integrations
        

        
        

        
        
          
          

          

          
            
            
            
            
            
          
          
            
            
            
            
              Coming Soon
            
          
          
            
            
            
            
              Coming Soon
            
          
          
            
            
            
            
              Coming Soon
            
          

          

        

      

  
  

        
        
          Upcoming Plans
          Pricing plans for all levels.
        

        
        

          
          

          
          

          
          

          
          

          
          Usage
          
          Usage
          
          Usage
          
          Usage
          

          
          
          
          
            Traces per Month
            Unlimited
          
          
            Traces per Month
            Unlimited
          

          
          
          
          
          

          
          Features
          
          Features
          
          Features
          
          Features
          

          
          
          
          
          

          
          
          
          
          

          
          
          
          
          

          
          
          
          
          

        

      


  
  
  























  
  

        
        
          FAQs
        

        
        

          
          

            
            
              Which teams won't benefit from Call Stacking?
              
                  If your team does not incur revenue loss from downtime attributed to code regressions,
                    Call Stacking isn't needed.
                  
                    If your team is senior lead and has a good grasp on your large code base, you probably don't need Call Stacking.
                  
                  
                    If your SLAs are loosely enforced and engineers are allowed to respond to incidents on their time, the price of
                    Call Stacking isn't worth it.
                  
                  
                    If your application is an internal one and usage is timeboxed between business hours, all bugs are resolved in upcoming sprint cycles,
                    you won't need Call Stacking.
                  
                  
                    If code complexity has not been an issue and production incidents have largely been trivial or isolated,
                    Call Stacking isn't needed.
                  
                
              
            

            
            
              Will the production level tracing impact my performance metrics?
              
                Yes. It's impossible to capture the full context of an app - method calls, parameter values, return values, without adding some additional overhead per request.
              
            

          

          
          

            
            
              How is tracing enabled and disabled?
              
                  Tracing is added and then removed on a per request basis using an prepend_around_action in your ApplicationController.
                

                
                    class ApplicationController < ActionController::Base
                      include Callstacking::Rails::Helpers::InstrumentHelper
                      prepend_around_action :callstacking_setup
                  
                

                HTTP request times may have to be extended depending on the size of the codebase.
                  Once the instrumented methods are removed for the request, all subsequent requests for that server will be called with the original implementation.
                  Only the instrumented requests will incur the overhead of tracing.
                
            

            
            
              What are the requirements needed from my Rails app in order for Call Stacking to be supported?
              
                  Ruby 2+.
                  Rails 5+.
                  Must have the Rails cache configured(e.g. Rails.cache.write/read ).
                  Must ActiveJobs configured(e.g. CleanupJob.perform_later ).
                
              
            

          

        

      

  
  

  
  

        
        
          
            Revenue cannot grow if your product is unreliable.
          
          
            When instability arises,
            you need to get to root cause fast.
          
        

      
