brainzlab 0.1.1 → 0.1.3

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module ResqueInstrumentation
+      class << self
+        def install!
+          return unless defined?(::Resque)
+
+          install_hooks!
+          install_failure_backend!
+
+          BrainzLab.debug_log('[Instrumentation] Resque instrumentation installed')
+        end
+
+        private
+
+        def install_hooks!
+          ::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)
+          end
+
+          ::Resque.after_fork do |job|
+            # Re-establish connections after forking
+          end
+        end
+
+        def install_failure_backend!
+          # Create a custom failure backend
+          failure_backend = Class.new do
+            def initialize(exception, worker, queue, payload)
+              @exception = exception
+              @worker = worker
+              @queue = queue
+              @payload = payload
+            end
+
+            def save
+              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']
+                                          })
+              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
+          return unless defined?(::Resque::Failure)
+
+          ::Resque::Failure.backend = ::Resque::Failure::Multiple.new(
+            ::Resque::Failure.backend,
+            failure_backend
+          )
+        end
+      end
+
+      # Middleware module to include in Resque jobs
+      module Middleware
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def around_perform_brainzlab(*_args)
+            job_class = name
+            queue = Resque.queue_from_class(self) || 'default'
+            started_at = Time.now
+
+            BrainzLab::Context.current.set_context(
+              job_class: job_class,
+              queue: queue
+            )
+
+            begin
+              yield
+            ensure
+              duration_ms = ((Time.now - started_at) * 1000).round(2)
+
+              if BrainzLab.configuration.pulse_effectively_enabled?
+                BrainzLab::Pulse.record_trace(
+                  "job.#{job_class}",
+                  kind: 'job',
+                  started_at: started_at,
+                  ended_at: Time.now,
+                  job_class: job_class,
+                  queue: queue
+                )
+              end
+
+              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)
+              end
+
+              BrainzLab.clear_context!
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

data/lib/brainzlab/instrumentation/solid_queue.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module SolidQueueInstrumentation
+      class << self
+        def install!
+          return unless defined?(::SolidQueue)
+
+          install_job_instrumentation!
+          install_worker_instrumentation!
+
+          BrainzLab.debug_log('[Instrumentation] SolidQueue instrumentation installed')
+        end
+
+        private
+
+        def install_job_instrumentation!
+          return unless defined?(::ActiveJob::Base)
+
+          ::ActiveJob::Base.class_eval do
+            around_perform do |job, block|
+              BrainzLab::Instrumentation::SolidQueueInstrumentation.around_perform(job, &block)
+            end
+
+            around_enqueue do |job, block|
+              BrainzLab::Instrumentation::SolidQueueInstrumentation.around_enqueue(job, &block)
+            end
+          end
+        end
+
+        def install_worker_instrumentation!
+          # Subscribe to ActiveSupport notifications for SolidQueue
+          return unless defined?(::ActiveSupport::Notifications)
+
+          ::ActiveSupport::Notifications.subscribe(/solid_queue/) do |name, start, finish, _id, payload|
+            handle_notification(name, start, finish, payload)
+          end
+        end
+
+        def handle_notification(name, start, finish, payload)
+          duration_ms = ((finish - start) * 1000).round(2)
+
+          case name
+          when 'perform.solid_queue'
+            track_job_perform(payload, duration_ms)
+          when 'enqueue.solid_queue'
+            track_job_enqueue(payload)
+          when 'discard.solid_queue'
+            track_job_discard(payload)
+          when 'retry.solid_queue'
+            track_job_retry(payload)
+          end
+        end
+
+        def track_job_perform(payload, duration_ms)
+          job_class = payload[:job]&.class&.name || payload[:job_class]
+          queue = payload[:queue] || 'default'
+
+          # Track with Pulse
+          if BrainzLab.configuration.pulse_effectively_enabled?
+            BrainzLab::Pulse.record_trace(
+              "job.#{job_class}",
+              kind: 'job',
+              started_at: Time.now - (duration_ms / 1000.0),
+              ended_at: Time.now,
+              job_class: job_class,
+              job_id: payload[:job_id],
+              queue: queue,
+              executions: payload[:executions] || 1,
+              error: payload[:error].present?,
+              error_class: payload[:error]&.class&.name,
+              error_message: payload[:error]&.message
+            )
+          end
+
+          # Track with Flux
+          if BrainzLab.configuration.flux_effectively_enabled?
+            tags = { job_class: job_class, queue: queue }
+            BrainzLab::Flux.distribution('solid_queue.job.duration_ms', duration_ms, tags: tags)
+            BrainzLab::Flux.increment('solid_queue.job.processed', tags: tags)
+
+            BrainzLab::Flux.increment('solid_queue.job.failed', tags: tags) if payload[:error]
+          end
+
+          # Add breadcrumb for Reflex
+          BrainzLab::Reflex.add_breadcrumb(
+            "Job #{job_class} completed in #{duration_ms}ms",
+            category: 'job',
+            level: payload[:error] ? :error : :info,
+            data: { queue: queue, job_id: payload[:job_id], duration_ms: duration_ms }
+          )
+        end
+
+        def track_job_enqueue(payload)
+          job_class = payload[:job]&.class&.name || payload[:job_class]
+          queue = payload[:queue] || 'default'
+
+          return unless BrainzLab.configuration.flux_effectively_enabled?
+
+          BrainzLab::Flux.increment('solid_queue.job.enqueued', tags: { job_class: job_class, queue: queue })
+        end
+
+        def track_job_discard(payload)
+          job_class = payload[:job]&.class&.name || payload[:job_class]
+
+          return unless BrainzLab.configuration.flux_effectively_enabled?
+
+          BrainzLab::Flux.increment('solid_queue.job.discarded', tags: { job_class: job_class })
+        end
+
+        def track_job_retry(payload)
+          job_class = payload[:job]&.class&.name || payload[:job_class]
+
+          return unless BrainzLab.configuration.flux_effectively_enabled?
+
+          BrainzLab::Flux.increment('solid_queue.job.retried', tags: { job_class: job_class })
+        end
+      end
+
+      def self.around_perform(job)
+        job_class = job.class.name
+        queue = job.queue_name || 'default'
+        started_at = Time.now
+
+        # Set context for the job
+        BrainzLab::Context.current.set_context(
+          job_class: job_class,
+          job_id: job.job_id,
+          queue: queue
+        )
+
+        begin
+          yield
+        rescue StandardError => e
+          # Capture error with Reflex
+          if BrainzLab.configuration.reflex_effectively_enabled?
+            BrainzLab::Reflex.capture(e,
+                                      tags: { job_class: job_class, queue: queue },
+                                      extra: {
+                                        job_id: job.job_id,
+                                        arguments: safe_arguments(job),
+                                        executions: job.executions
+                                      })
+          end
+          raise
+        ensure
+          duration_ms = ((Time.now - started_at) * 1000).round(2)
+
+          # Record trace
+          if BrainzLab.configuration.pulse_effectively_enabled?
+            BrainzLab::Pulse.record_trace(
+              "job.#{job_class}",
+              kind: 'job',
+              started_at: started_at,
+              ended_at: Time.now,
+              job_class: job_class,
+              job_id: job.job_id,
+              queue: queue,
+              executions: job.executions
+            )
+          end
+
+          # Record metrics
+          if BrainzLab.configuration.flux_effectively_enabled?
+            tags = { job_class: job_class, queue: queue }
+            BrainzLab::Flux.distribution('solid_queue.job.duration_ms', duration_ms, tags: tags)
+          end
+
+          # Clear context
+          BrainzLab.clear_context!
+        end
+      end
+
+      def self.around_enqueue(job)
+        yield
+      rescue StandardError => e
+        if BrainzLab.configuration.reflex_effectively_enabled?
+          BrainzLab::Reflex.capture(e,
+                                    tags: { job_class: job.class.name, queue: job.queue_name },
+                                    extra: { job_id: job.job_id, arguments: safe_arguments(job) })
+        end
+        raise
+      end
+
+      def self.safe_arguments(job)
+        args = job.arguments
+        BrainzLab::Reflex.send(:filter_params, args) if args
+      rescue StandardError
+        '[Unable to serialize]'
+      end
+    end
+  end
+end