brainzlab 0.1.2 → 0.1.4

data/lib/brainzlab/instrumentation/aws.rb

@@ -9,7 +9,7 @@ module BrainzLab
 
           install_plugin!
 
-          BrainzLab.debug_log("[Instrumentation] AWS SDK instrumentation installed")
+          BrainzLab.debug_log('[Instrumentation] AWS SDK instrumentation installed')
         end
 
         private
@@ -22,16 +22,16 @@ module BrainzLab
           end
 
           # Also hook into Seahorse for lower-level tracking
-          if defined?(::Seahorse::Client::Base)
-            install_seahorse_handler!
-          end
+          return unless defined?(::Seahorse::Client::Base)
+
+          install_seahorse_handler!
         end
 
         def install_seahorse_handler!
           handler_class = Class.new(::Seahorse::Client::Handler) do
             def call(context)
               started_at = Time.now
-              service = context.client.class.name.split("::")[1] || "AWS"
+              service = context.client.class.name.split('::')[1] || 'AWS'
               operation = context.operation_name.to_s
 
               begin
@@ -46,12 +46,12 @@ module BrainzLab
 
             private
 
-            def track_success(service, operation, started_at, context, response)
+            def track_success(service, operation, started_at, context, _response)
               duration_ms = ((Time.now - started_at) * 1000).round(2)
 
               BrainzLab::Reflex.add_breadcrumb(
                 "AWS #{service}.#{operation}",
-                category: "aws",
+                category: 'aws',
                 level: :info,
                 data: {
                   service: service,
@@ -61,19 +61,19 @@ module BrainzLab
                 }
               )
 
-              if BrainzLab.configuration.flux_effectively_enabled?
-                tags = { service: service, operation: operation, region: context.config.region }
-                BrainzLab::Flux.distribution("aws.duration_ms", duration_ms, tags: tags)
-                BrainzLab::Flux.increment("aws.requests", tags: tags)
-              end
+              return unless BrainzLab.configuration.flux_effectively_enabled?
+
+              tags = { service: service, operation: operation, region: context.config.region }
+              BrainzLab::Flux.distribution('aws.duration_ms', duration_ms, tags: tags)
+              BrainzLab::Flux.increment('aws.requests', tags: tags)
             end
 
-            def track_error(service, operation, started_at, context, error)
-              duration_ms = ((Time.now - started_at) * 1000).round(2)
+            def track_error(service, operation, started_at, _context, error)
+              ((Time.now - started_at) * 1000).round(2)
 
               BrainzLab::Reflex.add_breadcrumb(
                 "AWS #{service}.#{operation} failed: #{error.message}",
-                category: "aws",
+                category: 'aws',
                 level: :error,
                 data: {
                   service: service,
@@ -82,16 +82,16 @@ module BrainzLab
                 }
               )
 
-              if BrainzLab.configuration.flux_effectively_enabled?
-                tags = { service: service, operation: operation, error_class: error.class.name }
-                BrainzLab::Flux.increment("aws.errors", tags: tags)
-              end
+              return unless BrainzLab.configuration.flux_effectively_enabled?
+
+              tags = { service: service, operation: operation, error_class: error.class.name }
+              BrainzLab::Flux.increment('aws.errors', tags: tags)
             end
           end
 
           ::Seahorse::Client::Base.add_plugin(
             Class.new(::Seahorse::Client::Plugin) do
-              define_method(:add_handlers) do |handlers, config|
+              define_method(:add_handlers) do |handlers, _config|
                 handlers.add(handler_class, step: :validate, priority: 0)
               end
             end
@@ -101,7 +101,7 @@ module BrainzLab
 
       # Aws SDK Plugin
       class BrainzLabPlugin
-        def self.add_handlers(handlers, config)
+        def self.add_handlers(handlers, _config)
           handlers.add(Handler, step: :validate, priority: 0)
         end
 
@@ -128,16 +128,20 @@ module BrainzLab
           private
 
           def extract_service(context)
-            context.client.class.name.to_s.split("::")[1] || "AWS"
+            context.client.class.name.to_s.split('::')[1] || 'AWS'
           end
 
-          def track_request(service, operation, started_at, context, response)
+          def track_request(service, operation, started_at, context, _response)
             duration_ms = ((Time.now - started_at) * 1000).round(2)
-            region = context.config.region rescue "unknown"
+            region = begin
+              context.config.region
+            rescue StandardError
+              'unknown'
+            end
 
             BrainzLab::Reflex.add_breadcrumb(
               "AWS #{service}.#{operation}",
-              category: "aws",
+              category: 'aws',
               level: :info,
               data: {
                 service: service,
@@ -148,29 +152,29 @@ module BrainzLab
               }
             )
 
-            if BrainzLab.configuration.flux_effectively_enabled?
-              tags = { service: service, operation: operation, region: region }
-              BrainzLab::Flux.distribution("aws.duration_ms", duration_ms, tags: tags)
-              BrainzLab::Flux.increment("aws.requests", tags: tags)
+            return unless BrainzLab.configuration.flux_effectively_enabled?
 
-              if context.retries > 0
-                BrainzLab::Flux.increment("aws.retries", value: context.retries, tags: tags)
-              end
-            end
+            tags = { service: service, operation: operation, region: region }
+            BrainzLab::Flux.distribution('aws.duration_ms', duration_ms, tags: tags)
+            BrainzLab::Flux.increment('aws.requests', tags: tags)
+
+            return unless context.retries.positive?
+
+            BrainzLab::Flux.increment('aws.retries', value: context.retries, tags: tags)
           end
 
-          def track_error(service, operation, started_at, context, error)
+          def track_error(service, operation, _started_at, _context, error)
             BrainzLab::Reflex.add_breadcrumb(
               "AWS #{service}.#{operation} failed",
-              category: "aws",
+              category: 'aws',
               level: :error,
               data: { service: service, operation: operation, error: error.class.name }
             )
 
-            if BrainzLab.configuration.flux_effectively_enabled?
-              tags = { service: service, operation: operation, error_class: error.class.name }
-              BrainzLab::Flux.increment("aws.errors", tags: tags)
-            end
+            return unless BrainzLab.configuration.flux_effectively_enabled?
+
+            tags = { service: service, operation: operation, error_class: error.class.name }
+            BrainzLab::Flux.increment('aws.errors', tags: tags)
           end
         end
       end

data/lib/brainzlab/instrumentation/dalli.rb

@@ -11,7 +11,7 @@ module BrainzLab
 
           install_client_instrumentation!
 
-          BrainzLab.debug_log("[Instrumentation] Dalli/Memcached instrumentation installed")
+          BrainzLab.debug_log('[Instrumentation] Dalli/Memcached instrumentation installed')
         end
 
         private
@@ -54,42 +54,42 @@ module BrainzLab
         # Add breadcrumb
         BrainzLab::Reflex.add_breadcrumb(
           "Memcached #{command.upcase}",
-          category: "cache",
+          category: 'cache',
           level: :info,
           data: { command: command, key: key, duration_ms: duration_ms }
         )
 
         # Track with Flux
-        if BrainzLab.configuration.flux_effectively_enabled?
-          tags = { command: command }
-          BrainzLab::Flux.distribution("memcached.duration_ms", duration_ms, tags: tags)
-          BrainzLab::Flux.increment("memcached.commands", tags: tags)
-
-          # Track cache hits/misses for get commands
-          if command == "get"
-            if result.nil?
-              BrainzLab::Flux.increment("memcached.miss", tags: tags)
-            else
-              BrainzLab::Flux.increment("memcached.hit", tags: tags)
-            end
-          end
+        return unless BrainzLab.configuration.flux_effectively_enabled?
+
+        tags = { command: command }
+        BrainzLab::Flux.distribution('memcached.duration_ms', duration_ms, tags: tags)
+        BrainzLab::Flux.increment('memcached.commands', tags: tags)
+
+        # Track cache hits/misses for get commands
+        return unless command == 'get'
+
+        if result.nil?
+          BrainzLab::Flux.increment('memcached.miss', tags: tags)
+        else
+          BrainzLab::Flux.increment('memcached.hit', tags: tags)
         end
       end
 
       def self.track_error(command, args, started_at, error)
-        duration_ms = ((Time.now - started_at) * 1000).round(2)
+        ((Time.now - started_at) * 1000).round(2)
         key = extract_key(args)
 
         BrainzLab::Reflex.add_breadcrumb(
           "Memcached #{command.upcase} failed: #{error.message}",
-          category: "cache",
+          category: 'cache',
           level: :error,
           data: { command: command, key: key, error: error.class.name }
         )
 
-        if BrainzLab.configuration.flux_effectively_enabled?
-          BrainzLab::Flux.increment("memcached.errors", tags: { command: command })
-        end
+        return unless BrainzLab.configuration.flux_effectively_enabled?
+
+        BrainzLab::Flux.increment('memcached.errors', tags: { command: command })
       end
 
       def self.extract_key(args)

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,