apm_bro 0.1.14 → 0.1.16

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,

data/lib/apm_bro/memory_tracking_subscriber.rb

@@ -5,12 +5,12 @@ require "active_support/notifications"
 module ApmBro
   class MemoryTrackingSubscriber
     # Object allocation events
-    ALLOCATION_EVENT = "object_allocations.active_support".freeze
-    
+    ALLOCATION_EVENT = "object_allocations.active_support"
+
     THREAD_LOCAL_KEY = :apm_bro_memory_events
     # Consider objects larger than this many bytes as "large"
     LARGE_OBJECT_THRESHOLD = 1_000_000 # 1MB threshold for large objects
-    
+
     # Performance optimization settings
     ALLOCATION_SAMPLING_RATE = 1 # Track all when enabled (adjust in production)
     MAX_ALLOCATIONS_PER_REQUEST = 1000 # Limit allocations tracked per request
@@ -28,18 +28,18 @@ module ApmBro
             next unless rand < ALLOCATION_SAMPLING_RATE
             track_allocation(data, started, finished)
           end
-        rescue StandardError
+        rescue
           # Allocation tracking might not be available in all Ruby versions
         end
       end
-    rescue StandardError
+    rescue
       # Never raise from instrumentation install
     end
 
     def self.start_request_tracking
       # Only track if memory tracking is enabled
       return unless ApmBro.configuration.memory_tracking_enabled
-      
+
       Thread.current[THREAD_LOCAL_KEY] = {
         allocations: [],
         memory_snapshots: [],
@@ -54,7 +54,7 @@ module ApmBro
     def self.stop_request_tracking
       events = Thread.current[THREAD_LOCAL_KEY]
       Thread.current[THREAD_LOCAL_KEY] = nil
-      
+
       if events
         events[:gc_after] = gc_stats
         events[:memory_after] = memory_usage_mb
@@ -67,20 +67,20 @@ module ApmBro
           events[:large_objects] = sample_large_objects
         end
       end
-      
+
       events || {}
     end
 
     def self.track_allocation(data, started, finished)
       return unless Thread.current[THREAD_LOCAL_KEY]
-      
+
       # Only track if we have meaningful allocation data
       return unless data.is_a?(Hash) && data[:count] && data[:size]
-      
+
       # Limit allocations per request to prevent memory bloat
       allocations = Thread.current[THREAD_LOCAL_KEY][:allocations]
       return if allocations.length >= MAX_ALLOCATIONS_PER_REQUEST
-      
+
       # Simplified allocation tracking (avoid expensive operations)
       allocation = {
         class_name: data[:class_name] || "Unknown",
@@ -88,7 +88,7 @@ module ApmBro
         size: data[:size]
         # Removed expensive fields: duration_ms, timestamp, memory_usage
       }
-      
+
       # Track large object allocations (these are rare and important)
       if data[:size] > LARGE_OBJECT_THRESHOLD
         large_object = allocation.merge(
@@ -97,13 +97,13 @@ module ApmBro
         )
         Thread.current[THREAD_LOCAL_KEY][:large_objects] << large_object
       end
-      
+
       Thread.current[THREAD_LOCAL_KEY][:allocations] << allocation
     end
 
     def self.take_memory_snapshot(label = nil)
       return unless Thread.current[THREAD_LOCAL_KEY]
-      
+
       snapshot = {
         label: label || "snapshot_#{Time.now.to_i}",
         memory_usage: memory_usage_mb,
@@ -112,45 +112,45 @@ module ApmBro
         object_count: object_count,
         heap_pages: heap_pages
       }
-      
+
       Thread.current[THREAD_LOCAL_KEY][:memory_snapshots] << snapshot
     end
 
     def self.analyze_memory_performance(memory_events)
       return {} if memory_events.empty?
-      
+
       allocations = memory_events[:allocations] || []
       large_objects = memory_events[:large_objects] || []
       snapshots = memory_events[:memory_snapshots] || []
-      
+
       # Calculate memory growth
       memory_growth = 0
       if memory_events[:memory_before] && memory_events[:memory_after]
         memory_growth = memory_events[:memory_after] - memory_events[:memory_before]
       end
-      
+
       # Calculate allocation totals
       total_allocations = allocations.sum { |a| a[:count] }
       total_allocated_size = allocations.sum { |a| a[:size] }
-      
+
       # Group allocations by class
       allocations_by_class = allocations.group_by { |a| a[:class_name] }
-                                      .transform_values { |allocs| 
-                                        { 
-                                          count: allocs.sum { |a| a[:count] },
-                                          size: allocs.sum { |a| a[:size] }
-                                        }
-                                      }
-      
+        .transform_values { |allocs|
+        {
+          count: allocs.sum { |a| a[:count] },
+          size: allocs.sum { |a| a[:size] }
+        }
+      }
+
       # Find top allocating classes
       top_allocating_classes = allocations_by_class.sort_by { |_, data| -data[:size] }.first(10)
-      
+
       # Analyze large objects
       large_object_analysis = analyze_large_objects(large_objects)
-      
+
       # Analyze memory snapshots for trends
       memory_trends = analyze_memory_trends(snapshots)
-      
+
       # Calculate GC efficiency
       gc_efficiency = calculate_gc_efficiency(memory_events[:gc_before], memory_events[:gc_after])
 
@@ -164,13 +164,13 @@ module ApmBro
           object_type_deltas[k] = (after[k] || 0) - (before[k] || 0)
         end
       end
-      
+
       {
         memory_growth_mb: memory_growth.round(2),
         total_allocations: total_allocations,
         total_allocated_size: total_allocated_size,
         total_allocated_size_mb: (total_allocated_size / 1_000_000.0).round(2),
-        allocations_per_second: memory_events[:duration_seconds] > 0 ? 
+        allocations_per_second: (memory_events[:duration_seconds] > 0) ?
           (total_allocations.to_f / memory_events[:duration_seconds]).round(2) : 0,
         top_allocating_classes: top_allocating_classes.map { |class_name, data|
           {
@@ -190,13 +190,13 @@ module ApmBro
 
     def self.analyze_large_objects(large_objects)
       return {} if large_objects.empty?
-      
+
       {
         count: large_objects.count,
         total_size_mb: large_objects.sum { |obj| obj[:size_mb] }.round(2),
         largest_object_mb: large_objects.max_by { |obj| obj[:size_mb] }[:size_mb],
         by_class: large_objects.group_by { |obj| obj[:class_name] }
-                              .transform_values(&:count)
+          .transform_values(&:count)
       }
     end
 
@@ -219,15 +219,23 @@ module ApmBro
           # Randomly sample to control overhead
           next unless rand < LARGE_OBJECT_SAMPLE_RATE
 
-          size = ObjectSpace.memsize_of(obj) rescue 0
+          size = begin
+            ObjectSpace.memsize_of(obj)
+          rescue
+            0
+          end
           next unless size && size > LARGE_OBJECT_THRESHOLD
 
-          klass = (obj.respond_to?(:class) && obj.class) ? obj.class.name : "Unknown" rescue "Unknown"
-          results << { class_name: klass, size: size, size_mb: (size / 1_000_000.0).round(2) }
+          klass = begin
+            (obj.respond_to?(:class) && obj.class) ? obj.class.name : "Unknown"
+          rescue
+            "Unknown"
+          end
+          results << {class_name: klass, size: size, size_mb: (size / 1_000_000.0).round(2)}
 
           break if results.length >= MAX_LARGE_OBJECTS
         end
-      rescue StandardError
+      rescue
         # Best-effort only
       end
 
@@ -241,24 +249,24 @@ module ApmBro
       else
         {}
       end
-    rescue StandardError
+    rescue
       {}
     end
 
     def self.analyze_memory_trends(snapshots)
       return {} if snapshots.length < 2
-      
+
       # Calculate memory growth rate between snapshots
       memory_values = snapshots.map { |s| s[:memory_usage] }
       memory_growth_rates = []
-      
+
       (1...memory_values.length).each do |i|
-        growth = memory_values[i] - memory_values[i-1]
-        time_diff = snapshots[i][:timestamp] - snapshots[i-1][:timestamp]
-        rate = time_diff > 0 ? growth / time_diff : 0
+        growth = memory_values[i] - memory_values[i - 1]
+        time_diff = snapshots[i][:timestamp] - snapshots[i - 1][:timestamp]
+        rate = (time_diff > 0) ? growth / time_diff : 0
         memory_growth_rates << rate
       end
-      
+
       {
         average_growth_rate_mb_per_second: memory_growth_rates.sum / memory_growth_rates.length,
         max_growth_rate_mb_per_second: memory_growth_rates.max,
@@ -270,12 +278,12 @@ module ApmBro
 
     def self.calculate_gc_efficiency(gc_before, gc_after)
       return {} unless gc_before && gc_after
-      
+
       {
         gc_count_increase: (gc_after[:count] || 0) - (gc_before[:count] || 0),
         heap_pages_increase: (gc_after[:heap_allocated_pages] || 0) - (gc_before[:heap_allocated_pages] || 0),
         objects_allocated: (gc_after[:total_allocated_objects] || 0) - (gc_before[:total_allocated_objects] || 0),
-        gc_frequency: gc_after[:count] && gc_before[:count] ? 
+        gc_frequency: (gc_after[:count] && gc_before[:count]) ?
           (gc_after[:count] - gc_before[:count]).to_f / [gc_after[:count], 1].max : 0
       }
     end
@@ -284,12 +292,12 @@ module ApmBro
       # Use cached memory calculation to avoid expensive system calls
       @memory_cache ||= {}
       cache_key = Process.pid
-      
+
       # Cache memory usage for 1 second to avoid repeated system calls
       if @memory_cache[cache_key] && (Time.now - @memory_cache[cache_key][:timestamp]) < 1
         return @memory_cache[cache_key][:memory]
       end
-      
+
       memory = if defined?(GC) && GC.respond_to?(:stat)
         # Use GC stats as a proxy for memory usage (much faster than ps)
         gc_stats = GC.stat
@@ -299,10 +307,10 @@ module ApmBro
       else
         0
       end
-      
-      @memory_cache[cache_key] = { memory: memory, timestamp: Time.now }
+
+      @memory_cache[cache_key] = {memory: memory, timestamp: Time.now}
       memory
-    rescue StandardError
+    rescue
       0
     end
 
@@ -321,7 +329,7 @@ module ApmBro
       else
         {}
       end
-    rescue StandardError
+    rescue
       {}
     end
 
@@ -331,7 +339,7 @@ module ApmBro
       else
         0
       end
-    rescue StandardError
+    rescue
       0
     end
 
@@ -341,7 +349,7 @@ module ApmBro
       else
         0
       end
-    rescue StandardError
+    rescue
       0
     end
 

data/lib/apm_bro/railtie.rb

@@ -1,13 +1,19 @@
 # frozen_string_literal: true
 
-require "rails/railtie"
+begin
+  require "rails/railtie"
+rescue LoadError
+  # Rails not available, skip railtie definition
+end
+
+# Only define Railtie if Rails is available
+if defined?(Rails) && defined?(Rails::Railtie)
+  module ApmBro
+    class Railtie < ::Rails::Railtie
+      initializer "apm_bro.configure" do |_app|
+        # Allow host app to set config in Rails config, credentials, or ENV.
+        # If host app sets config.x.apm_bro, mirror into gem configuration.
 
-module ApmBro
-  class Railtie < ::Rails::Railtie
-    initializer "apm_bro.configure" do |_app|
-      # Allow host app to set config in Rails config, credentials, or ENV.
-      # If host app sets config.x.apm_bro, mirror into gem configuration.
-      begin
         if Rails.application.config.x.respond_to?(:apm_bro)
           xcfg = Rails.application.config.x.apm_bro
           ApmBro.configure do |cfg|
@@ -15,22 +21,20 @@ module ApmBro
             cfg.enabled = xcfg.enabled if xcfg.respond_to?(:enabled)
           end
         end
-      rescue StandardError
+      rescue
       end
-    end
 
-    initializer "apm_bro.subscribe" do |app|
-      app.config.after_initialize do
-        begin
+      initializer "apm_bro.subscribe" do |app|
+        app.config.after_initialize do
           ApmBro::Subscriber.subscribe!(client: ApmBro::Client.new)
           # Install outgoing HTTP instrumentation
           require "apm_bro/http_instrumentation"
           ApmBro::HttpInstrumentation.install!(client: ApmBro::Client.new)
-          
+
           # Install SQL query tracking
           require "apm_bro/sql_subscriber"
           ApmBro::SqlSubscriber.subscribe!
-          
+
           # Install Rails cache tracking
           require "apm_bro/cache_subscriber"
           ApmBro::CacheSubscriber.subscribe!
@@ -42,18 +46,18 @@ module ApmBro
           # Install view rendering tracking
           require "apm_bro/view_rendering_subscriber"
           ApmBro::ViewRenderingSubscriber.subscribe!(client: ApmBro::Client.new)
-          
+
           # Install lightweight memory tracking (default)
           require "apm_bro/lightweight_memory_tracker"
           require "apm_bro/memory_leak_detector"
           ApmBro::MemoryLeakDetector.initialize_history
-          
+
           # Install detailed memory tracking only if enabled
           if ApmBro.configuration.allocation_tracking_enabled
             require "apm_bro/memory_tracking_subscriber"
             ApmBro::MemoryTrackingSubscriber.subscribe!(client: ApmBro::Client.new)
           end
-          
+
           # Install job tracking if ActiveJob is available
           if defined?(ActiveJob)
             require "apm_bro/job_subscriber"
@@ -61,15 +65,13 @@ module ApmBro
             ApmBro::JobSqlTrackingMiddleware.subscribe!
             ApmBro::JobSubscriber.subscribe!(client: ApmBro::Client.new)
           end
-        rescue StandardError
+        rescue
           # Never raise in Railtie init
         end
       end
-    end
 
-    # Insert Rack middleware early enough to observe uncaught exceptions
-    initializer "apm_bro.middleware" do |app|
-      begin
+      # Insert Rack middleware early enough to observe uncaught exceptions
+      initializer "apm_bro.middleware" do |app|
         require "apm_bro/error_middleware"
 
         if defined?(::ActionDispatch::DebugExceptions)
@@ -79,21 +81,17 @@ module ApmBro
         else
           app.config.middleware.use(::ApmBro::ErrorMiddleware)
         end
-      rescue StandardError
+      rescue
         # Never raise in Railtie init
       end
-    end
 
-    # Insert SQL tracking middleware
-    initializer "apm_bro.sql_tracking_middleware" do |app|
-      begin
+      # Insert SQL tracking middleware
+      initializer "apm_bro.sql_tracking_middleware" do |app|
         require "apm_bro/sql_tracking_middleware"
         app.config.middleware.use(::ApmBro::SqlTrackingMiddleware)
-      rescue StandardError
+      rescue
         # Never raise in Railtie init
       end
     end
   end
 end
-
-