brainzlab 0.1.2 → 0.1.3

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

@@ -10,7 +10,7 @@ module BrainzLab
           install_job_instrumentation!
           install_worker_instrumentation!
 
-          BrainzLab.debug_log("[Instrumentation] SolidQueue instrumentation installed")
+          BrainzLab.debug_log('[Instrumentation] SolidQueue instrumentation installed')
         end
 
         private
@@ -31,10 +31,10 @@ module BrainzLab
 
         def install_worker_instrumentation!
           # Subscribe to ActiveSupport notifications for SolidQueue
-          if defined?(::ActiveSupport::Notifications)
-            ::ActiveSupport::Notifications.subscribe(/solid_queue/) do |name, start, finish, id, payload|
-              handle_notification(name, start, finish, payload)
-            end
+          return unless defined?(::ActiveSupport::Notifications)
+
+          ::ActiveSupport::Notifications.subscribe(/solid_queue/) do |name, start, finish, _id, payload|
+            handle_notification(name, start, finish, payload)
           end
         end
 
@@ -42,26 +42,26 @@ module BrainzLab
           duration_ms = ((finish - start) * 1000).round(2)
 
           case name
-          when "perform.solid_queue"
+          when 'perform.solid_queue'
             track_job_perform(payload, duration_ms)
-          when "enqueue.solid_queue"
+          when 'enqueue.solid_queue'
             track_job_enqueue(payload)
-          when "discard.solid_queue"
+          when 'discard.solid_queue'
             track_job_discard(payload)
-          when "retry.solid_queue"
+          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"
+          queue = payload[:queue] || 'default'
 
           # Track with Pulse
           if BrainzLab.configuration.pulse_effectively_enabled?
             BrainzLab::Pulse.record_trace(
               "job.#{job_class}",
-              kind: "job",
+              kind: 'job',
               started_at: Time.now - (duration_ms / 1000.0),
               ended_at: Time.now,
               job_class: job_class,
@@ -77,18 +77,16 @@ module BrainzLab
           # 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.distribution('solid_queue.job.duration_ms', duration_ms, tags: tags)
+            BrainzLab::Flux.increment('solid_queue.job.processed', tags: tags)
 
-            if payload[:error]
-              BrainzLab::Flux.increment("solid_queue.job.failed", tags: tags)
-            end
+            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",
+            category: 'job',
             level: payload[:error] ? :error : :info,
             data: { queue: queue, job_id: payload[:job_id], duration_ms: duration_ms }
           )
@@ -96,33 +94,33 @@ module BrainzLab
 
         def track_job_enqueue(payload)
           job_class = payload[:job]&.class&.name || payload[:job_class]
-          queue = payload[:queue] || "default"
+          queue = payload[:queue] || 'default'
 
-          if BrainzLab.configuration.flux_effectively_enabled?
-            BrainzLab::Flux.increment("solid_queue.job.enqueued", tags: { job_class: job_class, queue: queue })
-          end
+          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]
 
-          if BrainzLab.configuration.flux_effectively_enabled?
-            BrainzLab::Flux.increment("solid_queue.job.discarded", tags: { job_class: job_class })
-          end
+          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]
 
-          if BrainzLab.configuration.flux_effectively_enabled?
-            BrainzLab::Flux.increment("solid_queue.job.retried", tags: { job_class: job_class })
-          end
+          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"
+        queue = job.queue_name || 'default'
         started_at = Time.now
 
         # Set context for the job
@@ -138,13 +136,12 @@ module BrainzLab
           # 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
-              }
-            )
+                                      tags: { job_class: job_class, queue: queue },
+                                      extra: {
+                                        job_id: job.job_id,
+                                        arguments: safe_arguments(job),
+                                        executions: job.executions
+                                      })
           end
           raise
         ensure
@@ -154,7 +151,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,
@@ -167,7 +164,7 @@ module BrainzLab
           # 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)
+            BrainzLab::Flux.distribution('solid_queue.job.duration_ms', duration_ms, tags: tags)
           end
 
           # Clear context
@@ -180,9 +177,8 @@ module BrainzLab
       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) }
-          )
+                                    tags: { job_class: job.class.name, queue: job.queue_name },
+                                    extra: { job_id: job.job_id, arguments: safe_arguments(job) })
         end
         raise
       end
@@ -191,7 +187,7 @@ module BrainzLab
         args = job.arguments
         BrainzLab::Reflex.send(:filter_params, args) if args
       rescue StandardError
-        "[Unable to serialize]"
+        '[Unable to serialize]'
       end
     end
   end

data/lib/brainzlab/instrumentation/stripe.rb

@@ -9,7 +9,7 @@ module BrainzLab
 
           install_instrumentation!
 
-          BrainzLab.debug_log("[Instrumentation] Stripe instrumentation installed")
+          BrainzLab.debug_log('[Instrumentation] Stripe instrumentation installed')
         end
 
         private
@@ -63,8 +63,8 @@ module BrainzLab
 
               def extract_resource(path)
                 # /v1/customers/cus_xxx -> customers
-                parts = path.to_s.split("/").reject(&:empty?)
-                parts[1] || "unknown"
+                parts = path.to_s.split('/').reject(&:empty?)
+                parts[1] || 'unknown'
               end
             end
           end
@@ -73,11 +73,11 @@ module BrainzLab
         def track_event(event)
           duration_ms = (event[:duration] * 1000).round(2) if event[:duration]
           method = event[:method].to_s.upcase
-          resource = event[:path].to_s.split("/")[2] || "unknown"
+          resource = event[:path].to_s.split('/')[2] || 'unknown'
 
           BrainzLab::Reflex.add_breadcrumb(
             "Stripe #{method} #{resource}",
-            category: "payment",
+            category: 'payment',
             level: event[:error] ? :error : :info,
             data: {
               method: method,
@@ -88,24 +88,24 @@ module BrainzLab
             }
           )
 
-          if BrainzLab.configuration.flux_effectively_enabled?
-            tags = { method: method, resource: resource }
-            BrainzLab::Flux.distribution("stripe.duration_ms", duration_ms, tags: tags) if duration_ms
-            BrainzLab::Flux.increment("stripe.requests", tags: tags)
+          return unless BrainzLab.configuration.flux_effectively_enabled?
 
-            if event[:error]
-              BrainzLab::Flux.increment("stripe.errors", tags: tags.merge(error_type: event[:error_type]))
-            end
-          end
+          tags = { method: method, resource: resource }
+          BrainzLab::Flux.distribution('stripe.duration_ms', duration_ms, tags: tags) if duration_ms
+          BrainzLab::Flux.increment('stripe.requests', tags: tags)
+
+          return unless event[:error]
+
+          BrainzLab::Flux.increment('stripe.errors', tags: tags.merge(error_type: event[:error_type]))
         end
       end
 
-      def self.track_success(method, resource, path, started_at, response)
+      def self.track_success(method, resource, path, started_at, _response)
         duration_ms = ((Time.now - started_at) * 1000).round(2)
 
         BrainzLab::Reflex.add_breadcrumb(
           "Stripe #{method.to_s.upcase} #{resource}",
-          category: "payment",
+          category: 'payment',
           level: :info,
           data: {
             method: method.to_s.upcase,
@@ -115,28 +115,28 @@ module BrainzLab
           }
         )
 
-        if BrainzLab.configuration.flux_effectively_enabled?
-          tags = { method: method.to_s.upcase, resource: resource }
-          BrainzLab::Flux.distribution("stripe.duration_ms", duration_ms, tags: tags)
-          BrainzLab::Flux.increment("stripe.requests", tags: tags)
-        end
+        return unless BrainzLab.configuration.flux_effectively_enabled?
+
+        tags = { method: method.to_s.upcase, resource: resource }
+        BrainzLab::Flux.distribution('stripe.duration_ms', duration_ms, tags: tags)
+        BrainzLab::Flux.increment('stripe.requests', tags: tags)
       end
 
-      def self.track_error(method, resource, path, started_at, error)
-        duration_ms = ((Time.now - started_at) * 1000).round(2)
+      def self.track_error(method, resource, _path, started_at, error)
+        ((Time.now - started_at) * 1000).round(2)
         error_type = case error
-                     when Stripe::CardError then "card_error"
-                     when Stripe::RateLimitError then "rate_limit"
-                     when Stripe::InvalidRequestError then "invalid_request"
-                     when Stripe::AuthenticationError then "authentication"
-                     when Stripe::APIConnectionError then "connection"
-                     when Stripe::StripeError then "stripe_error"
-                     else "unknown"
+                     when Stripe::CardError then 'card_error'
+                     when Stripe::RateLimitError then 'rate_limit'
+                     when Stripe::InvalidRequestError then 'invalid_request'
+                     when Stripe::AuthenticationError then 'authentication'
+                     when Stripe::APIConnectionError then 'connection'
+                     when Stripe::StripeError then 'stripe_error'
+                     else 'unknown'
                      end
 
         BrainzLab::Reflex.add_breadcrumb(
           "Stripe #{method.to_s.upcase} #{resource} failed: #{error.message}",
-          category: "payment",
+          category: 'payment',
           level: :error,
           data: {
             method: method.to_s.upcase,
@@ -148,16 +148,15 @@ module BrainzLab
 
         if BrainzLab.configuration.flux_effectively_enabled?
           tags = { method: method.to_s.upcase, resource: resource, error_type: error_type }
-          BrainzLab::Flux.increment("stripe.errors", tags: tags)
+          BrainzLab::Flux.increment('stripe.errors', tags: tags)
         end
 
         # Capture with Reflex (but filter sensitive data)
-        if BrainzLab.configuration.reflex_effectively_enabled?
-          BrainzLab::Reflex.capture(error,
-            tags: { source: "stripe", resource: resource },
-            extra: { error_type: error_type }
-          )
-        end
+        return unless BrainzLab.configuration.reflex_effectively_enabled?
+
+        BrainzLab::Reflex.capture(error,
+                                  tags: { source: 'stripe', resource: resource },
+                                  extra: { error_type: error_type })
       end
     end
   end

data/lib/brainzlab/instrumentation/typhoeus.rb

@@ -9,7 +9,7 @@ module BrainzLab
 
           install_callbacks!
 
-          BrainzLab.debug_log("[Instrumentation] Typhoeus instrumentation installed")
+          BrainzLab.debug_log('[Instrumentation] Typhoeus instrumentation installed')
         end
 
         private
@@ -24,21 +24,25 @@ module BrainzLab
           request = response.request
           return unless request
 
-          uri = URI.parse(request.base_url) rescue nil
+          uri = begin
+            URI.parse(request.base_url)
+          rescue StandardError
+            nil
+          end
           return unless uri
 
           host = uri.host
           return if skip_host?(host)
 
           method = (request.options[:method] || :get).to_s.upcase
-          path = uri.path.empty? ? "/" : uri.path
+          path = uri.path.empty? ? '/' : uri.path
           status = response.response_code
           duration_ms = (response.total_time * 1000).round(2)
 
           # Add breadcrumb
           BrainzLab::Reflex.add_breadcrumb(
             "HTTP #{method} #{host}#{path} -> #{status}",
-            category: "http",
+            category: 'http',
             level: response.success? ? :info : :error,
             data: {
               method: method,
@@ -50,19 +54,17 @@ module BrainzLab
           )
 
           # Track with Flux
-          if BrainzLab.configuration.flux_effectively_enabled?
-            tags = { host: host, method: method, status: status.to_s }
-            BrainzLab::Flux.distribution("http.typhoeus.duration_ms", duration_ms, tags: tags)
-            BrainzLab::Flux.increment("http.typhoeus.requests", tags: tags)
+          return unless BrainzLab.configuration.flux_effectively_enabled?
 
-            unless response.success?
-              BrainzLab::Flux.increment("http.typhoeus.errors", tags: tags)
-            end
+          tags = { host: host, method: method, status: status.to_s }
+          BrainzLab::Flux.distribution('http.typhoeus.duration_ms', duration_ms, tags: tags)
+          BrainzLab::Flux.increment('http.typhoeus.requests', tags: tags)
 
-            if response.timed_out?
-              BrainzLab::Flux.increment("http.typhoeus.timeouts", tags: { host: host })
-            end
-          end
+          BrainzLab::Flux.increment('http.typhoeus.errors', tags: tags) unless response.success?
+
+          return unless response.timed_out?
+
+          BrainzLab::Flux.increment('http.typhoeus.timeouts', tags: { host: host })
         end
 
         def skip_host?(host)
@@ -90,8 +92,8 @@ module BrainzLab
               duration_ms = ((Time.now - started_at) * 1000).round(2)
 
               if BrainzLab.configuration.flux_effectively_enabled?
-                BrainzLab::Flux.distribution("http.typhoeus.hydra.duration_ms", duration_ms)
-                BrainzLab::Flux.distribution("http.typhoeus.hydra.request_count", request_count)
+                BrainzLab::Flux.distribution('http.typhoeus.hydra.duration_ms', duration_ms)
+                BrainzLab::Flux.distribution('http.typhoeus.hydra.request_count', request_count)
               end
 
               result