apm_bro 0.1.12 → 0.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: caf0f22a5f4a72ddab15c8ec54dd82eb421786dd02568706eab5a906e2543a6c
-  data.tar.gz: 8b944014790250fc71107ebe01e789b882f9f9d836904f30edcc03ebb734fd41
+  metadata.gz: d47832a9c956542a7b0e88d048d2f8760f7971df069a7e06fec92822ad79e67e
+  data.tar.gz: 2f536dfe0c55b9b46fae2a4f5b77f5c873b39c59ef71ec06052951d02192a4c7
 SHA512:
-  metadata.gz: 750db0f63cd9e0d6bb01f3c45db1efcd81922a5b532ed0226d9948dcf0ae4b709f6cec442403f469064bc334b45bcae9d203b4df4a90cefc6ba334a0b4add919
-  data.tar.gz: 626c32ee6ac593b581a1fbd3e9a5086382b877212280d8265f774600bd6fea79c87957aa6c50c6c3725baa1835cc899f1a3fa1af7f9de0713e3bf63b34fb7d0f
+  metadata.gz: 1e288923b2a58952d927cee3c85e3e242fe22baf79acccefd79ce0933a3b6c7db786faae7b4e96bd9f5687f9aed48c78e9bc493440809a65d27eaf9a31cb51d2
+  data.tar.gz: 02cd07fa51270bdda5a7ada77463435491cd99e7999ea4162864547454f99ce9846ed78b9cfc9c1df0e5095e7145da43d9822bd790786e1c77701f94a9705d34

data/lib/apm_bro/job_sql_tracking_middleware.rb

@@ -8,6 +8,16 @@ module ApmBro
         # Clear logs for this job
         ApmBro.logger.clear
         ApmBro::SqlSubscriber.start_request_tracking
+
+        # Start lightweight memory tracking for this job
+        if defined?(ApmBro::LightweightMemoryTracker)
+          ApmBro::LightweightMemoryTracker.start_request_tracking
+        end
+
+        # Start detailed memory tracking when allocation tracking is enabled
+        if ApmBro.configuration.allocation_tracking_enabled && defined?(ApmBro::MemoryTrackingSubscriber)
+          ApmBro::MemoryTrackingSubscriber.start_request_tracking
+        end
       end
     rescue StandardError
       # Never raise from instrumentation install

data/lib/apm_bro/job_subscriber.rb

@@ -23,6 +23,34 @@ module ApmBro
         # Get SQL queries executed during this job
         sql_queries = ApmBro::SqlSubscriber.stop_request_tracking
         
+        # Stop memory tracking and get collected memory data
+        if ApmBro.configuration.allocation_tracking_enabled && defined?(ApmBro::MemoryTrackingSubscriber)
+          detailed_memory = ApmBro::MemoryTrackingSubscriber.stop_request_tracking
+          memory_performance = ApmBro::MemoryTrackingSubscriber.analyze_memory_performance(detailed_memory)
+          # Keep memory_events compact and user-friendly (no large raw arrays)
+          memory_events = {
+            memory_before: detailed_memory[:memory_before],
+            memory_after: detailed_memory[:memory_after],
+            duration_seconds: detailed_memory[:duration_seconds],
+            allocations_count: (detailed_memory[:allocations] || []).length,
+            memory_snapshots_count: (detailed_memory[:memory_snapshots] || []).length,
+            large_objects_count: (detailed_memory[:large_objects] || []).length
+          }
+        else
+          lightweight_memory = ApmBro::LightweightMemoryTracker.stop_request_tracking
+          # Separate raw readings from derived performance metrics to avoid duplicating data
+          memory_events = {
+            memory_before: lightweight_memory[:memory_before],
+            memory_after: lightweight_memory[:memory_after]
+          }
+          memory_performance = {
+            memory_growth_mb: lightweight_memory[:memory_growth_mb],
+            gc_count_increase: lightweight_memory[:gc_count_increase],
+            heap_pages_increase: lightweight_memory[:heap_pages_increase],
+            duration_seconds: lightweight_memory[:duration_seconds]
+          }
+        end
+        
         payload = {
           job_class: data[:job].class.name,
           job_id: data[:job].job_id,
@@ -35,6 +63,8 @@ module ApmBro
           host: safe_host,
           memory_usage: memory_usage_mb,
           gc_stats: gc_stats,
+          memory_events: memory_events,
+          memory_performance: memory_performance,
           logs: ApmBro.logger.logs
         }
         
@@ -57,6 +87,34 @@ module ApmBro
         # Get SQL queries executed during this job
         sql_queries = ApmBro::SqlSubscriber.stop_request_tracking
         
+        # Stop memory tracking and get collected memory data
+        if ApmBro.configuration.allocation_tracking_enabled && defined?(ApmBro::MemoryTrackingSubscriber)
+          detailed_memory = ApmBro::MemoryTrackingSubscriber.stop_request_tracking
+          memory_performance = ApmBro::MemoryTrackingSubscriber.analyze_memory_performance(detailed_memory)
+          # Keep memory_events compact and user-friendly (no large raw arrays)
+          memory_events = {
+            memory_before: detailed_memory[:memory_before],
+            memory_after: detailed_memory[:memory_after],
+            duration_seconds: detailed_memory[:duration_seconds],
+            allocations_count: (detailed_memory[:allocations] || []).length,
+            memory_snapshots_count: (detailed_memory[:memory_snapshots] || []).length,
+            large_objects_count: (detailed_memory[:large_objects] || []).length
+          }
+        else
+          lightweight_memory = ApmBro::LightweightMemoryTracker.stop_request_tracking
+          # Separate raw readings from derived performance metrics to avoid duplicating data
+          memory_events = {
+            memory_before: lightweight_memory[:memory_before],
+            memory_after: lightweight_memory[:memory_after]
+          }
+          memory_performance = {
+            memory_growth_mb: lightweight_memory[:memory_growth_mb],
+            gc_count_increase: lightweight_memory[:gc_count_increase],
+            heap_pages_increase: lightweight_memory[:heap_pages_increase],
+            duration_seconds: lightweight_memory[:duration_seconds]
+          }
+        end
+        
         payload = {
           job_class: data[:job].class.name,
           job_id: data[:job].job_id,
@@ -72,6 +130,8 @@ module ApmBro
           host: safe_host,
           memory_usage: memory_usage_mb,
           gc_stats: gc_stats,
+          memory_events: memory_events,
+          memory_performance: memory_performance,
           logs: ApmBro.logger.logs
         }
         

data/lib/apm_bro/sql_subscriber.rb

@@ -9,6 +9,7 @@ module ApmBro
     THREAD_LOCAL_KEY = :apm_bro_sql_queries
     THREAD_LOCAL_ALLOC_START_KEY = :apm_bro_sql_alloc_start
     THREAD_LOCAL_ALLOC_RESULTS_KEY = :apm_bro_sql_alloc_results
+    THREAD_LOCAL_BACKTRACE_KEY = :apm_bro_sql_backtraces
 
     def self.subscribe!
       # Subscribe with a start/finish listener to measure allocations per query
@@ -20,13 +21,19 @@ module ApmBro
       end
 
       ActiveSupport::Notifications.subscribe(SQL_EVENT_NAME) do |name, started, finished, _unique_id, data|
+        next if data[:name] == "SCHEMA"
         # Only track queries that are part of the current request
         next unless Thread.current[THREAD_LOCAL_KEY]
         unique_id = _unique_id
         allocations = nil
+        captured_backtrace = nil
         begin
           alloc_results = Thread.current[THREAD_LOCAL_ALLOC_RESULTS_KEY]
           allocations = alloc_results && alloc_results.delete(unique_id)
+          
+          # Get the captured backtrace from when the query started
+          backtrace_map = Thread.current[THREAD_LOCAL_BACKTRACE_KEY]
+          captured_backtrace = backtrace_map && backtrace_map.delete(unique_id)
         rescue StandardError
         end
 
@@ -36,7 +43,7 @@ module ApmBro
           duration_ms: ((finished - started) * 1000.0).round(2),
           cached: data[:cached] || false,
           connection_id: data[:connection_id],
-          trace: safe_query_trace(data),
+          trace: safe_query_trace(data, captured_backtrace),
           allocations: allocations
         }
         # Add to thread-local storage
@@ -49,6 +56,7 @@ module ApmBro
       Thread.current[THREAD_LOCAL_KEY] = []
       Thread.current[THREAD_LOCAL_ALLOC_START_KEY] = {}
       Thread.current[THREAD_LOCAL_ALLOC_RESULTS_KEY] = {}
+      Thread.current[THREAD_LOCAL_BACKTRACE_KEY] = {}
     end
 
     def self.stop_request_tracking
@@ -56,6 +64,7 @@ module ApmBro
       Thread.current[THREAD_LOCAL_KEY] = nil
       Thread.current[THREAD_LOCAL_ALLOC_START_KEY] = nil
       Thread.current[THREAD_LOCAL_ALLOC_RESULTS_KEY] = nil
+      Thread.current[THREAD_LOCAL_BACKTRACE_KEY] = nil
       queries || []
     end
 
@@ -75,7 +84,7 @@ module ApmBro
       sql.length > 1000 ? sql[0..1000] + "..." : sql
     end
 
-    def self.safe_query_trace(data)
+    def self.safe_query_trace(data, captured_backtrace = nil)
       return [] unless data.is_a?(Hash)
 
       # Build trace from available data fields
@@ -86,24 +95,64 @@ module ApmBro
         trace << "#{data[:filename]}:#{data[:line]}:in `#{data[:method]}'"
       end
       
-      # Always try to get the full call stack for better trace information
-      begin
-        # Get the current call stack, skip the first few frames (our own code)
-        caller_stack = caller(3, 0) # Skip 3 frames, get up to 1
-        caller_trace = caller_stack.map do |line|
+      # Use the captured backtrace from when the query started (most accurate)
+      if captured_backtrace && captured_backtrace.is_a?(Array) && !captured_backtrace.empty?
+        # Filter to only include frames that contain "app/" (application code)
+        app_frames = captured_backtrace.select do |frame|
+          frame.include?('app/') && !frame.include?('/vendor/')
+        end
+        
+        caller_trace = app_frames.map do |line|
           # Remove any potential sensitive information from file paths
           line.gsub(/\/[^\/]*(password|secret|key|token)[^\/]*\//i, '/[FILTERED]/')
         end
         
-        # Combine the immediate location with the call stack
         trace.concat(caller_trace)
-      rescue StandardError
-        # If caller fails, we still have the immediate location
+      else
+        # Fallback: try to get backtrace from current context
+        begin
+          # Get all available frames - we'll filter to find application code
+          all_frames = Thread.current.backtrace || []
+          
+          if all_frames.empty?
+            # Fallback to caller_locations if backtrace is empty
+            locations = caller_locations(1, 50)
+            all_frames = locations.map { |loc| "#{loc.path}:#{loc.lineno}:in `#{loc.label}'" } if locations
+          end
+          
+          # Filter to only include frames that contain "app/" (application code)
+          app_frames = all_frames.select do |frame|
+            frame.include?('app/') && !frame.include?('/vendor/')
+          end
+          
+          caller_trace = app_frames.map do |line|
+            line.gsub(/\/[^\/]*(password|secret|key|token)[^\/]*\//i, '/[FILTERED]/')
+          end
+          
+          trace.concat(caller_trace)
+        rescue StandardError
+          # If backtrace fails, try caller as fallback
+          begin
+            caller_stack = caller(20, 50) # Get more frames to find app/ frames
+            app_frames = caller_stack.select { |frame| frame.include?('app/') && !frame.include?('/vendor/') }
+            caller_trace = app_frames.map do |line|
+              line.gsub(/\/[^\/]*(password|secret|key|token)[^\/]*\//i, '/[FILTERED]/')
+            end
+            trace.concat(caller_trace)
+          rescue StandardError
+            # If caller also fails, we still have the immediate location
+          end
+        end
       end
       
-      # If we have a backtrace, use it (but it's usually nil for SQL events)
+      # If we have a backtrace in the data, use it (but it's usually nil for SQL events)
       if data[:backtrace] && data[:backtrace].is_a?(Array)
-        backtrace_trace = data[:backtrace].first(5).map do |line|
+        # Filter to only include frames that contain "app/"
+        app_backtrace = data[:backtrace].select do |line|
+          line.is_a?(String) && line.include?('app/') && !line.include?('/vendor/')
+        end
+        
+        backtrace_trace = app_backtrace.map do |line|
           case line
           when String
             line.gsub(/\/[^\/]*(password|secret|key|token)[^\/]*\//i, '/[FILTERED]/')
@@ -114,8 +163,8 @@ module ApmBro
         trace.concat(backtrace_trace)
       end
       
-      # Remove duplicates and limit the number of frames
-      trace.uniq.first(10).map do |line|
+      # Remove duplicates and return all app/ frames (no limit)
+      trace.uniq.map do |line|
         case line
         when String
           # Remove any potential sensitive information from file paths
@@ -138,6 +187,15 @@ module ApmBro
       begin
         map = (Thread.current[ApmBro::SqlSubscriber::THREAD_LOCAL_ALLOC_START_KEY] ||= {})
         map[id] = GC.stat[:total_allocated_objects] if defined?(GC) && GC.respond_to?(:stat)
+        
+        # Capture the backtrace at query start time (before notification system processes it)
+        # This gives us the actual call stack where the SQL was executed
+        backtrace_map = (Thread.current[ApmBro::SqlSubscriber::THREAD_LOCAL_BACKTRACE_KEY] ||= {})
+        captured_backtrace = Thread.current.backtrace
+        if captured_backtrace && captured_backtrace.is_a?(Array)
+          # Skip the first few frames (our listener code) to get to the actual query execution
+          backtrace_map[id] = captured_backtrace[5..-1] || captured_backtrace
+        end
       rescue StandardError
       end
     end

data/lib/apm_bro/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ApmBro
-  VERSION = "0.1.12"
+  VERSION = "0.1.14"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: apm_bro
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.14
 platform: ruby
 authors:
 - Emanuel Comsa