brainzlab 0.1.2 → 0.1.3

data/lib/brainzlab/instrumentation/delayed_job.rb

@@ -11,17 +11,13 @@ module BrainzLab
           return if @installed
 
           # Install lifecycle hooks
-          if defined?(::Delayed::Worker)
-            install_lifecycle_hooks!
-          end
+          install_lifecycle_hooks! if defined?(::Delayed::Worker)
 
           # Install plugin if Delayed::Plugin is available
-          if defined?(::Delayed::Plugin)
-            ::Delayed::Worker.plugins << Plugin
-          end
+          ::Delayed::Worker.plugins << Plugin if defined?(::Delayed::Plugin)
 
           @installed = true
-          BrainzLab.debug_log("Delayed::Job instrumentation installed")
+          BrainzLab.debug_log('Delayed::Job instrumentation installed')
         end
 
         def installed?
@@ -35,15 +31,15 @@ module BrainzLab
         private
 
         def install_lifecycle_hooks!
-          ::Delayed::Worker.lifecycle.around(:invoke_job) do |job, *args, &block|
+          ::Delayed::Worker.lifecycle.around(:invoke_job) do |job, *_args, &block|
             around_invoke(job, &block)
           end
 
-          ::Delayed::Worker.lifecycle.after(:error) do |worker, job|
+          ::Delayed::Worker.lifecycle.after(:error) do |_worker, job|
             record_error(job)
           end
 
-          ::Delayed::Worker.lifecycle.after(:failure) do |worker, job|
+          ::Delayed::Worker.lifecycle.after(:failure) do |_worker, job|
             record_failure(job)
           end
         rescue StandardError => e
@@ -53,7 +49,7 @@ module BrainzLab
         def around_invoke(job, &block)
           started_at = Time.now.utc
           job_name = extract_job_name(job)
-          queue = job.queue || "default"
+          queue = job.queue || 'default'
 
           # Calculate queue wait time
           queue_wait_ms = job.created_at ? ((started_at - job.created_at) * 1000).round(2) : nil
@@ -64,7 +60,7 @@ module BrainzLab
           # Add breadcrumb
           BrainzLab::Reflex.add_breadcrumb(
             "DelayedJob #{job_name}",
-            category: "job.delayed_job",
+            category: 'job.delayed_job',
             level: :info,
             data: { job_id: job.id, queue: queue, attempts: job.attempts }
           )
@@ -133,7 +129,7 @@ module BrainzLab
           payload = {
             trace_id: SecureRandom.uuid,
             name: job_name,
-            kind: "job",
+            kind: 'job',
             started_at: started_at.utc.iso8601(3),
             ended_at: ended_at.utc.iso8601(3),
             duration_ms: duration_ms,
@@ -162,7 +158,7 @@ module BrainzLab
 
           BrainzLab::Reflex.add_breadcrumb(
             "DelayedJob error: #{extract_job_name(job)}",
-            category: "job.delayed_job.error",
+            category: 'job.delayed_job.error',
             level: :error,
             data: {
               job_id: job.id,
@@ -177,7 +173,7 @@ module BrainzLab
         def record_failure(job)
           BrainzLab::Reflex.add_breadcrumb(
             "DelayedJob failed permanently: #{extract_job_name(job)}",
-            category: "job.delayed_job.failure",
+            category: 'job.delayed_job.failure',
             level: :error,
             data: {
               job_id: job.id,
@@ -200,7 +196,7 @@ module BrainzLab
             payload.class.name
           end
         rescue StandardError
-          job.name || "Unknown"
+          job.name || 'Unknown'
         end
 
         def format_timestamp(ts)
@@ -216,21 +212,23 @@ module BrainzLab
       end
 
       # Delayed::Job Plugin (alternative installation method)
-      class Plugin < ::Delayed::Plugin
-        callbacks do |lifecycle|
-          lifecycle.around(:invoke_job) do |job, *args, &block|
-            DelayedJobInstrumentation.send(:around_invoke, job, &block)
-          end
-
-          lifecycle.after(:error) do |worker, job|
-            DelayedJobInstrumentation.send(:record_error, job)
-          end
-
-          lifecycle.after(:failure) do |worker, job|
-            DelayedJobInstrumentation.send(:record_failure, job)
+      if defined?(::Delayed::Plugin)
+        class Plugin < ::Delayed::Plugin
+          callbacks do |lifecycle|
+            lifecycle.around(:invoke_job) do |job, *_args, &block|
+              DelayedJobInstrumentation.send(:around_invoke, job, &block)
+            end
+
+            lifecycle.after(:error) do |_worker, job|
+              DelayedJobInstrumentation.send(:record_error, job)
+            end
+
+            lifecycle.after(:failure) do |_worker, job|
+              DelayedJobInstrumentation.send(:record_failure, job)
+            end
           end
         end
-      end if defined?(::Delayed::Plugin)
+      end
     end
   end
 end

data/lib/brainzlab/instrumentation/elasticsearch.rb

@@ -32,7 +32,7 @@ module BrainzLab
           return unless installed_any
 
           @installed = true
-          BrainzLab.debug_log("Elasticsearch instrumentation installed")
+          BrainzLab.debug_log('Elasticsearch instrumentation installed')
         end
 
         def installed?
@@ -64,14 +64,12 @@ module BrainzLab
           return super unless should_track?
 
           started_at = Time.now.utc
-          error_info = nil
 
           begin
             response = super
             record_request(method, path, params, started_at, response.status)
             response
           rescue StandardError => e
-            error_info = e
             record_request(method, path, params, started_at, nil, e)
             raise
           end
@@ -83,7 +81,7 @@ module BrainzLab
           BrainzLab.configuration.instrument_elasticsearch
         end
 
-        def record_request(method, path, params, started_at, status, error = nil)
+        def record_request(method, path, _params, started_at, status, error = nil)
           duration_ms = ((Time.now.utc - started_at) * 1000).round(2)
           operation = extract_operation(method, path)
           index = extract_index(path)
@@ -93,7 +91,7 @@ module BrainzLab
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "ES #{operation}",
-              category: "elasticsearch",
+              category: 'elasticsearch',
               level: level,
               data: {
                 method: method.to_s.upcase,
@@ -143,7 +141,7 @@ module BrainzLab
           span = {
             span_id: SecureRandom.uuid,
             name: "ES #{operation}",
-            kind: "elasticsearch",
+            kind: 'elasticsearch',
             started_at: started_at,
             ended_at: Time.now.utc,
             duration_ms: duration_ms,
@@ -168,25 +166,25 @@ module BrainzLab
           method_str = method.to_s.upcase
 
           case path
-          when %r{/_search} then "search"
-          when %r{/_bulk} then "bulk"
-          when %r{/_count} then "count"
-          when %r{/_mget} then "mget"
-          when %r{/_msearch} then "msearch"
-          when %r{/_update_by_query} then "update_by_query"
-          when %r{/_delete_by_query} then "delete_by_query"
-          when %r{/_refresh} then "refresh"
-          when %r{/_mapping} then "mapping"
-          when %r{/_settings} then "settings"
-          when %r{/_alias} then "alias"
-          when %r{/_analyze} then "analyze"
+          when %r{/_search} then 'search'
+          when %r{/_bulk} then 'bulk'
+          when %r{/_count} then 'count'
+          when %r{/_mget} then 'mget'
+          when %r{/_msearch} then 'msearch'
+          when %r{/_update_by_query} then 'update_by_query'
+          when %r{/_delete_by_query} then 'delete_by_query'
+          when %r{/_refresh} then 'refresh'
+          when %r{/_mapping} then 'mapping'
+          when %r{/_settings} then 'settings'
+          when %r{/_alias} then 'alias'
+          when %r{/_analyze} then 'analyze'
           else
             case method_str
-            when "GET" then "get"
-            when "POST" then "index"
-            when "PUT" then "update"
-            when "DELETE" then "delete"
-            when "HEAD" then "exists"
+            when 'GET' then 'get'
+            when 'POST' then 'index'
+            when 'PUT' then 'update'
+            when 'DELETE' then 'delete'
+            when 'HEAD' then 'exists'
             else method_str.downcase
             end
           end
@@ -195,13 +193,14 @@ module BrainzLab
         def extract_index(path)
           # Extract index name from path like /my-index/_search
           match = path.match(%r{^/([^/_]+)})
-          match[1] if match && !match[1].start_with?("_")
+          match[1] if match && !match[1].start_with?('_')
         rescue StandardError
           nil
         end
 
         def truncate_path(path)
           return nil unless path
+
           path.to_s[0, 200]
         end
       end

data/lib/brainzlab/instrumentation/excon.rb

@@ -9,7 +9,7 @@ module BrainzLab
 
           install_middleware!
 
-          BrainzLab.debug_log("[Instrumentation] Excon instrumentation installed")
+          BrainzLab.debug_log('[Instrumentation] Excon instrumentation installed')
         end
 
         private
@@ -19,15 +19,15 @@ module BrainzLab
           ::Excon.defaults[:instrumentor] = BrainzLabInstrumentor
 
           # Also set up middleware
-          if ::Excon.defaults[:middlewares]
-            ::Excon.defaults[:middlewares] = [Middleware] + ::Excon.defaults[:middlewares]
-          end
+          return unless ::Excon.defaults[:middlewares]
+
+          ::Excon.defaults[:middlewares] = [Middleware] + ::Excon.defaults[:middlewares]
         end
       end
 
       # Excon Instrumentor for ActiveSupport-style notifications
       module BrainzLabInstrumentor
-        def self.instrument(name, params = {}, &block)
+        def self.instrument(name, params = {})
           started_at = Time.now
 
           begin
@@ -40,19 +40,19 @@ module BrainzLab
           end
         end
 
-        def self.track_request(name, params, started_at, error)
+        def self.track_request(_name, params, started_at, error)
           return if skip_tracking?(params)
 
           duration_ms = ((Time.now - started_at) * 1000).round(2)
-          host = params[:host] || "unknown"
-          method = (params[:method] || "GET").to_s.upcase
-          path = params[:path] || "/"
+          host = params[:host] || 'unknown'
+          method = (params[:method] || 'GET').to_s.upcase
+          path = params[:path] || '/'
           status = params[:status]
 
           # Add breadcrumb
           BrainzLab::Reflex.add_breadcrumb(
             "HTTP #{method} #{host}#{path}",
-            category: "http",
+            category: 'http',
             level: error ? :error : :info,
             data: {
               method: method,
@@ -65,21 +65,21 @@ module BrainzLab
 
           # Track with Pulse
           if BrainzLab.configuration.pulse_effectively_enabled?
-            BrainzLab::Pulse.span("http.excon", kind: "http") do
+            BrainzLab::Pulse.span('http.excon', kind: 'http') do
               # Already completed, just recording
             end
           end
 
           # Track with Flux
-          if BrainzLab.configuration.flux_effectively_enabled?
-            tags = { host: host, method: method, status: status.to_s }
-            BrainzLab::Flux.distribution("http.excon.duration_ms", duration_ms, tags: tags)
-            BrainzLab::Flux.increment("http.excon.requests", tags: tags)
+          return unless BrainzLab.configuration.flux_effectively_enabled?
 
-            if error || (status && status >= 400)
-              BrainzLab::Flux.increment("http.excon.errors", tags: tags)
-            end
-          end
+          tags = { host: host, method: method, status: status.to_s }
+          BrainzLab::Flux.distribution('http.excon.duration_ms', duration_ms, tags: tags)
+          BrainzLab::Flux.increment('http.excon.requests', tags: tags)
+
+          return unless error || (status && status >= 400)
+
+          BrainzLab::Flux.increment('http.excon.errors', tags: tags)
         end
 
         def self.skip_tracking?(params)
@@ -122,22 +122,22 @@ module BrainzLab
           return if skip_host?(host)
 
           duration_ms = ((Time.now - started_at) * 1000).round(2)
-          method = (datum[:method] || "GET").to_s.upcase
-          path = datum[:path] || "/"
+          method = (datum[:method] || 'GET').to_s.upcase
+          path = datum[:path] || '/'
           status = datum[:response]&.dig(:status)
 
           BrainzLab::Reflex.add_breadcrumb(
             "HTTP #{method} #{host}#{path} -> #{status || 'error'}",
-            category: "http",
+            category: 'http',
             level: error ? :error : :info,
             data: { method: method, host: host, status: status, duration_ms: duration_ms }
           )
 
-          if BrainzLab.configuration.flux_effectively_enabled?
-            tags = { host: host, method: method }
-            tags[:status] = status.to_s if status
-            BrainzLab::Flux.distribution("http.excon.duration_ms", duration_ms, tags: tags)
-          end
+          return unless BrainzLab.configuration.flux_effectively_enabled?
+
+          tags = { host: host, method: method }
+          tags[:status] = status.to_s if status
+          BrainzLab::Flux.distribution('http.excon.duration_ms', duration_ms, tags: tags)
         end
 
         def skip_host?(host)

data/lib/brainzlab/instrumentation/faraday.rb

@@ -14,7 +14,7 @@ module BrainzLab
           ::Faraday::Middleware.register_middleware(brainzlab: Middleware)
 
           @installed = true
-          BrainzLab.debug_log("Faraday instrumentation installed")
+          BrainzLab.debug_log('Faraday instrumentation installed')
         end
 
         def installed?
@@ -46,7 +46,6 @@ module BrainzLab
           inject_trace_context(env)
 
           started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          error_info = nil
 
           begin
             response = @app.call(env)
@@ -98,7 +97,7 @@ module BrainzLab
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "#{method} #{url}",
-              category: "http.faraday",
+              category: 'http.faraday',
               level: level,
               data: {
                 method: method,
@@ -138,7 +137,7 @@ module BrainzLab
           span = {
             span_id: SecureRandom.uuid,
             name: "HTTP #{method} #{host}",
-            kind: "http",
+            kind: 'http',
             started_at: Time.now.utc - (duration_ms / 1000.0),
             ended_at: Time.now.utc,
             duration_ms: duration_ms,

data/lib/brainzlab/instrumentation/good_job.rb

@@ -10,7 +10,7 @@ module BrainzLab
           install_notifier!
           install_middleware!
 
-          BrainzLab.debug_log("[Instrumentation] GoodJob instrumentation installed")
+          BrainzLab.debug_log('[Instrumentation] GoodJob instrumentation installed')
         end
 
         private
@@ -19,12 +19,12 @@ module BrainzLab
           return unless defined?(::ActiveSupport::Notifications)
 
           # GoodJob emits ActiveSupport notifications
-          ::ActiveSupport::Notifications.subscribe("perform_job.good_job") do |*args|
+          ::ActiveSupport::Notifications.subscribe('perform_job.good_job') do |*args|
             event = ::ActiveSupport::Notifications::Event.new(*args)
             handle_perform(event)
           end
 
-          ::ActiveSupport::Notifications.subscribe("finished_job_task.good_job") do |*args|
+          ::ActiveSupport::Notifications.subscribe('finished_job_task.good_job') do |*args|
             event = ::ActiveSupport::Notifications::Event.new(*args)
             handle_finished(event)
           end
@@ -34,25 +34,28 @@ module BrainzLab
           return unless defined?(::GoodJob::Adapter)
 
           # Add our callback to GoodJob
-          if ::GoodJob.respond_to?(:on_thread_error)
-            ::GoodJob.on_thread_error = ->(error) do
-              BrainzLab::Reflex.capture(error, tags: { source: "good_job" }) if BrainzLab.configuration.reflex_effectively_enabled?
+          return unless ::GoodJob.respond_to?(:on_thread_error)
+
+          ::GoodJob.on_thread_error = lambda { |error|
+            if BrainzLab.configuration.reflex_effectively_enabled?
+              BrainzLab::Reflex.capture(error,
+                                        tags: { source: 'good_job' })
             end
-          end
+          }
         end
 
         def handle_perform(event)
           payload = event.payload
           job = payload[:job]
-          job_class = job&.class&.name || payload[:job_class] || "Unknown"
-          queue = job&.queue_name || payload[:queue_name] || "default"
+          job_class = job&.class&.name || payload[:job_class] || 'Unknown'
+          queue = job&.queue_name || payload[:queue_name] || 'default'
           duration_ms = event.duration.round(2)
 
           # Track with Pulse
           if BrainzLab.configuration.pulse_effectively_enabled?
             BrainzLab::Pulse.record_trace(
               "job.#{job_class}",
-              kind: "job",
+              kind: 'job',
               started_at: event.time,
               ended_at: event.end,
               job_class: job_class,
@@ -67,33 +70,30 @@ module BrainzLab
           # Track with Flux
           if BrainzLab.configuration.flux_effectively_enabled?
             tags = { job_class: job_class, queue: queue }
-            BrainzLab::Flux.distribution("good_job.job.duration_ms", duration_ms, tags: tags)
-            BrainzLab::Flux.increment("good_job.job.processed", tags: tags)
+            BrainzLab::Flux.distribution('good_job.job.duration_ms', duration_ms, tags: tags)
+            BrainzLab::Flux.increment('good_job.job.processed', tags: tags)
 
-            if payload[:error]
-              BrainzLab::Flux.increment("good_job.job.failed", tags: tags)
-            end
+            BrainzLab::Flux.increment('good_job.job.failed', tags: tags) if payload[:error]
           end
 
           # Capture error with Reflex
-          if payload[:error] && BrainzLab.configuration.reflex_effectively_enabled?
-            BrainzLab::Reflex.capture(payload[:error],
-              tags: { job_class: job_class, queue: queue, source: "good_job" },
-              extra: { job_id: job&.job_id, duration_ms: duration_ms }
-            )
-          end
+          return unless payload[:error] && BrainzLab.configuration.reflex_effectively_enabled?
+
+          BrainzLab::Reflex.capture(payload[:error],
+                                    tags: { job_class: job_class, queue: queue, source: 'good_job' },
+                                    extra: { job_id: job&.job_id, duration_ms: duration_ms })
         end
 
         def handle_finished(event)
           payload = event.payload
 
-          if BrainzLab.configuration.flux_effectively_enabled?
-            result = payload[:result]
-            if result == :discarded
-              BrainzLab::Flux.increment("good_job.job.discarded")
-            elsif result == :retried
-              BrainzLab::Flux.increment("good_job.job.retried")
-            end
+          return unless BrainzLab.configuration.flux_effectively_enabled?
+
+          result = payload[:result]
+          if result == :discarded
+            BrainzLab::Flux.increment('good_job.job.discarded')
+          elsif result == :retried
+            BrainzLab::Flux.increment('good_job.job.retried')
           end
         end
       end

data/lib/brainzlab/instrumentation/grape.rb

@@ -14,7 +14,7 @@ module BrainzLab
           install_notifications!
 
           @installed = true
-          BrainzLab.debug_log("Grape instrumentation installed")
+          BrainzLab.debug_log('Grape instrumentation installed')
         end
 
         def installed?
@@ -29,23 +29,23 @@ module BrainzLab
 
         def install_notifications!
           # Grape emits these notifications
-          ActiveSupport::Notifications.subscribe("endpoint_run.grape") do |*args|
+          ActiveSupport::Notifications.subscribe('endpoint_run.grape') do |*args|
             event = ActiveSupport::Notifications::Event.new(*args)
             record_endpoint(event)
           end
 
-          ActiveSupport::Notifications.subscribe("endpoint_render.grape") do |*args|
+          ActiveSupport::Notifications.subscribe('endpoint_render.grape') do |*args|
             event = ActiveSupport::Notifications::Event.new(*args)
             record_render(event)
           end
 
-          ActiveSupport::Notifications.subscribe("endpoint_run_filters.grape") do |*args|
+          ActiveSupport::Notifications.subscribe('endpoint_run_filters.grape') do |*args|
             event = ActiveSupport::Notifications::Event.new(*args)
             record_filters(event)
           end
 
           # Format validation
-          ActiveSupport::Notifications.subscribe("format_response.grape") do |*args|
+          ActiveSupport::Notifications.subscribe('format_response.grape') do |*args|
             event = ActiveSupport::Notifications::Event.new(*args)
             record_format(event)
           end
@@ -58,19 +58,19 @@ module BrainzLab
           endpoint = payload[:endpoint]
           env = payload[:env] || {}
 
-          method = env["REQUEST_METHOD"] || "GET"
-          path = endpoint&.options&.dig(:path)&.first || env["PATH_INFO"] || "/"
+          method = env['REQUEST_METHOD'] || 'GET'
+          path = endpoint&.options&.dig(:path)&.first || env['PATH_INFO'] || '/'
           route_pattern = extract_route_pattern(endpoint)
           duration_ms = event.duration.round(2)
 
-          status = env["api.endpoint"]&.status || 200
+          status = env['api.endpoint']&.status || 200
           level = status >= 400 ? :error : :info
 
           # Add breadcrumb for Reflex
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "Grape #{method} #{route_pattern}",
-              category: "grape.endpoint",
+              category: 'grape.endpoint',
               level: level,
               data: {
                 method: method,
@@ -85,7 +85,7 @@ module BrainzLab
           # Record span for Pulse
           record_span(
             name: "Grape #{method} #{route_pattern}",
-            kind: "grape",
+            kind: 'grape',
             started_at: event.time,
             ended_at: event.end,
             duration_ms: duration_ms,
@@ -117,12 +117,12 @@ module BrainzLab
           duration_ms = event.duration.round(2)
 
           record_span(
-            name: "Grape render",
-            kind: "grape.render",
+            name: 'Grape render',
+            kind: 'grape.render',
             started_at: event.time,
             ended_at: event.end,
             duration_ms: duration_ms,
-            data: { phase: "render" }
+            data: { phase: 'render' }
           )
         rescue StandardError => e
           BrainzLab.debug_log("Grape render recording failed: #{e.message}")
@@ -131,11 +131,11 @@ module BrainzLab
         def record_filters(event)
           payload = event.payload
           duration_ms = event.duration.round(2)
-          filter_type = payload[:type] || "filter"
+          filter_type = payload[:type] || 'filter'
 
           record_span(
             name: "Grape #{filter_type} filters",
-            kind: "grape.filter",
+            kind: 'grape.filter',
             started_at: event.time,
             ended_at: event.end,
             duration_ms: duration_ms,
@@ -149,12 +149,12 @@ module BrainzLab
           duration_ms = event.duration.round(2)
 
           record_span(
-            name: "Grape format response",
-            kind: "grape.format",
+            name: 'Grape format response',
+            kind: 'grape.format',
             started_at: event.time,
             ended_at: event.end,
             duration_ms: duration_ms,
-            data: { phase: "format" }
+            data: { phase: 'format' }
           )
         rescue StandardError => e
           BrainzLab.debug_log("Grape format recording failed: #{e.message}")
@@ -177,14 +177,14 @@ module BrainzLab
         end
 
         def extract_route_pattern(endpoint)
-          return "/" unless endpoint
+          return '/' unless endpoint
 
           route = endpoint.route
-          return "/" unless route
+          return '/' unless route
 
-          route.pattern&.path || route.path || "/"
+          route.pattern&.path || route.path || '/'
         rescue StandardError
-          "/"
+          '/'
         end
       end
 
@@ -243,14 +243,14 @@ module BrainzLab
           path = request.path
 
           # Get route pattern from Grape if available
-          route_pattern = env["grape.routing_args"]&.dig(:route_info)&.pattern&.path || path
+          route_pattern = env['grape.routing_args']&.dig(:route_info)&.pattern&.path || path
 
           spans = Thread.current[:brainzlab_pulse_spans] || []
 
           payload = {
             trace_id: SecureRandom.uuid,
             name: "#{method} #{route_pattern}",
-            kind: "request",
+            kind: 'request',
             started_at: started_at.utc.iso8601(3),
             ended_at: ended_at.utc.iso8601(3),
             duration_ms: duration_ms,