apm_bro 0.1.14 → 0.1.16

data/lib/apm_bro/error_middleware.rb

@@ -4,7 +4,7 @@ require "rack"
 
 module ApmBro
   class ErrorMiddleware
-    EVENT_NAME = "exception.uncaught".freeze
+    EVENT_NAME = "exception.uncaught"
 
     def initialize(app, client: Client.new)
       @app = app
@@ -20,7 +20,7 @@ module ApmBro
         event_name = exception.class.name.to_s
         event_name = EVENT_NAME if event_name.empty?
         @client.post_metric(event_name: event_name, payload: payload)
-      rescue StandardError
+      rescue
         # Never let APM reporting interfere with the host app
       end
       raise
@@ -36,14 +36,13 @@ module ApmBro
         message: truncate(exception.message.to_s, 1000),
         backtrace: safe_backtrace(exception),
         occurred_at: Time.now.utc.to_i,
-        user_email: extract_user_email_from_env(env),
         rack:
           {
-            method: (req&.request_method),
-            path: (req&.path),
-            fullpath: (req&.fullpath),
-            ip: (req&.ip),
-            user_agent: truncate((req&.user_agent).to_s, 200),
+            method: req&.request_method,
+            path: req&.path,
+            fullpath: req&.fullpath,
+            ip: req&.ip,
+            user_agent: truncate(req&.user_agent.to_s, 200),
             params: safe_params(req),
             request_id: env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"],
             referer: truncate(env["HTTP_REFERER"].to_s, 500),
@@ -58,13 +57,13 @@ module ApmBro
 
     def rack_request(env)
       ::Rack::Request.new(env)
-    rescue StandardError
+    rescue
       nil
     end
 
     def safe_backtrace(exception)
       Array(exception.backtrace).first(50)
-    rescue StandardError
+    rescue
       []
     end
 
@@ -79,7 +78,7 @@ module ApmBro
         filtered.delete(k.to_sym)
       end
       JSON.parse(JSON.dump(filtered)) # ensure JSON-safe
-    rescue StandardError
+    rescue
       {}
     end
 
@@ -94,33 +93,20 @@ module ApmBro
       else
         ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
       end
-    rescue StandardError
+    rescue
       "development"
     end
 
     def safe_app_name
       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
     end
-
-    def extract_user_email_from_env(env)
-      return nil unless ApmBro.configuration.user_email_tracking_enabled
-
-      # Try to get user email from various sources in the Rack environment
-      request_data = {
-        request: rack_request(env),
-        session: env["rack.session"],
-        params: env["action_dispatch.request.parameters"] || {}
-      }
-
-      ApmBro.configuration.extract_user_email(request_data)
-    rescue StandardError
-      nil
-    end
   end
 end
-
-

data/lib/apm_bro/http_instrumentation.rb

@@ -5,12 +5,12 @@ require "net/http"
 
 module ApmBro
   module HttpInstrumentation
-    EVENT_NAME = "outgoing.http".freeze
+    EVENT_NAME = "outgoing.http"
 
     def self.install!(client: Client.new)
       install_net_http!(client)
       install_typhoeus!(client) if defined?(::Typhoeus)
-    rescue StandardError
+    rescue
       # Never raise from instrumentation install
     end
 
@@ -30,29 +30,33 @@ module ApmBro
             finish_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             duration_ms = ((finish_time - start_time) * 1000.0).round(2)
             begin
-              uri = URI.parse(req.uri ? req.uri.to_s : "http://#{@address}:#{@port}#{req.path}") rescue nil
+              uri = begin
+                URI.parse(req.uri ? req.uri.to_s : "http://#{@address}:#{@port}#{req.path}")
+              rescue
+                nil
+              end
 
               # Skip instrumentation for our own APM endpoint to prevent infinite loops,
               # but do NOT alter the original method's return value/control flow.
-              skip_instrumentation = (uri && (uri.to_s.include?("localhost") || uri.to_s.include?("uptime.aberatii.com")))
+              skip_instrumentation = uri && (uri.to_s.include?("localhost") || uri.to_s.include?("uptime.aberatii.com"))
 
               unless skip_instrumentation
                 payload = {
                   library: "net_http",
                   method: req.method,
-                  url: (uri && uri.to_s),
+                  url: uri && uri.to_s,
                   host: (uri && uri.host) || @address,
                   path: (uri && uri.path) || req.path,
-                  status: (response && response.code.to_i),
+                  status: response && response.code.to_i,
                   duration_ms: duration_ms,
-                  exception: (error && error.class.name)
+                  exception: error && error.class.name
                 }
                 # Accumulate per-request; only send with controller metric
                 if Thread.current[:apm_bro_http_events]
                   Thread.current[:apm_bro_http_events] << payload
                 end
               end
-            rescue StandardError
+            rescue
             end
           end
         end
@@ -73,18 +77,22 @@ module ApmBro
             finish_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             duration_ms = ((finish_time - start_time) * 1000.0).round(2)
             begin
-              req_url = respond_to?(:url) ? url : (respond_to?(:base_url) ? base_url : nil)
+              req_url = if respond_to?(:url)
+                url
+              else
+                (respond_to?(:base_url) ? base_url : nil)
+              end
 
               # Skip instrumentation for our own APM endpoint to prevent infinite loops,
               # but do NOT alter the original method's return value/control flow.
-              skip_instrumentation = (req_url && req_url.include?("localhost:3100/apm/v1/metrics"))
+              skip_instrumentation = req_url && req_url.include?("localhost:3100/apm/v1/metrics")
 
               unless skip_instrumentation
                 payload = {
                   library: "typhoeus",
-                  method: respond_to?(:options) && options[:method] ? options[:method].to_s.upcase : nil,
+                  method: (respond_to?(:options) && options[:method]) ? options[:method].to_s.upcase : nil,
                   url: req_url,
-                  status: (response && response.code),
+                  status: response && response.code,
                   duration_ms: duration_ms
                 }
                 # Accumulate per-request; only send with controller metric
@@ -92,16 +100,14 @@ module ApmBro
                   Thread.current[:apm_bro_http_events] << payload
                 end
               end
-            rescue StandardError
+            rescue
             end
           end
         end
       end
 
       ::Typhoeus::Request.prepend(mod) unless ::Typhoeus::Request.ancestors.include?(mod)
-    rescue StandardError
+    rescue
     end
   end
 end
-
-

data/lib/apm_bro/job_sql_tracking_middleware.rb

@@ -19,7 +19,7 @@ module ApmBro
           ApmBro::MemoryTrackingSubscriber.start_request_tracking
         end
       end
-    rescue StandardError
+    rescue
       # Never raise from instrumentation install
     end
   end

data/lib/apm_bro/job_subscriber.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
-require "active_support/notifications"
+begin
+  require "active_support/notifications"
+rescue LoadError
+  # ActiveSupport not available
+end
 
 module ApmBro
   class JobSubscriber
-    JOB_EVENT_NAME = "perform.active_job".freeze
-    JOB_EXCEPTION_EVENT_NAME = "exception.active_job".freeze
+    JOB_EVENT_NAME = "perform.active_job"
+    JOB_EXCEPTION_EVENT_NAME = "exception.active_job"
 
     def self.subscribe!(client: Client.new)
       # Track job execution
@@ -15,14 +19,14 @@ module ApmBro
           if ApmBro.configuration.excluded_job?(job_class_name)
             next
           end
-        rescue StandardError
+        rescue
         end
 
         duration_ms = ((finished - started) * 1000.0).round(2)
-        
+
         # 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
@@ -50,7 +54,7 @@ module ApmBro
             duration_seconds: lightweight_memory[:duration_seconds]
           }
         end
-        
+
         payload = {
           job_class: data[:job].class.name,
           job_id: data[:job].job_id,
@@ -67,7 +71,7 @@ module ApmBro
           memory_performance: memory_performance,
           logs: ApmBro.logger.logs
         }
-        
+
         client.post_metric(event_name: name, payload: payload)
       end
 
@@ -78,15 +82,15 @@ module ApmBro
           if ApmBro.configuration.excluded_job?(job_class_name)
             next
           end
-        rescue StandardError
+        rescue
         end
 
         duration_ms = ((finished - started) * 1000.0).round(2)
         exception = data[:exception_object]
-        
+
         # 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
@@ -114,7 +118,7 @@ module ApmBro
             duration_seconds: lightweight_memory[:duration_seconds]
           }
         end
-        
+
         payload = {
           job_class: data[:job].class.name,
           job_id: data[:job].job_id,
@@ -134,11 +138,11 @@ module ApmBro
           memory_performance: memory_performance,
           logs: ApmBro.logger.logs
         }
-        
+
         event_name = exception&.class&.name || "ActiveJob::Exception"
         client.post_metric(event_name: event_name, payload: payload, error: true)
       end
-    rescue StandardError
+    rescue
       # Never raise from instrumentation install
     end
 
@@ -146,27 +150,31 @@ module ApmBro
 
     def self.safe_arguments(arguments)
       return [] unless arguments.is_a?(Array)
-      
+
       # Limit and sanitize job arguments
       arguments.first(10).map do |arg|
         case arg
         when String
-          arg.length > 200 ? arg[0, 200] + "..." : arg
+          (arg.length > 200) ? arg[0, 200] + "..." : arg
         when Hash
           # Filter sensitive keys and limit size
           filtered = arg.except(*%w[password token secret key])
-          filtered.keys.size > 20 ? filtered.first(20).to_h : filtered
+          (filtered.keys.size > 20) ? filtered.first(20).to_h : filtered
         when Array
           arg.first(5)
         when ActiveRecord::Base
           # Handle ActiveRecord objects safely
-          "#{arg.class.name}##{arg.id rescue 'unknown'}"
+          "#{arg.class.name}##{begin
+            arg.id
+          rescue
+            "unknown"
+          end}"
         else
           # Convert to string and truncate, but avoid object inspection
-          arg.to_s.length > 200 ? arg.to_s[0, 200] + "..." : arg.to_s
+          (arg.to_s.length > 200) ? arg.to_s[0, 200] + "..." : arg.to_s
         end
       end
-    rescue StandardError
+    rescue
       []
     end
 
@@ -176,13 +184,17 @@ module ApmBro
       else
         ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development"
       end
-    rescue StandardError
+    rescue
       "development"
     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
@@ -191,12 +203,16 @@ module ApmBro
     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
 
@@ -212,7 +228,7 @@ module ApmBro
       else
         {}
       end
-    rescue StandardError
+    rescue
       {}
     end
   end

data/lib/apm_bro/lightweight_memory_tracker.rb

@@ -7,7 +7,7 @@ module ApmBro
 
     def self.start_request_tracking
       return unless ApmBro.configuration.memory_tracking_enabled
-      
+
       # Only track essential metrics to minimize overhead
       Thread.current[THREAD_LOCAL_KEY] = {
         gc_before: lightweight_gc_stats,
@@ -19,13 +19,13 @@ module ApmBro
     def self.stop_request_tracking
       events = Thread.current[THREAD_LOCAL_KEY]
       Thread.current[THREAD_LOCAL_KEY] = nil
-      
+
       return {} unless events
-      
+
       # Calculate only essential metrics
       gc_after = lightweight_gc_stats
       memory_after = lightweight_memory_usage
-      
+
       {
         memory_growth_mb: (memory_after - events[:memory_before]).round(2),
         gc_count_increase: (gc_after[:count] || 0) - (events[:gc_before][:count] || 0),
@@ -39,24 +39,24 @@ module ApmBro
     def self.lightweight_memory_usage
       # Use only GC stats for memory estimation (no system calls)
       return 0 unless defined?(GC) && GC.respond_to?(:stat)
-      
+
       gc_stats = GC.stat
       heap_pages = gc_stats[:heap_allocated_pages] || 0
       # Rough estimation: 4KB per page
       (heap_pages * 4) / 1024.0 # Convert to MB
-    rescue StandardError
+    rescue
       0
     end
 
     def self.lightweight_gc_stats
       return {} unless defined?(GC) && GC.respond_to?(:stat)
-      
+
       stats = GC.stat
       {
         count: stats[:count] || 0,
         heap_allocated_pages: stats[:heap_allocated_pages] || 0
       }
-    rescue StandardError
+    rescue
       {}
     end
   end

data/lib/apm_bro/logger.rb

@@ -11,12 +11,12 @@ module ApmBro
     }.freeze
 
     # ANSI color codes
-    COLOR_RESET = "\033[0m".freeze
-    COLOR_DEBUG = "\033[36m".freeze  # Cyan
-    COLOR_INFO = "\033[32m".freeze   # Green
-    COLOR_WARN = "\033[33m".freeze   # Yellow
-    COLOR_ERROR = "\033[31m".freeze # Red
-    COLOR_FATAL = "\033[35m".freeze  # Magenta
+    COLOR_RESET = "\033[0m"
+    COLOR_DEBUG = "\033[36m"  # Cyan
+    COLOR_INFO = "\033[32m"   # Green
+    COLOR_WARN = "\033[33m"   # Yellow
+    COLOR_ERROR = "\033[31m" # Red
+    COLOR_FATAL = "\033[35m"  # Magenta
 
     def initialize
       @thread_logs_key = :apm_bro_logs
@@ -72,7 +72,7 @@ module ApmBro
 
     def print_log(severity, message, timestamp)
       formatted_message = format_log_message(severity, message, timestamp)
-      
+
       if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
         # Use Rails logger if available (Rails handles its own color formatting)
         case severity
@@ -92,7 +92,7 @@ module ApmBro
         colored_message = format_log_message_with_color(severity, message, timestamp)
         $stdout.puts(colored_message)
       end
-    rescue StandardError
+    rescue
       # Never let logging break the application
       $stdout.puts("[ApmBro] #{severity.to_s.upcase}: #{message}")
     end
@@ -125,4 +125,3 @@ module ApmBro
     end
   end
 end
-

data/lib/apm_bro/memory_helpers.rb

@@ -3,17 +3,17 @@
 module ApmBro
   module MemoryHelpers
     # Helper methods for memory tracking and leak detection
-    
+
     # Take a memory snapshot with a custom label
     def self.snapshot(label)
       ApmBro::MemoryTrackingSubscriber.take_memory_snapshot(label)
     end
-    
+
     # Get current memory analysis
     def self.analyze_memory
       ApmBro::MemoryLeakDetector.get_memory_analysis
     end
-    
+
     # Check for memory leaks
     def self.check_for_leaks
       analysis = analyze_memory
@@ -23,26 +23,26 @@ module ApmBro
           puts "  - Growth: #{alert[:memory_growth_mb]}MB"
           puts "  - Rate: #{alert[:growth_rate_mb_per_second]}MB/sec"
           puts "  - Confidence: #{(alert[:confidence] * 100).round(1)}%"
-          puts "  - Recent controllers: #{alert[:recent_controllers].join(', ')}"
+          puts "  - Recent controllers: #{alert[:recent_controllers].join(", ")}"
         end
       else
         puts "✅ No memory leaks detected"
       end
       analysis
     end
-    
+
     # Get memory usage summary
     def self.memory_summary
       analysis = analyze_memory
       return "Insufficient data" if analysis[:status] == "insufficient_data"
-      
+
       memory_stats = analysis[:memory_stats]
       puts "📊 Memory Summary:"
       puts "  - Current: #{memory_stats[:mean]}MB (avg)"
       puts "  - Range: #{memory_stats[:min]}MB - #{memory_stats[:max]}MB"
       puts "  - Volatility: #{memory_stats[:std_dev]}MB"
       puts "  - Samples: #{analysis[:sample_count]}"
-      
+
       if analysis[:memory_trend][:slope] > 0
         puts "  - Trend: ↗️ Growing at #{analysis[:memory_trend][:slope].round(3)}MB/sec"
       elsif analysis[:memory_trend][:slope] < 0
@@ -50,16 +50,16 @@ module ApmBro
       else
         puts "  - Trend: ➡️ Stable"
       end
-      
+
       analysis
     end
-    
+
     # Monitor memory during a block execution
     def self.monitor_memory(label, &block)
       snapshot("before_#{label}")
       result = yield
       snapshot("after_#{label}")
-      
+
       # Get the difference
       analysis = analyze_memory
       if analysis[:memory_stats]
@@ -67,15 +67,15 @@ module ApmBro
         puts "  - Memory change: #{analysis[:memory_stats][:max] - analysis[:memory_stats][:min]}MB"
         puts "  - Peak usage: #{analysis[:memory_stats][:max]}MB"
       end
-      
+
       result
     end
-    
+
     # Clear memory history (useful for testing)
     def self.clear_history
       ApmBro::MemoryLeakDetector.clear_history
     end
-    
+
     # Get top memory allocating classes
     def self.top_allocators
       # This would need to be called from within a request context