apm_bro 0.1.13 → 0.1.15

data/lib/apm_bro/sql_subscriber.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
-require "active_support/notifications"
-require "thread"
+begin
+  require "active_support/notifications"
+rescue LoadError
+  # ActiveSupport not available
+end
 
 module ApmBro
   class SqlSubscriber
-    SQL_EVENT_NAME = "sql.active_record".freeze
+    SQL_EVENT_NAME = "sql.active_record"
     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
@@ -16,7 +19,7 @@ module ApmBro
       if ActiveSupport::Notifications.notifier.respond_to?(:subscribe)
         begin
           ActiveSupport::Notifications.notifier.subscribe(SQL_EVENT_NAME, SqlAllocListener.new)
-        rescue StandardError
+        rescue
         end
       end
 
@@ -30,11 +33,11 @@ module ApmBro
         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
+        rescue
         end
 
         query_info = {
@@ -48,7 +51,6 @@ module ApmBro
         }
         # Add to thread-local storage
         Thread.current[THREAD_LOCAL_KEY] << query_info
-
       end
     end
 
@@ -74,14 +76,14 @@ module ApmBro
       # Remove sensitive data patterns
       sql = sql.gsub(/\b(password|token|secret|key|ssn|credit_card)\s*=\s*['"][^'"]*['"]/i, '\1 = ?')
       sql = sql.gsub(/\b(password|token|secret|key|ssn|credit_card)\s*=\s*[^'",\s)]+/i, '\1 = ?')
-      
+
       # Remove specific values in WHERE clauses that might be sensitive
       sql = sql.gsub(/WHERE\s+[^=]+=\s*['"][^'"]*['"]/i) do |match|
-        match.gsub(/=\s*['"][^'"]*['"]/, '= ?')
+        match.gsub(/=\s*['"][^'"]*['"]/, "= ?")
       end
 
       # Limit query length to prevent huge payloads
-      sql.length > 1000 ? sql[0..1000] + "..." : sql
+      (sql.length > 1000) ? sql[0..1000] + "..." : sql
     end
 
     def self.safe_query_trace(data, captured_backtrace = nil)
@@ -89,94 +91,93 @@ module ApmBro
 
       # Build trace from available data fields
       trace = []
-      
+
       # Use filename, line, and method if available
       if data[:filename] && data[:line] && data[:method]
         trace << "#{data[:filename]}:#{data[:line]}:in `#{data[:method]}'"
       end
-      
+
       # 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?("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]/')
+          line.gsub(/\/[^\/]*(password|secret|key|token)[^\/]*\//i, "/[FILTERED]/")
         end
-        
+
         trace.concat(caller_trace)
       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?("app/") && !frame.include?("/vendor/")
           end
-          
+
           caller_trace = app_frames.map do |line|
-            line.gsub(/\/[^\/]*(password|secret|key|token)[^\/]*\//i, '/[FILTERED]/')
+            line.gsub(/\/[^\/]*(password|secret|key|token)[^\/]*\//i, "/[FILTERED]/")
           end
-          
+
           trace.concat(caller_trace)
-        rescue StandardError
+        rescue
           # 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/') }
+            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]/')
+              line.gsub(/\/[^\/]*(password|secret|key|token)[^\/]*\//i, "/[FILTERED]/")
             end
             trace.concat(caller_trace)
-          rescue StandardError
+          rescue
             # If caller also fails, we still have the immediate location
           end
         end
       end
-      
+
       # 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)
         # Filter to only include frames that contain "app/"
         app_backtrace = data[:backtrace].select do |line|
-          line.is_a?(String) && line.include?('/app/')
+          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]/')
+            line.gsub(/\/[^\/]*(password|secret|key|token)[^\/]*\//i, "/[FILTERED]/")
           else
             line.to_s
           end
         end
         trace.concat(backtrace_trace)
       end
-      
+
       # 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
-          line.gsub(/\/[^\/]*(password|secret|key|token)[^\/]*\//i, '/[FILTERED]/')
+          line.gsub(/\/[^\/]*(password|secret|key|token)[^\/]*\//i, "/[FILTERED]/")
         else
           line.to_s
         end
       end
-    rescue StandardError
+    rescue
       []
     end
-
   end
 end
 
@@ -184,36 +185,36 @@ module ApmBro
   # Listener that records GC allocation deltas per SQL event id
   class SqlAllocListener
     def start(name, id, payload)
-      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
+      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
     end
 
     def finish(name, id, payload)
-      begin
-        start_map = Thread.current[ApmBro::SqlSubscriber::THREAD_LOCAL_ALLOC_START_KEY]
-        return unless start_map && start_map.key?(id)
-
-        start_count = start_map.delete(id)
-        end_count = (GC.stat[:total_allocated_objects] rescue nil)
-        return unless start_count && end_count
-
-        delta = end_count - start_count
-        results = (Thread.current[ApmBro::SqlSubscriber::THREAD_LOCAL_ALLOC_RESULTS_KEY] ||= {})
-        results[id] = delta
-      rescue StandardError
+      start_map = Thread.current[ApmBro::SqlSubscriber::THREAD_LOCAL_ALLOC_START_KEY]
+      return unless start_map && start_map.key?(id)
+
+      start_count = start_map.delete(id)
+      end_count = begin
+        GC.stat[:total_allocated_objects]
+      rescue
+        nil
       end
+      return unless start_count && end_count
+
+      delta = end_count - start_count
+      results = (Thread.current[ApmBro::SqlSubscriber::THREAD_LOCAL_ALLOC_RESULTS_KEY] ||= {})
+      results[id] = delta
+    rescue
     end
   end
 end

data/lib/apm_bro/sql_tracking_middleware.rb

@@ -12,37 +12,37 @@ module ApmBro
 
       # Start SQL tracking for this request
       if defined?(ApmBro::SqlSubscriber)
-        puts "Starting SQL tracking for request: #{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
+        puts "Starting SQL tracking for request: #{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
         ApmBro::SqlSubscriber.start_request_tracking
       end
 
       # Start cache tracking for this request
       if defined?(ApmBro::CacheSubscriber)
-        puts "Starting cache tracking for request: #{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
+        puts "Starting cache tracking for request: #{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
         ApmBro::CacheSubscriber.start_request_tracking
       end
 
       # Start Redis tracking for this request
       if defined?(ApmBro::RedisSubscriber)
-        puts "Starting redis tracking for request: #{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
+        puts "Starting redis tracking for request: #{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
         ApmBro::RedisSubscriber.start_request_tracking
       end
 
       # Start view rendering tracking for this request
       if defined?(ApmBro::ViewRenderingSubscriber)
-        puts "Starting view rendering tracking for request: #{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
+        puts "Starting view rendering tracking for request: #{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
         ApmBro::ViewRenderingSubscriber.start_request_tracking
       end
 
       # Start lightweight memory tracking for this request
       if defined?(ApmBro::LightweightMemoryTracker)
-        puts "Starting lightweight memory tracking for request: #{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
+        puts "Starting lightweight memory tracking for request: #{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
         ApmBro::LightweightMemoryTracker.start_request_tracking
       end
 
       # Start detailed memory tracking when allocation tracking is enabled
       if ApmBro.configuration.allocation_tracking_enabled && defined?(ApmBro::MemoryTrackingSubscriber)
-        puts "Starting detailed memory tracking for request: #{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
+        puts "Starting detailed memory tracking for request: #{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
         ApmBro::MemoryTrackingSubscriber.start_request_tracking
       end
 
@@ -53,27 +53,27 @@ module ApmBro
     ensure
       # Clean up thread-local storage
       if defined?(ApmBro::SqlSubscriber)
-        queries = Thread.current[:apm_bro_sql_queries]
+        Thread.current[:apm_bro_sql_queries]
         Thread.current[:apm_bro_sql_queries] = nil
       end
 
       if defined?(ApmBro::CacheSubscriber)
-        cache_events = Thread.current[:apm_bro_cache_events]
+        Thread.current[:apm_bro_cache_events]
         Thread.current[:apm_bro_cache_events] = nil
       end
 
       if defined?(ApmBro::RedisSubscriber)
-        redis_events = Thread.current[:apm_bro_redis_events]
+        Thread.current[:apm_bro_redis_events]
         Thread.current[:apm_bro_redis_events] = nil
       end
 
       if defined?(ApmBro::ViewRenderingSubscriber)
-        view_events = Thread.current[:apm_bro_view_events]
+        Thread.current[:apm_bro_view_events]
         Thread.current[:apm_bro_view_events] = nil
       end
 
       if defined?(ApmBro::LightweightMemoryTracker)
-        memory_events = Thread.current[:apm_bro_lightweight_memory]
+        Thread.current[:apm_bro_lightweight_memory]
         Thread.current[:apm_bro_lightweight_memory] = nil
       end
 

data/lib/apm_bro/subscriber.rb

@@ -4,7 +4,7 @@ require "active_support/notifications"
 
 module ApmBro
   class Subscriber
-    EVENT_NAME = "process_action.action_controller".freeze
+    EVENT_NAME = "process_action.action_controller"
 
     def self.subscribe!(client: Client.new)
       ActiveSupport::Notifications.subscribe(EVENT_NAME) do |name, started, finished, _unique_id, data|
@@ -15,13 +15,13 @@ module ApmBro
           if ApmBro.configuration.excluded_controller_action?(controller_name, action_name)
             next
           end
-        rescue StandardError
+        rescue
         end
 
         duration_ms = ((finished - started) * 1000.0).round(2)
         # Stop SQL tracking and get collected queries (this was started by the request)
         sql_queries = ApmBro::SqlSubscriber.stop_request_tracking
-        
+
         # Stop cache and redis tracking
         cache_events = defined?(ApmBro::CacheSubscriber) ? ApmBro::CacheSubscriber.stop_request_tracking : []
         redis_events = defined?(ApmBro::RedisSubscriber) ? ApmBro::RedisSubscriber.stop_request_tracking : []
@@ -29,7 +29,7 @@ module ApmBro
         # Stop view rendering tracking and get collected view events
         view_events = ApmBro::ViewRenderingSubscriber.stop_request_tracking
         view_performance = ApmBro::ViewRenderingSubscriber.analyze_view_performance(view_events)
-        
+
         # Stop memory tracking and get collected memory data
         if ApmBro.configuration.allocation_tracking_enabled && defined?(ApmBro::MemoryTrackingSubscriber)
           detailed_memory = ApmBro::MemoryTrackingSubscriber.stop_request_tracking
@@ -57,7 +57,7 @@ module ApmBro
             duration_seconds: lightweight_memory[:duration_seconds]
           }
         end
-        
+
         # Record memory sample for leak detection (only if memory tracking enabled)
         if ApmBro.configuration.memory_tracking_enabled
           ApmBro::MemoryLeakDetector.record_memory_sample({
@@ -70,7 +70,7 @@ module ApmBro
             action: data[:action]
           })
         end
-        
+
         # Report exceptions attached to this action (e.g. controller/view errors)
         if data[:exception] || data[:exception_object]
           begin
@@ -90,9 +90,8 @@ module ApmBro
               host: safe_host,
               params: safe_params(data),
               user_agent: safe_user_agent(data),
-              user_email: extract_user_email(data),
               user_id: extract_user_id(data),
-              exception_class: (exception_class || exception_obj&.class&.name),
+              exception_class: exception_class || exception_obj&.class&.name,
               message: (exception_message || exception_obj&.message).to_s[0, 1000],
               backtrace: backtrace,
               error: true,
@@ -101,7 +100,7 @@ module ApmBro
 
             event_name = (exception_class || exception_obj&.class&.name || "exception").to_s
             client.post_metric(event_name: event_name, payload: error_payload)
-          rescue StandardError
+          rescue
           ensure
             next
           end
@@ -121,13 +120,12 @@ module ApmBro
           rails_env: rails_env,
           params: safe_params(data),
           user_agent: safe_user_agent(data),
-          user_email: extract_user_email(data),
           user_id: extract_user_id(data),
           memory_usage: memory_usage_mb,
           gc_stats: gc_stats,
           sql_count: sql_count(data),
           sql_queries: sql_queries,
-          http_outgoing: (Thread.current[:apm_bro_http_events] || []),
+          http_outgoing: Thread.current[:apm_bro_http_events] || [],
           cache_events: cache_events,
           redis_events: redis_events,
           cache_hits: cache_hits(data),
@@ -145,13 +143,17 @@ module ApmBro
     def self.safe_path(data)
       path = data[:path] || (data[:request] && data[:request].path)
       path.to_s
-    rescue StandardError
+    rescue
       ""
     end
 
     def self.safe_host
       if defined?(Rails) && Rails.respond_to?(:application)
-        Rails.application.class.module_parent_name rescue ""
+        begin
+          Rails.application.class.module_parent_name
+        rescue
+          ""
+        end
       else
         ""
       end
@@ -171,7 +173,7 @@ module ApmBro
       params = data[:params]
       begin
         params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
-      rescue StandardError
+      rescue
       end
 
       unless params.is_a?(Hash)
@@ -190,7 +192,7 @@ module ApmBro
 
       # Truncate deeply to keep payload small and safe
       truncate_value(filtered)
-    rescue StandardError
+    rescue
       {}
     end
 
@@ -198,7 +200,7 @@ module ApmBro
     def self.truncate_value(value, max_str: 200, max_array: 20, max_hash_keys: 30)
       case value
       when String
-        value.length > max_str ? value[0, max_str] + "…" : value
+        (value.length > max_str) ? value[0, max_str] + "…" : value
       when Numeric, TrueClass, FalseClass, NilClass
         value
       when Array
@@ -209,7 +211,7 @@ module ApmBro
           memo[k] = truncate_value(v, max_str: max_str, max_array: max_array, max_hash_keys: max_hash_keys)
         end
       else
-        value.to_s.length > max_str ? value.to_s[0, max_str] + "…" : value.to_s
+        (value.to_s.length > max_str) ? value.to_s[0, max_str] + "…" : value.to_s
       end
     end
 
@@ -233,7 +235,11 @@ module ApmBro
             ua = headers["HTTP_USER_AGENT"] || headers["User-Agent"] || headers["user-agent"]
             return ua.to_s[0..200]
           elsif headers.respond_to?(:to_h)
-            h = headers.to_h rescue {}
+            h = begin
+              headers.to_h
+            rescue
+              {}
+            end
             ua = h["HTTP_USER_AGENT"] || h["User-Agent"] || h["user-agent"]
             return ua.to_s[0..200]
           end
@@ -246,22 +252,26 @@ module ApmBro
         end
 
         ""
-      rescue StandardError
+      rescue
         ""
       end
-    rescue StandardError
+    rescue
       ""
     end
 
     def self.memory_usage_mb
       if defined?(GC) && GC.respond_to?(:stat)
         # Get memory usage in MB
-        memory_kb = `ps -o rss= -p #{Process.pid}`.to_i rescue 0
+        memory_kb = begin
+          `ps -o rss= -p #{Process.pid}`.to_i
+        rescue
+          0
+        end
         (memory_kb / 1024.0).round(2)
       else
         0
       end
-    rescue StandardError
+    rescue
       0
     end
 
@@ -277,7 +287,7 @@ module ApmBro
       else
         {}
       end
-    rescue StandardError
+    rescue
       {}
     end
 
@@ -287,11 +297,15 @@ module ApmBro
         data[:sql_count]
       elsif defined?(ActiveRecord) && ActiveRecord::Base.connection
         # Try to get from ActiveRecord connection
-        ActiveRecord::Base.connection.query_cache.size rescue 0
+        begin
+          ActiveRecord::Base.connection.query_cache.size
+        rescue
+          0
+        end
       else
         0
       end
-    rescue StandardError
+    rescue
       0
     end
 
@@ -299,11 +313,15 @@ module ApmBro
       if data[:cache_hits]
         data[:cache_hits]
       elsif defined?(Rails) && Rails.cache.respond_to?(:stats)
-        Rails.cache.stats[:hits] rescue 0
+        begin
+          Rails.cache.stats[:hits]
+        rescue
+          0
+        end
       else
         0
       end
-    rescue StandardError
+    rescue
       0
     end
 
@@ -311,26 +329,22 @@ module ApmBro
       if data[:cache_misses]
         data[:cache_misses]
       elsif defined?(Rails) && Rails.cache.respond_to?(:stats)
-        Rails.cache.stats[:misses] rescue 0
+        begin
+          Rails.cache.stats[:misses]
+        rescue
+          0
+        end
       else
         0
       end
-    rescue StandardError
+    rescue
       0
     end
 
-    def self.extract_user_email(data)
-      data[:headers].env['warden'].user.email
-    rescue StandardError
-      nil
-    end
-
     def self.extract_user_id(data)
-      data[:headers].env['warden'].user.id
-    rescue StandardError
+      data[:headers].env["warden"].user.id
+    rescue
       nil
     end
   end
 end
-
-

data/lib/apm_bro/version.rb

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