brainzlab 0.1.1 → 0.1.3

data/lib/brainzlab/instrumentation/aws.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module AWSInstrumentation
+      class << self
+        def install!
+          return unless defined?(::Aws)
+
+          install_plugin!
+
+          BrainzLab.debug_log('[Instrumentation] AWS SDK instrumentation installed')
+        end
+
+        private
+
+        def install_plugin!
+          # AWS SDK v3 uses plugins
+          if defined?(::Aws::Plugins)
+            ::Aws.config[:plugins] ||= []
+            ::Aws.config[:plugins] << BrainzLabPlugin unless ::Aws.config[:plugins].include?(BrainzLabPlugin)
+          end
+
+          # Also hook into Seahorse for lower-level tracking
+          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'
+              operation = context.operation_name.to_s
+
+              begin
+                response = @handler.call(context)
+                track_success(service, operation, started_at, context, response)
+                response
+              rescue StandardError => e
+                track_error(service, operation, started_at, context, e)
+                raise
+              end
+            end
+
+            private
+
+            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',
+                level: :info,
+                data: {
+                  service: service,
+                  operation: operation,
+                  region: context.config.region,
+                  duration_ms: duration_ms
+                }
+              )
+
+              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)
+              ((Time.now - started_at) * 1000).round(2)
+
+              BrainzLab::Reflex.add_breadcrumb(
+                "AWS #{service}.#{operation} failed: #{error.message}",
+                category: 'aws',
+                level: :error,
+                data: {
+                  service: service,
+                  operation: operation,
+                  error: error.class.name
+                }
+              )
+
+              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|
+                handlers.add(handler_class, step: :validate, priority: 0)
+              end
+            end
+          )
+        end
+      end
+
+      # Aws SDK Plugin
+      class BrainzLabPlugin
+        def self.add_handlers(handlers, _config)
+          handlers.add(Handler, step: :validate, priority: 0)
+        end
+
+        class Handler
+          def initialize(handler)
+            @handler = handler
+          end
+
+          def call(context)
+            started_at = Time.now
+            service = extract_service(context)
+            operation = context.operation_name.to_s
+
+            begin
+              response = @handler.call(context)
+              track_request(service, operation, started_at, context, response)
+              response
+            rescue StandardError => e
+              track_error(service, operation, started_at, context, e)
+              raise
+            end
+          end
+
+          private
+
+          def extract_service(context)
+            context.client.class.name.to_s.split('::')[1] || 'AWS'
+          end
+
+          def track_request(service, operation, started_at, context, _response)
+            duration_ms = ((Time.now - started_at) * 1000).round(2)
+            region = begin
+              context.config.region
+            rescue StandardError
+              'unknown'
+            end
+
+            BrainzLab::Reflex.add_breadcrumb(
+              "AWS #{service}.#{operation}",
+              category: 'aws',
+              level: :info,
+              data: {
+                service: service,
+                operation: operation,
+                region: region,
+                duration_ms: duration_ms,
+                retries: context.retries
+              }
+            )
+
+            return unless 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 context.retries.positive?
+
+            BrainzLab::Flux.increment('aws.retries', value: context.retries, tags: tags)
+          end
+
+          def track_error(service, operation, _started_at, _context, error)
+            BrainzLab::Reflex.add_breadcrumb(
+              "AWS #{service}.#{operation} failed",
+              category: 'aws',
+              level: :error,
+              data: { service: service, operation: operation, error: error.class.name }
+            )
+
+            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
+    end
+  end
+end

data/lib/brainzlab/instrumentation/dalli.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module DalliInstrumentation
+      TRACKED_COMMANDS = %w[get set add replace delete incr decr cas get_multi set_multi].freeze
+
+      class << self
+        def install!
+          return unless defined?(::Dalli::Client)
+
+          install_client_instrumentation!
+
+          BrainzLab.debug_log('[Instrumentation] Dalli/Memcached instrumentation installed')
+        end
+
+        private
+
+        def install_client_instrumentation!
+          ::Dalli::Client.class_eval do
+            TRACKED_COMMANDS.each do |cmd|
+              original_method = "original_#{cmd}"
+              next if method_defined?(original_method)
+
+              alias_method original_method, cmd
+
+              define_method(cmd) do |*args, &block|
+                BrainzLab::Instrumentation::DalliInstrumentation.track_command(cmd, args) do
+                  send(original_method, *args, &block)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def self.track_command(command, args)
+        started_at = Time.now
+
+        begin
+          result = yield
+          track_success(command, args, started_at, result)
+          result
+        rescue StandardError => e
+          track_error(command, args, started_at, e)
+          raise
+        end
+      end
+
+      def self.track_success(command, args, started_at, result)
+        duration_ms = ((Time.now - started_at) * 1000).round(2)
+        key = extract_key(args)
+
+        # Add breadcrumb
+        BrainzLab::Reflex.add_breadcrumb(
+          "Memcached #{command.upcase}",
+          category: 'cache',
+          level: :info,
+          data: { command: command, key: key, duration_ms: duration_ms }
+        )
+
+        # Track with Flux
+        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)
+        ((Time.now - started_at) * 1000).round(2)
+        key = extract_key(args)
+
+        BrainzLab::Reflex.add_breadcrumb(
+          "Memcached #{command.upcase} failed: #{error.message}",
+          category: 'cache',
+          level: :error,
+          data: { command: command, key: key, error: error.class.name }
+        )
+
+        return unless BrainzLab.configuration.flux_effectively_enabled?
+
+        BrainzLab::Flux.increment('memcached.errors', tags: { command: command })
+      end
+
+      def self.extract_key(args)
+        key = args.first
+        case key
+        when String
+          key.length > 50 ? "#{key[0..47]}..." : key
+        when Array
+          "[#{key.size} keys]"
+        else
+          key.to_s[0..50]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module ExconInstrumentation
+      class << self
+        def install!
+          return unless defined?(::Excon)
+
+          install_middleware!
+
+          BrainzLab.debug_log('[Instrumentation] Excon instrumentation installed')
+        end
+
+        private
+
+        def install_middleware!
+          # Add our instrumentor to Excon defaults
+          ::Excon.defaults[:instrumentor] = BrainzLabInstrumentor
+
+          # Also set up middleware
+          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 = {})
+          started_at = Time.now
+
+          begin
+            result = yield if block_given?
+            track_request(name, params, started_at, nil)
+            result
+          rescue StandardError => e
+            track_request(name, params, started_at, e)
+            raise
+          end
+        end
+
+        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] || '/'
+          status = params[:status]
+
+          # Add breadcrumb
+          BrainzLab::Reflex.add_breadcrumb(
+            "HTTP #{method} #{host}#{path}",
+            category: 'http',
+            level: error ? :error : :info,
+            data: {
+              method: method,
+              host: host,
+              path: path,
+              status: status,
+              duration_ms: duration_ms
+            }
+          )
+
+          # Track with Pulse
+          if BrainzLab.configuration.pulse_effectively_enabled?
+            BrainzLab::Pulse.span('http.excon', kind: 'http') do
+              # Already completed, just recording
+            end
+          end
+
+          # Track with Flux
+          return unless 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 error || (status && status >= 400)
+
+          BrainzLab::Flux.increment('http.excon.errors', tags: tags)
+        end
+
+        def self.skip_tracking?(params)
+          host = params[:host]
+          return true unless host
+
+          ignore_hosts = BrainzLab.configuration.http_ignore_hosts || []
+          ignore_hosts.any? { |h| host.include?(h) }
+        end
+      end
+
+      # Excon Middleware
+      class Middleware
+        def initialize(stack)
+          @stack = stack
+        end
+
+        def request_call(datum)
+          datum[:brainzlab_started_at] = Time.now
+          @stack.request_call(datum)
+        end
+
+        def response_call(datum)
+          track_response(datum)
+          @stack.response_call(datum)
+        end
+
+        def error_call(datum)
+          track_response(datum, error: true)
+          @stack.error_call(datum)
+        end
+
+        private
+
+        def track_response(datum, error: false)
+          started_at = datum[:brainzlab_started_at]
+          return unless started_at
+
+          host = datum[:host]
+          return if skip_host?(host)
+
+          duration_ms = ((Time.now - started_at) * 1000).round(2)
+          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',
+            level: error ? :error : :info,
+            data: { method: method, host: host, status: status, duration_ms: duration_ms }
+          )
+
+          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)
+          return true unless host
+
+          ignore_hosts = BrainzLab.configuration.http_ignore_hosts || []
+          ignore_hosts.any? { |h| host.include?(h) }
+        end
+      end
+    end
+  end
+end