apm_bro 0.1.13 → 0.1.15

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

data/lib/apm_bro/memory_leak_detector.rb

@@ -18,7 +18,7 @@ module ApmBro
 
     def self.record_memory_sample(sample_data)
       history = Thread.current[MEMORY_HISTORY_KEY] || initialize_history
-      
+
       sample = {
         timestamp: Time.now.utc.to_i,
         memory_usage: sample_data[:memory_usage] || 0,
@@ -29,15 +29,15 @@ module ApmBro
         controller: sample_data[:controller],
         action: sample_data[:action]
       }
-      
+
       history[:samples] << sample
-      
+
       # Clean up old samples
       cleanup_old_samples(history)
-      
+
       # Check for memory leaks
       check_for_memory_leaks(history)
-      
+
       history
     end
 
@@ -49,18 +49,18 @@ module ApmBro
     def self.check_for_memory_leaks(history)
       samples = history[:samples]
       return if samples.length < MIN_SAMPLES_FOR_LEAK_DETECTION
-      
+
       # Calculate memory growth trend
       memory_values = samples.map { |s| s[:memory_usage] }
       timestamps = samples.map { |s| s[:timestamp] }
-      
+
       # Use linear regression to detect upward trend
       trend = calculate_memory_trend(memory_values, timestamps)
-      
+
       # Check if memory is growing consistently
       if trend[:slope] > 0.1 && trend[:r_squared] > 0.7 # Growing with good correlation
         memory_growth = memory_values.last - memory_values.first
-        
+
         if memory_growth > MEMORY_GROWTH_THRESHOLD
           leak_alert = {
             detected_at: Time.now.utc.to_i,
@@ -71,9 +71,9 @@ module ApmBro
             time_window_seconds: timestamps.last - timestamps.first,
             recent_controllers: samples.last(5).map { |s| "#{s[:controller]}##{s[:action]}" }.uniq
           }
-          
+
           history[:leak_alerts] << leak_alert
-          
+
           # Only keep recent leak alerts
           history[:leak_alerts] = history[:leak_alerts].last(10)
         end
@@ -81,25 +81,25 @@ module ApmBro
     end
 
     def self.calculate_memory_trend(memory_values, timestamps)
-      return { slope: 0, r_squared: 0 } if memory_values.length < 2
-      
+      return {slope: 0, r_squared: 0} if memory_values.length < 2
+
       n = memory_values.length
       sum_x = timestamps.sum
       sum_y = memory_values.sum
       sum_xy = timestamps.zip(memory_values).sum { |x, y| x * y }
       sum_x2 = timestamps.sum { |x| x * x }
-      sum_y2 = memory_values.sum { |y| y * y }
-      
+      memory_values.sum { |y| y * y }
+
       # Calculate slope (m) and intercept (b) for y = mx + b
       slope = (n * sum_xy - sum_x * sum_y).to_f / (n * sum_x2 - sum_x * sum_x)
       intercept = (sum_y - slope * sum_x).to_f / n
-      
+
       # Calculate R-squared (coefficient of determination)
       y_mean = sum_y.to_f / n
-      ss_tot = memory_values.sum { |y| (y - y_mean) ** 2 }
-      ss_res = memory_values.zip(timestamps).sum { |y, x| (y - (slope * x + intercept)) ** 2 }
-      r_squared = ss_tot > 0 ? 1 - (ss_res / ss_tot) : 0
-      
+      ss_tot = memory_values.sum { |y| (y - y_mean)**2 }
+      ss_res = memory_values.zip(timestamps).sum { |y, x| (y - (slope * x + intercept))**2 }
+      r_squared = (ss_tot > 0) ? 1 - (ss_res / ss_tot) : 0
+
       {
         slope: slope,
         intercept: intercept,
@@ -110,25 +110,25 @@ module ApmBro
     def self.get_memory_analysis
       history = Thread.current[MEMORY_HISTORY_KEY] || initialize_history
       samples = history[:samples]
-      
-      return { status: "insufficient_data", sample_count: samples.length } if samples.length < 5
-      
+
+      return {status: "insufficient_data", sample_count: samples.length} if samples.length < 5
+
       memory_values = samples.map { |s| s[:memory_usage] }
       gc_counts = samples.map { |s| s[:gc_count] }
       object_counts = samples.map { |s| s[:object_count] }
-      
+
       # Calculate basic statistics
       memory_stats = calculate_stats(memory_values)
       gc_stats = calculate_stats(gc_counts)
       object_stats = calculate_stats(object_counts)
-      
+
       # Detect patterns
       memory_trend = calculate_memory_trend(memory_values, samples.map { |s| s[:timestamp] })
-      
+
       # Analyze recent activity
       recent_samples = samples.last(10)
       recent_controllers = recent_samples.map { |s| "#{s[:controller]}##{s[:action]}" }.tally
-      
+
       {
         status: "analyzed",
         sample_count: samples.length,
@@ -145,7 +145,7 @@ module ApmBro
 
     def self.calculate_stats(values)
       return {} if values.empty?
-      
+
       {
         min: values.min,
         max: values.max,
@@ -157,31 +157,31 @@ module ApmBro
 
     def self.calculate_standard_deviation(values)
       return 0 if values.length < 2
-      
+
       mean = values.sum.to_f / values.length
-      variance = values.sum { |v| (v - mean) ** 2 } / (values.length - 1)
+      variance = values.sum { |v| (v - mean)**2 } / (values.length - 1)
       Math.sqrt(variance).round(2)
     end
 
     def self.calculate_memory_efficiency(samples)
       return {} if samples.length < 2
-      
+
       # Calculate memory per object ratio
       memory_per_object = samples.map do |sample|
-        sample[:object_count] > 0 ? sample[:memory_usage] / sample[:object_count] : 0
+        (sample[:object_count] > 0) ? sample[:memory_usage] / sample[:object_count] : 0
       end
-      
+
       # Calculate GC efficiency (objects collected per GC cycle)
       gc_efficiency = []
       (1...samples.length).each do |i|
-        gc_delta = samples[i][:gc_count] - samples[i-1][:gc_count]
-        memory_delta = samples[i][:memory_usage] - samples[i-1][:memory_usage]
-        
+        gc_delta = samples[i][:gc_count] - samples[i - 1][:gc_count]
+        memory_delta = samples[i][:memory_usage] - samples[i - 1][:memory_usage]
+
         if gc_delta > 0 && memory_delta < 0
           gc_efficiency << (-memory_delta / gc_delta).round(2)
         end
       end
-      
+
       {
         average_memory_per_object_kb: (memory_per_object.sum / memory_per_object.length).round(2),
         gc_efficiency_mb_per_cycle: gc_efficiency.any? ? (gc_efficiency.sum / gc_efficiency.length).round(2) : 0,