brainzlab 0.1.2 → 0.1.4

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

data/lib/brainzlab/instrumentation.rb

@@ -31,9 +31,17 @@ module BrainzLab
         # Elasticsearch instrumentation
         install_elasticsearch! if config.instrument_elasticsearch
 
-        # ActionMailer instrumentation
+        # Rails MVC instrumentation
+        install_action_controller! if config.instrument_action_controller
+        install_action_view! if config.instrument_action_view
         install_action_mailer! if config.instrument_action_mailer
 
+        # ActiveJob instrumentation (covers all job backends)
+        install_active_job! if config.instrument_active_job
+
+        # ActiveSupport::Cache instrumentation
+        install_active_support_cache! if config.instrument_active_support_cache
+
         # Delayed::Job instrumentation
         install_delayed_job! if config.instrument_delayed_job
 
@@ -55,144 +63,226 @@ module BrainzLab
         # Cloud & Payment
         install_aws! if config.instrument_aws
         install_stripe! if config.instrument_stripe
+
+        # File storage
+        install_active_storage! if config.instrument_active_storage
+
+        # WebSocket
+        install_action_cable! if config.instrument_action_cable
+
+        # Rails framework events
+        install_action_dispatch! if config.instrument_action_dispatch
+        install_rails_deprecation! if config.instrument_rails_deprecation
+        install_action_mailbox! if config.instrument_action_mailbox
+        install_railties! if config.instrument_railties
       end
 
       def install_net_http!
-        require_relative "instrumentation/net_http"
+        require_relative 'instrumentation/net_http'
         NetHttp.install!
       end
 
       def install_faraday!
         return unless defined?(::Faraday)
 
-        require_relative "instrumentation/faraday"
+        require_relative 'instrumentation/faraday'
         FaradayMiddleware.install!
       end
 
       def install_httparty!
         return unless defined?(::HTTParty)
 
-        require_relative "instrumentation/httparty"
+        require_relative 'instrumentation/httparty'
         HTTPartyInstrumentation.install!
       end
 
       def install_active_record!
-        require_relative "instrumentation/active_record"
+        require_relative 'instrumentation/active_record'
         ActiveRecord.install!
       end
 
       def install_redis!
         return unless defined?(::Redis)
 
-        require_relative "instrumentation/redis"
+        require_relative 'instrumentation/redis'
         RedisInstrumentation.install!
       end
 
       def install_sidekiq!
         return unless defined?(::Sidekiq)
 
-        require_relative "instrumentation/sidekiq"
+        require_relative 'instrumentation/sidekiq'
         SidekiqInstrumentation.install!
       end
 
       def install_graphql!
         return unless defined?(::GraphQL)
 
-        require_relative "instrumentation/graphql"
+        require_relative 'instrumentation/graphql'
         GraphQLInstrumentation.install!
       end
 
       def install_mongodb!
         return unless defined?(::Mongo) || defined?(::Mongoid)
 
-        require_relative "instrumentation/mongodb"
+        require_relative 'instrumentation/mongodb'
         MongoDBInstrumentation.install!
       end
 
       def install_elasticsearch!
         return unless defined?(::Elasticsearch) || defined?(::OpenSearch)
 
-        require_relative "instrumentation/elasticsearch"
+        require_relative 'instrumentation/elasticsearch'
         ElasticsearchInstrumentation.install!
       end
 
+      def install_action_controller!
+        return unless defined?(::ActionController)
+
+        require_relative 'instrumentation/action_controller'
+        ActionController.install!
+      end
+
+      def install_action_view!
+        return unless defined?(::ActionView)
+
+        require_relative 'instrumentation/action_view'
+        ActionView.install!
+      end
+
       def install_action_mailer!
         return unless defined?(::ActionMailer)
 
-        require_relative "instrumentation/action_mailer"
+        require_relative 'instrumentation/action_mailer'
         ActionMailerInstrumentation.install!
       end
 
+      def install_active_job!
+        return unless defined?(::ActiveJob)
+
+        require_relative 'instrumentation/active_job'
+        ActiveJob.install!
+      end
+
+      def install_active_support_cache!
+        return unless defined?(::ActiveSupport::Cache)
+
+        require_relative 'instrumentation/active_support_cache'
+        ActiveSupportCache.install!
+      end
+
       def install_delayed_job!
         return unless defined?(::Delayed::Job) || defined?(::Delayed::Backend)
 
-        require_relative "instrumentation/delayed_job"
+        require_relative 'instrumentation/delayed_job'
         DelayedJobInstrumentation.install!
       end
 
       def install_grape!
         return unless defined?(::Grape::API)
 
-        require_relative "instrumentation/grape"
+        require_relative 'instrumentation/grape'
         GrapeInstrumentation.install!
       end
 
       def install_solid_queue!
         return unless defined?(::SolidQueue)
 
-        require_relative "instrumentation/solid_queue"
+        require_relative 'instrumentation/solid_queue'
         SolidQueueInstrumentation.install!
       end
 
       def install_good_job!
         return unless defined?(::GoodJob)
 
-        require_relative "instrumentation/good_job"
+        require_relative 'instrumentation/good_job'
         GoodJobInstrumentation.install!
       end
 
       def install_resque!
         return unless defined?(::Resque)
 
-        require_relative "instrumentation/resque"
+        require_relative 'instrumentation/resque'
         ResqueInstrumentation.install!
       end
 
       def install_excon!
         return unless defined?(::Excon)
 
-        require_relative "instrumentation/excon"
+        require_relative 'instrumentation/excon'
         ExconInstrumentation.install!
       end
 
       def install_typhoeus!
         return unless defined?(::Typhoeus)
 
-        require_relative "instrumentation/typhoeus"
+        require_relative 'instrumentation/typhoeus'
         TyphoeusInstrumentation.install!
       end
 
       def install_dalli!
         return unless defined?(::Dalli::Client)
 
-        require_relative "instrumentation/dalli"
+        require_relative 'instrumentation/dalli'
         DalliInstrumentation.install!
       end
 
       def install_aws!
         return unless defined?(::Aws)
 
-        require_relative "instrumentation/aws"
+        require_relative 'instrumentation/aws'
         AWSInstrumentation.install!
       end
 
       def install_stripe!
         return unless defined?(::Stripe)
 
-        require_relative "instrumentation/stripe"
+        require_relative 'instrumentation/stripe'
         StripeInstrumentation.install!
       end
 
+      def install_active_storage!
+        return unless defined?(::ActiveStorage)
+
+        require_relative 'instrumentation/active_storage'
+        ActiveStorage.install!
+      end
+
+      def install_action_cable!
+        return unless defined?(::ActionCable)
+
+        require_relative 'instrumentation/action_cable'
+        ActionCable.install!
+      end
+
+      def install_action_dispatch!
+        return unless defined?(::ActionDispatch)
+
+        require_relative 'instrumentation/action_dispatch'
+        ActionDispatch.install!
+      end
+
+      def install_rails_deprecation!
+        return unless defined?(::Rails)
+
+        require_relative 'instrumentation/rails_deprecation'
+        RailsDeprecation.install!
+      end
+
+      def install_action_mailbox!
+        return unless defined?(::ActionMailbox)
+
+        require_relative 'instrumentation/action_mailbox'
+        ActionMailbox.install!
+      end
+
+      def install_railties!
+        return unless defined?(::Rails)
+
+        require_relative 'instrumentation/railties'
+        Railties.install!
+      end
+
       # Manual installation methods for lazy-loaded libraries
       def install_http!
         install_net_http!