brainzlab 0.1.2 → 0.1.4

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,

data/lib/brainzlab/instrumentation/graphql.rb

@@ -13,14 +13,14 @@ module BrainzLab
           # For GraphQL Ruby 2.0+
           if ::GraphQL::Schema.respond_to?(:trace_with)
             # Will be installed per-schema via BrainzLab::GraphQL::Tracer
-            BrainzLab.debug_log("GraphQL tracer available - add `trace_with BrainzLab::Instrumentation::GraphQLInstrumentation::Tracer` to your schema")
+            BrainzLab.debug_log('GraphQL tracer available - add `trace_with BrainzLab::Instrumentation::GraphQLInstrumentation::Tracer` to your schema')
           end
 
           # Subscribe to ActiveSupport notifications if available
           install_notifications!
 
           @installed = true
-          BrainzLab.debug_log("GraphQL instrumentation installed")
+          BrainzLab.debug_log('GraphQL instrumentation installed')
         end
 
         def installed?
@@ -35,17 +35,17 @@ module BrainzLab
 
         def install_notifications!
           # GraphQL-ruby emits ActiveSupport notifications
-          ActiveSupport::Notifications.subscribe("execute.graphql") do |*args|
+          ActiveSupport::Notifications.subscribe('execute.graphql') do |*args|
             event = ActiveSupport::Notifications::Event.new(*args)
             record_execution(event)
           end
 
-          ActiveSupport::Notifications.subscribe("analyze.graphql") do |*args|
+          ActiveSupport::Notifications.subscribe('analyze.graphql') do |*args|
             event = ActiveSupport::Notifications::Event.new(*args)
             record_analyze(event)
           end
 
-          ActiveSupport::Notifications.subscribe("validate.graphql") do |*args|
+          ActiveSupport::Notifications.subscribe('validate.graphql') do |*args|
             event = ActiveSupport::Notifications::Event.new(*args)
             record_validate(event)
           end
@@ -56,15 +56,15 @@ module BrainzLab
         def record_execution(event)
           payload = event.payload
           query = payload[:query]
-          operation_name = query&.operation_name || "anonymous"
-          operation_type = query&.selected_operation&.operation_type || "query"
+          operation_name = query&.operation_name || 'anonymous'
+          operation_type = query&.selected_operation&.operation_type || 'query'
           duration_ms = event.duration.round(2)
 
           # Add breadcrumb
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "GraphQL #{operation_type} #{operation_name}",
-              category: "graphql.execute",
+              category: 'graphql.execute',
               level: payload[:errors]&.any? ? :error : :info,
               data: {
                 operation_name: operation_name,
@@ -78,7 +78,7 @@ module BrainzLab
           # Record span
           record_span(
             name: "GraphQL #{operation_type} #{operation_name}",
-            kind: "graphql",
+            kind: 'graphql',
             duration_ms: duration_ms,
             started_at: event.time,
             ended_at: event.end,
@@ -97,12 +97,12 @@ module BrainzLab
 
         def record_analyze(event)
           record_span(
-            name: "GraphQL analyze",
-            kind: "graphql",
+            name: 'GraphQL analyze',
+            kind: 'graphql',
             duration_ms: event.duration.round(2),
             started_at: event.time,
             ended_at: event.end,
-            data: { phase: "analyze" }
+            data: { phase: 'analyze' }
           )
         rescue StandardError => e
           BrainzLab.debug_log("GraphQL analyze recording failed: #{e.message}")
@@ -110,12 +110,12 @@ module BrainzLab
 
         def record_validate(event)
           record_span(
-            name: "GraphQL validate",
-            kind: "graphql",
+            name: 'GraphQL validate',
+            kind: 'graphql',
             duration_ms: event.duration.round(2),
             started_at: event.time,
             ended_at: event.end,
-            data: { phase: "validate" }
+            data: { phase: 'validate' }
           )
         rescue StandardError => e
           BrainzLab.debug_log("GraphQL validate recording failed: #{e.message}")
@@ -139,6 +139,7 @@ module BrainzLab
 
         def truncate_query(query)
           return nil unless query
+
           query.to_s[0, 2000]
         end
 
@@ -148,7 +149,7 @@ module BrainzLab
           scrub_fields = BrainzLab.configuration.scrub_fields
           variables.transform_values do |value|
             if scrub_fields.any? { |f| value.to_s.downcase.include?(f.to_s) }
-              "[FILTERED]"
+              '[FILTERED]'
             else
               value
             end
@@ -163,19 +164,19 @@ module BrainzLab
       module Tracer
         def execute_query(query:)
           started_at = Time.now.utc
-          operation_name = query.operation_name || "anonymous"
-          operation_type = query.selected_operation&.operation_type || "query"
+          operation_name = query.operation_name || 'anonymous'
+          operation_type = query.selected_operation&.operation_type || 'query'
 
           result = super
 
           duration_ms = ((Time.now.utc - started_at) * 1000).round(2)
-          has_errors = result.to_h["errors"]&.any?
+          has_errors = result.to_h['errors']&.any?
 
           # Add breadcrumb
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "GraphQL #{operation_type} #{operation_name}",
-              category: "graphql.execute",
+              category: 'graphql.execute',
               level: has_errors ? :error : :info,
               data: {
                 operation_name: operation_name,
@@ -191,7 +192,7 @@ module BrainzLab
             spans << {
               span_id: SecureRandom.uuid,
               name: "GraphQL #{operation_type} #{operation_name}",
-              kind: "graphql",
+              kind: 'graphql',
               started_at: started_at,
               ended_at: Time.now.utc,
               duration_ms: duration_ms,
@@ -209,7 +210,7 @@ module BrainzLab
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "GraphQL #{operation_type} #{operation_name} failed",
-              category: "graphql.error",
+              category: 'graphql.error',
               level: :error,
               data: { error: e.class.name }
             )
@@ -231,7 +232,7 @@ module BrainzLab
               spans << {
                 span_id: SecureRandom.uuid,
                 name: "GraphQL field #{field.owner.graphql_name}.#{field.graphql_name}",
-                kind: "graphql.field",
+                kind: 'graphql.field',
                 started_at: started_at,
                 ended_at: Time.now.utc,
                 duration_ms: duration_ms,

data/lib/brainzlab/instrumentation/httparty.rb

@@ -13,7 +13,7 @@ module BrainzLab
           ::HTTParty.singleton_class.prepend(Patch)
 
           @installed = true
-          BrainzLab.debug_log("HTTParty instrumentation installed")
+          BrainzLab.debug_log('HTTParty instrumentation installed')
         end
 
         def installed?
@@ -26,14 +26,13 @@ module BrainzLab
       end
 
       module Patch
-        def perform_request(http_method, path, options = {}, &block)
+        def perform_request(http_method, path, options = {}, &)
           return super unless should_track?(path, options)
 
           # Inject distributed tracing headers
           options = inject_trace_context(options)
 
           started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          error_info = nil
 
           begin
             response = super
@@ -79,7 +78,7 @@ module BrainzLab
           method = extract_method_name(http_method)
           uri = parse_uri(path, options)
           url = uri ? sanitize_url(uri) : path.to_s
-          host = uri&.host || "unknown"
+          host = uri&.host || 'unknown'
           request_path = uri&.path || path.to_s
           level = error || (status && status >= 400) ? :error : :info
 
@@ -87,7 +86,7 @@ module BrainzLab
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "#{method} #{url}",
-              category: "http.httparty",
+              category: 'http.httparty',
               level: level,
               data: {
                 method: method,
@@ -127,7 +126,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,
@@ -149,14 +148,14 @@ module BrainzLab
 
         def extract_method_name(http_method)
           case http_method.name
-          when /Get$/ then "GET"
-          when /Post$/ then "POST"
-          when /Put$/ then "PUT"
-          when /Patch$/ then "PATCH"
-          when /Delete$/ then "DELETE"
-          when /Head$/ then "HEAD"
-          when /Options$/ then "OPTIONS"
-          else http_method.name.split("::").last.upcase
+          when /Get$/ then 'GET'
+          when /Post$/ then 'POST'
+          when /Put$/ then 'PUT'
+          when /Patch$/ then 'PATCH'
+          when /Delete$/ then 'DELETE'
+          when /Head$/ then 'HEAD'
+          when /Options$/ then 'OPTIONS'
+          else http_method.name.split('::').last.upcase
           end
         end
 

data/lib/brainzlab/instrumentation/mongodb.rb

@@ -26,7 +26,7 @@ module BrainzLab
           return unless installed_any
 
           @installed = true
-          BrainzLab.debug_log("MongoDB instrumentation installed")
+          BrainzLab.debug_log('MongoDB instrumentation installed')
         end
 
         def installed?
@@ -51,9 +51,9 @@ module BrainzLab
 
         def install_mongoid!
           # For Mongoid 7+, use the APM module
-          if ::Mongoid.respond_to?(:subscribe)
-            ::Mongoid.subscribe(CommandSubscriber.new)
-          end
+          return unless ::Mongoid.respond_to?(:subscribe)
+
+          ::Mongoid.subscribe(CommandSubscriber.new)
         end
       end
 
@@ -96,7 +96,7 @@ module BrainzLab
         def extract_collection(event)
           # Try to extract collection name from command
           cmd = event.command
-          cmd["collection"] || cmd[event.command_name] || cmd.keys.first
+          cmd['collection'] || cmd[event.command_name] || cmd.keys.first
         rescue StandardError
           nil
         end
@@ -116,7 +116,7 @@ module BrainzLab
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "MongoDB #{command_name}",
-              category: "mongodb",
+              category: 'mongodb',
               level: level,
               data: {
                 command: command_name,
@@ -163,7 +163,7 @@ module BrainzLab
           span = {
             span_id: SecureRandom.uuid,
             name: "MongoDB #{command_name} #{collection}".strip,
-            kind: "mongodb",
+            kind: 'mongodb',
             started_at: started_at,
             ended_at: Time.now.utc,
             duration_ms: duration_ms.round(2),

data/lib/brainzlab/instrumentation/net_http.rb

@@ -24,7 +24,7 @@ module BrainzLab
       end
 
       module Patch
-        def request(req, body = nil, &block)
+        def request(req, body = nil, &)
           return super unless should_track?
 
           # Inject distributed tracing context into outgoing request headers
@@ -38,7 +38,7 @@ module BrainzLab
             response = super
             track_request(method, url, response.code.to_i, started_at)
             response
-          rescue => e
+          rescue StandardError => e
             track_request(method, url, nil, started_at, e.class.name)
             raise
           end
@@ -69,9 +69,9 @@ module BrainzLab
         end
 
         def build_url(req)
-          scheme = use_ssl? ? "https" : "http"
+          scheme = use_ssl? ? 'https' : 'http'
           port_str = if (use_ssl? && port == 443) || (!use_ssl? && port == 80)
-                       ""
+                       ''
                      else
                        ":#{port}"
                      end
@@ -86,7 +86,7 @@ module BrainzLab
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "#{method} #{url}",
-              category: "http",
+              category: 'http',
               level: level,
               data: { method: method, url: url, status_code: status, duration_ms: duration_ms, error: error }.compact
             )
@@ -99,7 +99,7 @@ module BrainzLab
               method: method, url: url, status_code: status, duration_ms: duration_ms, error: error
             )
           end
-        rescue => e
+        rescue StandardError => e
           # Don't let instrumentation errors crash the app
           BrainzLab.configuration.logger&.error("[BrainzLab] HTTP instrumentation error: #{e.message}")
         end