brainzlab 0.1.2 → 0.1.4

data/lib/brainzlab/instrumentation/rails_deprecation.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    class RailsDeprecation
+      class << self
+        def install!
+          return unless defined?(::Rails)
+          return if @installed
+
+          install_deprecation_subscriber!
+
+          @installed = true
+          BrainzLab.debug_log('Rails deprecation instrumentation installed')
+        end
+
+        def installed?
+          @installed == true
+        end
+
+        private
+
+        # ============================================
+        # deprecation.rails
+        # Fired when a deprecated Rails API is used
+        # ============================================
+        def install_deprecation_subscriber!
+          ActiveSupport::Notifications.subscribe('deprecation.rails') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            handle_deprecation(event)
+          end
+        end
+
+        def handle_deprecation(event)
+          payload = event.payload
+
+          message = payload[:message]
+          callstack = payload[:callstack]
+          gem_name = payload[:gem_name]
+          deprecation_horizon = payload[:deprecation_horizon]
+
+          # Extract relevant caller info
+          caller_info = extract_caller_info(callstack)
+
+          # Record breadcrumb with warning level
+          if BrainzLab.configuration.reflex_effectively_enabled?
+            BrainzLab::Reflex.add_breadcrumb(
+              "Deprecation: #{truncate_message(message)}",
+              category: 'rails.deprecation',
+              level: :warning,
+              data: {
+                message: truncate_message(message, 500),
+                gem_name: gem_name,
+                deprecation_horizon: deprecation_horizon,
+                caller: caller_info
+              }.compact
+            )
+          end
+
+          # Log to Recall for tracking
+          if BrainzLab.configuration.recall_effectively_enabled?
+            BrainzLab::Recall.warn(
+              "Rails deprecation warning",
+              message: truncate_message(message, 500),
+              gem_name: gem_name,
+              deprecation_horizon: deprecation_horizon,
+              caller: caller_info,
+              callstack: truncate_callstack(callstack)
+            )
+          end
+
+          # Track deprecation count in Pulse metrics
+          record_deprecation_metric(gem_name, deprecation_horizon)
+        rescue StandardError => e
+          BrainzLab.debug_log("Rails deprecation instrumentation failed: #{e.message}")
+        end
+
+        # ============================================
+        # Helper Methods
+        # ============================================
+        def extract_caller_info(callstack)
+          return nil unless callstack.is_a?(Array) && callstack.any?
+
+          # Find the first non-Rails, non-gem caller
+          app_caller = callstack.find do |line|
+            line_str = line.to_s
+            !line_str.include?('/gems/') &&
+              !line_str.include?('/ruby/') &&
+              !line_str.include?('/bundler/')
+          end
+
+          (app_caller || callstack.first).to_s
+        end
+
+        def truncate_callstack(callstack, max_lines = 5)
+          return nil unless callstack.is_a?(Array)
+
+          callstack.first(max_lines).map(&:to_s)
+        end
+
+        def truncate_message(message, max_length = 200)
+          return 'unknown' unless message
+
+          msg_str = message.to_s
+          if msg_str.length > max_length
+            "#{msg_str[0, max_length - 3]}..."
+          else
+            msg_str
+          end
+        end
+
+        def record_deprecation_metric(gem_name, horizon)
+          return unless BrainzLab.configuration.pulse_effectively_enabled?
+
+          # If Pulse has a counter/metric API, use it here
+          # For now, we just add a span to track it
+          tracer = BrainzLab::Pulse.tracer
+          return unless tracer.current_trace
+
+          span_data = {
+            span_id: SecureRandom.uuid,
+            name: 'rails.deprecation',
+            kind: 'internal',
+            started_at: Time.now,
+            ended_at: Time.now,
+            duration_ms: 0,
+            error: false,
+            data: {
+              'deprecation.gem_name' => gem_name,
+              'deprecation.horizon' => horizon
+            }.compact
+          }
+
+          tracer.current_spans << span_data
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/railties.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    class Railties
+      # Thresholds for slow initializers (in milliseconds)
+      SLOW_INITIALIZER_THRESHOLD = 100   # 100ms
+      VERY_SLOW_INITIALIZER_THRESHOLD = 500  # 500ms
+
+      class << self
+        def install!
+          return unless defined?(::Rails)
+          return if @installed
+
+          install_load_config_initializer_subscriber!
+
+          @installed = true
+          BrainzLab.debug_log('Railties instrumentation installed')
+        end
+
+        def installed?
+          @installed == true
+        end
+
+        private
+
+        # ============================================
+        # load_config_initializer.railties
+        # Fired when each config initializer is loaded
+        # ============================================
+        def install_load_config_initializer_subscriber!
+          ActiveSupport::Notifications.subscribe('load_config_initializer.railties') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            handle_load_config_initializer(event)
+          end
+        end
+
+        def handle_load_config_initializer(event)
+          payload = event.payload
+          duration = event.duration.round(2)
+
+          initializer = payload[:initializer]
+
+          # Extract just the filename for cleaner display
+          initializer_name = extract_initializer_name(initializer)
+
+          # Determine level based on duration
+          level = case duration
+                  when 0...SLOW_INITIALIZER_THRESHOLD then :info
+                  when SLOW_INITIALIZER_THRESHOLD...VERY_SLOW_INITIALIZER_THRESHOLD then :warning
+                  else :error
+                  end
+
+          # Record breadcrumb (only for slow initializers to reduce noise during boot)
+          if duration >= 10 && BrainzLab.configuration.reflex_effectively_enabled?
+            BrainzLab::Reflex.add_breadcrumb(
+              "Initializer loaded: #{initializer_name} (#{duration}ms)",
+              category: 'rails.initializer',
+              level: level,
+              data: {
+                initializer: initializer_name,
+                path: initializer,
+                duration_ms: duration
+              }.compact
+            )
+          end
+
+          # Add Pulse span for tracking boot time
+          record_initializer_span(event, initializer_name, initializer, duration)
+
+          # Log slow initializers
+          log_slow_initializer(initializer_name, initializer, duration) if duration >= SLOW_INITIALIZER_THRESHOLD
+        rescue StandardError => e
+          BrainzLab.debug_log("Railties load_config_initializer instrumentation failed: #{e.message}")
+        end
+
+        # ============================================
+        # Span Recording
+        # ============================================
+        def record_initializer_span(event, name, path, duration)
+          return unless BrainzLab.configuration.pulse_effectively_enabled?
+
+          tracer = BrainzLab::Pulse.tracer
+          return unless tracer.current_trace
+
+          span_data = {
+            span_id: SecureRandom.uuid,
+            name: "rails.initializer.#{name}",
+            kind: 'internal',
+            started_at: event.time,
+            ended_at: event.end,
+            duration_ms: duration,
+            error: false,
+            data: {
+              'rails.initializer.name' => name,
+              'rails.initializer.path' => path
+            }.compact
+          }
+
+          tracer.current_spans << span_data
+        end
+
+        # ============================================
+        # Logging
+        # ============================================
+        def log_slow_initializer(name, path, duration)
+          return unless BrainzLab.configuration.recall_effectively_enabled?
+
+          level = duration >= VERY_SLOW_INITIALIZER_THRESHOLD ? :error : :warn
+
+          BrainzLab::Recall.send(
+            level,
+            "Slow initializer: #{name} (#{duration}ms)",
+            initializer: name,
+            path: path,
+            duration_ms: duration,
+            threshold_exceeded: duration >= VERY_SLOW_INITIALIZER_THRESHOLD ? 'critical' : 'warning'
+          )
+        end
+
+        # ============================================
+        # Helper Methods
+        # ============================================
+        def extract_initializer_name(path)
+          return 'unknown' unless path
+
+          # Extract filename without extension from path
+          # e.g., "/app/config/initializers/devise.rb" -> "devise"
+          File.basename(path.to_s, '.*')
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/redis.rb

@@ -18,7 +18,7 @@ module BrainzLab
           end
 
           @installed = true
-          BrainzLab.debug_log("Redis instrumentation installed")
+          BrainzLab.debug_log('Redis instrumentation installed')
         end
 
         def installed?
@@ -32,7 +32,7 @@ module BrainzLab
         private
 
         def redis_5_or_newer?
-          defined?(::Redis::VERSION) && Gem::Version.new(::Redis::VERSION) >= Gem::Version.new("5.0")
+          defined?(::Redis::VERSION) && Gem::Version.new(::Redis::VERSION) >= Gem::Version.new('5.0')
         end
 
         def install_middleware!
@@ -50,10 +50,6 @@ module BrainzLab
 
       # Middleware for Redis 5+ (RedisClient)
       module Middleware
-        def connect(redis_config)
-          super
-        end
-
         def call(command, redis_config)
           return super unless should_track?
 
@@ -78,10 +74,10 @@ module BrainzLab
           ignore.map(&:downcase).include?(cmd_name)
         end
 
-        def track_command(command, &block)
+        def track_command(command)
           return yield if should_skip_command?(command)
+
           started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          error_info = nil
 
           begin
             result = yield
@@ -94,9 +90,8 @@ module BrainzLab
           end
         end
 
-        def track_pipeline(commands, &block)
+        def track_pipeline(commands)
           started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          error_info = nil
 
           begin
             result = yield
@@ -119,7 +114,7 @@ module BrainzLab
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "Redis #{cmd_name}",
-              category: "redis",
+              category: 'redis',
               level: level,
               data: {
                 command: cmd_name,
@@ -138,14 +133,14 @@ module BrainzLab
 
         def record_pipeline(commands, started_at, error = nil)
           duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
-          cmd_names = commands.map { |c| c.first.to_s.upcase }.uniq.join(", ")
+          cmd_names = commands.map { |c| c.first.to_s.upcase }.uniq.join(', ')
           level = error ? :error : :info
 
           # Add breadcrumb for Reflex
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "Redis PIPELINE (#{commands.size} commands)",
-              category: "redis",
+              category: 'redis',
               level: level,
               data: {
                 commands: cmd_names,
@@ -157,7 +152,7 @@ module BrainzLab
           end
 
           # Record span for Pulse APM
-          record_pulse_span("PIPELINE", nil, duration_ms, error, commands.size)
+          record_pulse_span('PIPELINE', nil, duration_ms, error, commands.size)
         rescue StandardError => e
           BrainzLab.debug_log("Redis instrumentation error: #{e.message}")
         end
@@ -169,7 +164,7 @@ module BrainzLab
           span = {
             span_id: SecureRandom.uuid,
             name: "Redis #{command}",
-            kind: "redis",
+            kind: 'redis',
             started_at: Time.now.utc - (duration_ms / 1000.0),
             ended_at: Time.now.utc,
             duration_ms: duration_ms,
@@ -210,7 +205,6 @@ module BrainzLab
           return super if should_skip_command?(command)
 
           started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          error_info = nil
 
           begin
             result = super
@@ -227,7 +221,6 @@ module BrainzLab
           return super unless should_track?
 
           started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          error_info = nil
           commands = pipeline.commands
 
           begin
@@ -262,7 +255,7 @@ module BrainzLab
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "Redis #{cmd_name}",
-              category: "redis",
+              category: 'redis',
               level: level,
               data: {
                 command: cmd_name,
@@ -285,7 +278,7 @@ module BrainzLab
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "Redis PIPELINE (#{commands.size} commands)",
-              category: "redis",
+              category: 'redis',
               level: level,
               data: {
                 count: commands.size,
@@ -295,7 +288,7 @@ module BrainzLab
             )
           end
 
-          record_pulse_span("PIPELINE", nil, duration_ms, error, commands.size)
+          record_pulse_span('PIPELINE', nil, duration_ms, error, commands.size)
         rescue StandardError => e
           BrainzLab.debug_log("Redis instrumentation error: #{e.message}")
         end
@@ -307,7 +300,7 @@ module BrainzLab
           span = {
             span_id: SecureRandom.uuid,
             name: "Redis #{command}",
-            kind: "redis",
+            kind: 'redis',
             started_at: Time.now.utc - (duration_ms / 1000.0),
             ended_at: Time.now.utc,
             duration_ms: duration_ms,

data/lib/brainzlab/instrumentation/resque.rb

@@ -10,13 +10,13 @@ module BrainzLab
           install_hooks!
           install_failure_backend!
 
-          BrainzLab.debug_log("[Instrumentation] Resque instrumentation installed")
+          BrainzLab.debug_log('[Instrumentation] Resque instrumentation installed')
         end
 
         private
 
         def install_hooks!
-          ::Resque.before_fork do |job|
+          ::Resque.before_fork do |_job|
             # Clear any stale connections before forking
             BrainzLab::Recall.reset! if defined?(BrainzLab::Recall)
             BrainzLab::Pulse.reset! if defined?(BrainzLab::Pulse)
@@ -38,31 +38,30 @@ module BrainzLab
             end
 
             def save
-              job_class = @payload["class"] || "Unknown"
+              job_class = @payload['class'] || 'Unknown'
 
               if BrainzLab.configuration.reflex_effectively_enabled?
                 BrainzLab::Reflex.capture(@exception,
-                  tags: { job_class: job_class, queue: @queue, source: "resque" },
-                  extra: {
-                    worker: @worker.to_s,
-                    args: @payload["args"]
-                  }
-                )
+                                          tags: { job_class: job_class, queue: @queue, source: 'resque' },
+                                          extra: {
+                                            worker: @worker.to_s,
+                                            args: @payload['args']
+                                          })
               end
 
-              if BrainzLab.configuration.flux_effectively_enabled?
-                BrainzLab::Flux.increment("resque.job.failed", tags: { job_class: job_class, queue: @queue })
-              end
+              return unless BrainzLab.configuration.flux_effectively_enabled?
+
+              BrainzLab::Flux.increment('resque.job.failed', tags: { job_class: job_class, queue: @queue })
             end
           end
 
           # Add our failure backend to the chain
-          if defined?(::Resque::Failure)
-            ::Resque::Failure.backend = ::Resque::Failure::Multiple.new(
-              ::Resque::Failure.backend,
-              failure_backend
-            )
-          end
+          return unless defined?(::Resque::Failure)
+
+          ::Resque::Failure.backend = ::Resque::Failure::Multiple.new(
+            ::Resque::Failure.backend,
+            failure_backend
+          )
         end
       end
 
@@ -73,9 +72,9 @@ module BrainzLab
         end
 
         module ClassMethods
-          def around_perform_brainzlab(*args)
-            job_class = self.name
-            queue = Resque.queue_from_class(self) || "default"
+          def around_perform_brainzlab(*_args)
+            job_class = name
+            queue = Resque.queue_from_class(self) || 'default'
             started_at = Time.now
 
             BrainzLab::Context.current.set_context(
@@ -91,7 +90,7 @@ module BrainzLab
               if BrainzLab.configuration.pulse_effectively_enabled?
                 BrainzLab::Pulse.record_trace(
                   "job.#{job_class}",
-                  kind: "job",
+                  kind: 'job',
                   started_at: started_at,
                   ended_at: Time.now,
                   job_class: job_class,
@@ -101,8 +100,8 @@ module BrainzLab
 
               if BrainzLab.configuration.flux_effectively_enabled?
                 tags = { job_class: job_class, queue: queue }
-                BrainzLab::Flux.distribution("resque.job.duration_ms", duration_ms, tags: tags)
-                BrainzLab::Flux.increment("resque.job.processed", tags: tags)
+                BrainzLab::Flux.distribution('resque.job.duration_ms', duration_ms, tags: tags)
+                BrainzLab::Flux.increment('resque.job.processed', tags: tags)
               end
 
               BrainzLab.clear_context!

data/lib/brainzlab/instrumentation/sidekiq.rb

@@ -29,7 +29,7 @@ module BrainzLab
           end
 
           @installed = true
-          BrainzLab.debug_log("Sidekiq instrumentation installed")
+          BrainzLab.debug_log('Sidekiq instrumentation installed')
         end
 
         def installed?
@@ -47,11 +47,11 @@ module BrainzLab
           return yield unless should_trace?
 
           started_at = Time.now.utc
-          job_class = job["class"] || worker.class.name
-          job_id = job["jid"]
+          job_class = job['class'] || worker.class.name
+          job_id = job['jid']
 
           # Calculate queue wait time
-          enqueued_at = job["enqueued_at"] ? Time.at(job["enqueued_at"]) : nil
+          enqueued_at = job['enqueued_at'] ? Time.at(job['enqueued_at']) : nil
           queue_wait_ms = enqueued_at ? ((started_at - enqueued_at) * 1000).round(2) : nil
 
           # Extract parent trace context if present (distributed tracing)
@@ -63,9 +63,9 @@ module BrainzLab
           # Add breadcrumb
           BrainzLab::Reflex.add_breadcrumb(
             "Sidekiq #{job_class}",
-            category: "job.sidekiq",
+            category: 'job.sidekiq',
             level: :info,
-            data: { job_id: job_id, queue: queue, retry_count: job["retry_count"] }
+            data: { job_id: job_id, queue: queue, retry_count: job['retry_count'] }
           )
 
           # Initialize Pulse tracing
@@ -85,7 +85,7 @@ module BrainzLab
               queue: queue,
               started_at: started_at,
               queue_wait_ms: queue_wait_ms,
-              retry_count: job["retry_count"] || 0,
+              retry_count: job['retry_count'] || 0,
               parent_context: parent_context,
               error: error_occurred
             )
@@ -102,11 +102,11 @@ module BrainzLab
 
         def setup_context(job, queue)
           BrainzLab::Context.current.set_context(
-            job_class: job["class"],
-            job_id: job["jid"],
+            job_class: job['class'],
+            job_id: job['jid'],
             queue_name: queue,
-            retry_count: job["retry_count"],
-            arguments: job["args"]&.map(&:to_s)&.first(5)
+            retry_count: job['retry_count'],
+            arguments: job['args']&.map(&:to_s)&.first(5)
           )
         end
 
@@ -118,19 +118,20 @@ module BrainzLab
         end
 
         def extract_trace_context(job)
-          return nil unless job["_brainzlab_trace"]
+          return nil unless job['_brainzlab_trace']
 
-          trace_data = job["_brainzlab_trace"]
+          trace_data = job['_brainzlab_trace']
           BrainzLab::Pulse::Propagation::Context.new(
-            trace_id: trace_data["trace_id"],
-            span_id: trace_data["span_id"],
-            sampled: trace_data["sampled"] != false
+            trace_id: trace_data['trace_id'],
+            span_id: trace_data['span_id'],
+            sampled: trace_data['sampled'] != false
           )
         rescue StandardError
           nil
         end
 
-        def record_trace(job_class:, job_id:, queue:, started_at:, queue_wait_ms:, retry_count:, parent_context:, error:)
+        def record_trace(job_class:, job_id:, queue:, started_at:, queue_wait_ms:, retry_count:, parent_context:,
+                         error:)
           ended_at = Time.now.utc
           duration_ms = ((ended_at - started_at) * 1000).round(2)
 
@@ -156,7 +157,7 @@ module BrainzLab
           payload = {
             trace_id: SecureRandom.uuid,
             name: job_class,
-            kind: "job",
+            kind: 'job',
             started_at: started_at.utc.iso8601(3),
             ended_at: ended_at.utc.iso8601(3),
             duration_ms: duration_ms,
@@ -200,7 +201,7 @@ module BrainzLab
 
       # Client middleware - runs when jobs are enqueued
       class ClientMiddleware
-        def call(worker_class, job, queue, redis_pool)
+        def call(_worker_class, job, queue, _redis_pool)
           # Inject trace context for distributed tracing
           inject_trace_context(job)
 
@@ -208,9 +209,9 @@ module BrainzLab
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "Enqueue #{job['class']}",
-              category: "job.sidekiq.enqueue",
+              category: 'job.sidekiq.enqueue',
               level: :info,
-              data: { queue: queue, job_id: job["jid"] }
+              data: { queue: queue, job_id: job['jid'] }
             )
           end
 
@@ -231,10 +232,10 @@ module BrainzLab
 
           return unless ctx&.valid?
 
-          job["_brainzlab_trace"] = {
-            "trace_id" => ctx.trace_id,
-            "span_id" => ctx.span_id,
-            "sampled" => ctx.sampled
+          job['_brainzlab_trace'] = {
+            'trace_id' => ctx.trace_id,
+            'span_id' => ctx.span_id,
+            'sampled' => ctx.sampled
           }
         rescue StandardError => e
           BrainzLab.debug_log("Failed to inject Sidekiq trace context: #{e.message}")
@@ -247,13 +248,13 @@ module BrainzLab
           spans << {
             span_id: SecureRandom.uuid,
             name: "Enqueue #{job['class']}",
-            kind: "job",
+            kind: 'job',
             started_at: Time.now.utc,
             ended_at: Time.now.utc,
             duration_ms: 0,
             data: {
-              job_class: job["class"],
-              job_id: job["jid"],
+              job_class: job['class'],
+              job_id: job['jid'],
               queue: queue
             }
           }