apm_bro 0.1.14 → 0.1.15

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
-
-

data/lib/apm_bro/redis_subscriber.rb

@@ -6,7 +6,7 @@ module ApmBro
 
     def self.subscribe!
       install_redis_instrumentation!
-    rescue StandardError
+    rescue
       # Never raise from instrumentation install
     end
 
@@ -25,7 +25,7 @@ module ApmBro
       # Only instrument if Redis::Client actually has the call method
       # Check both public and private methods
       has_call = ::Redis::Client.instance_methods(false).include?(:call) ||
-                 ::Redis::Client.private_instance_methods(false).include?(:call)
+        ::Redis::Client.private_instance_methods(false).include?(:call)
       return unless has_call
 
       mod = Module.new do
@@ -41,7 +41,7 @@ module ApmBro
             end
           else
             # If not tracking, just pass through unchanged
-            super(*args, &block)
+            super
           end
         end
 
@@ -63,7 +63,6 @@ module ApmBro
           return yield unless Thread.current[RedisSubscriber::THREAD_LOCAL_KEY]
 
           start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          result = nil
           error = nil
           begin
             result = yield
@@ -90,7 +89,7 @@ module ApmBro
               if Thread.current[RedisSubscriber::THREAD_LOCAL_KEY]
                 Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] << event
               end
-            rescue StandardError
+            rescue
             end
           end
         end
@@ -99,7 +98,6 @@ module ApmBro
           return yield unless Thread.current[RedisSubscriber::THREAD_LOCAL_KEY]
 
           start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          result = nil
           begin
             result = yield
             result
@@ -119,7 +117,7 @@ module ApmBro
               if Thread.current[RedisSubscriber::THREAD_LOCAL_KEY]
                 Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] << event
               end
-            rescue StandardError
+            rescue
             end
           end
         end
@@ -128,7 +126,6 @@ module ApmBro
           return yield unless Thread.current[RedisSubscriber::THREAD_LOCAL_KEY]
 
           start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          result = nil
           begin
             result = yield
             result
@@ -148,7 +145,7 @@ module ApmBro
               if Thread.current[RedisSubscriber::THREAD_LOCAL_KEY]
                 Thread.current[RedisSubscriber::THREAD_LOCAL_KEY] << event
               end
-            rescue StandardError
+            rescue
             end
           end
         end
@@ -157,39 +154,41 @@ module ApmBro
           parts = Array(command).map(&:to_s)
           command_name = parts.first&.upcase
           key = parts[1]
-          args_count = parts.length > 1 ? parts.length - 1 : 0
+          args_count = (parts.length > 1) ? parts.length - 1 : 0
 
           {
             command: safe_command(command_name),
             key: safe_key(key),
             args_count: args_count
           }
-        rescue StandardError
-          { command: nil, key: nil, args_count: nil }
+        rescue
+          {command: nil, key: nil, args_count: nil}
         end
 
         def safe_command(cmd)
           return nil if cmd.nil?
           cmd.to_s[0, 20]
-        rescue StandardError
+        rescue
           nil
         end
 
         def safe_key(key)
           return nil if key.nil?
           s = key.to_s
-          s.length > 200 ? s[0, 200] + "…" : s
-        rescue StandardError
+          (s.length > 200) ? s[0, 200] + "…" : s
+        rescue
           nil
         end
 
         def safe_db(db)
-          Integer(db) rescue nil
+          Integer(db)
+        rescue
+          nil
         end
       end
 
       ::Redis::Client.prepend(mod) unless ::Redis::Client.ancestors.include?(mod)
-    rescue StandardError
+    rescue
       # Redis::Client may not be available or may have different structure
     end
 
@@ -204,7 +203,7 @@ module ApmBro
             event = build_event(name, data, duration_ms)
             Thread.current[THREAD_LOCAL_KEY] << event if event
           end
-        rescue StandardError
+        rescue
         end
       end
     end
@@ -221,7 +220,7 @@ module ApmBro
 
     def self.build_event(name, data, duration_ms)
       cmd = extract_command(data)
-      base = {
+      {
         event: name.to_s,
         command: cmd[:command],
         key: cmd[:key],
@@ -229,22 +228,21 @@ module ApmBro
         duration_ms: duration_ms,
         db: safe_db(data[:db])
       }
-      base
-    rescue StandardError
+    rescue
       nil
     end
 
     def self.extract_command(data)
-      return { command: nil, key: nil, args_count: nil } unless data.is_a?(Hash)
+      return {command: nil, key: nil, args_count: nil} unless data.is_a?(Hash)
 
-      if data[:command]
-        parts = Array(data[:command]).map(&:to_s)
+      parts = if data[:command]
+        Array(data[:command]).map(&:to_s)
       elsif data[:commands]
-        parts = Array(data[:commands]).flatten.map(&:to_s)
+        Array(data[:commands]).flatten.map(&:to_s)
       elsif data[:cmd]
-        parts = Array(data[:cmd]).map(&:to_s)
+        Array(data[:cmd]).map(&:to_s)
       else
-        parts = []
+        []
       end
 
       command_name = parts.first&.upcase
@@ -256,30 +254,29 @@ module ApmBro
         key: safe_key(key),
         args_count: args_count
       }
-    rescue StandardError
-      { command: nil, key: nil, args_count: nil }
+    rescue
+      {command: nil, key: nil, args_count: nil}
     end
 
     def self.safe_command(cmd)
       return nil if cmd.nil?
-      s = cmd.to_s[0, 20]
-      s
-    rescue StandardError
+      cmd.to_s[0, 20]
+    rescue
       nil
     end
 
     def self.safe_key(key)
       return nil if key.nil?
       s = key.to_s
-      s.length > 200 ? s[0, 200] + "…" : s
-    rescue StandardError
+      (s.length > 200) ? s[0, 200] + "…" : s
+    rescue
       nil
     end
 
     def self.safe_db(db)
-      Integer(db) rescue nil
+      Integer(db)
+    rescue
+      nil
     end
   end
 end
-
-