fluyenta-ruby 0.1.14

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

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module DelayedJobInstrumentation
+      @installed = false
+
+      class << self
+        def install!
+          return unless defined?(::Delayed::Job) || defined?(::Delayed::Backend)
+          return if @installed
+
+          # Install lifecycle hooks
+          install_lifecycle_hooks! if defined?(::Delayed::Worker)
+
+          # Install plugin if Delayed::Plugin is available
+          ::Delayed::Worker.plugins << Plugin if defined?(::Delayed::Plugin)
+
+          @installed = true
+          BrainzLab.debug_log('Delayed::Job instrumentation installed')
+        end
+
+        def installed?
+          @installed
+        end
+
+        def reset!
+          @installed = false
+        end
+
+        private
+
+        def install_lifecycle_hooks!
+          ::Delayed::Worker.lifecycle.around(:invoke_job) do |job, *_args, &block|
+            around_invoke(job, &block)
+          end
+
+          ::Delayed::Worker.lifecycle.after(:error) do |_worker, job|
+            record_error(job)
+          end
+
+          ::Delayed::Worker.lifecycle.after(:failure) do |_worker, job|
+            record_failure(job)
+          end
+        rescue StandardError => e
+          BrainzLab.debug_log("Delayed::Job lifecycle hooks failed: #{e.message}")
+        end
+
+        def around_invoke(job, &block)
+          started_at = Time.now.utc
+          job_name = extract_job_name(job)
+          queue = job.queue || 'default'
+
+          # Calculate queue wait time
+          queue_wait_ms = job.created_at ? ((started_at - job.created_at) * 1000).round(2) : nil
+
+          # Set up context
+          setup_context(job, queue)
+
+          # Add breadcrumb
+          BrainzLab::Reflex.add_breadcrumb(
+            "DelayedJob #{job_name}",
+            category: 'job.delayed_job',
+            level: :info,
+            data: { job_id: job.id, queue: queue, attempts: job.attempts }
+          )
+
+          # Initialize Pulse tracing
+          Thread.current[:brainzlab_pulse_spans] = []
+          Thread.current[:brainzlab_pulse_breakdown] = nil
+
+          error_occurred = nil
+          begin
+            block.call(job)
+          rescue StandardError => e
+            error_occurred = e
+            raise
+          ensure
+            record_trace(
+              job: job,
+              job_name: job_name,
+              queue: queue,
+              started_at: started_at,
+              queue_wait_ms: queue_wait_ms,
+              error: error_occurred
+            )
+
+            cleanup_context
+          end
+        end
+
+        def setup_context(job, queue)
+          BrainzLab::Context.current.set_context(
+            job_class: extract_job_name(job),
+            job_id: job.id,
+            queue_name: queue,
+            attempts: job.attempts
+          )
+        end
+
+        def cleanup_context
+          Thread.current[:brainzlab_pulse_spans] = nil
+          Thread.current[:brainzlab_pulse_breakdown] = nil
+          BrainzLab::Context.clear!
+        end
+
+        def record_trace(job:, job_name:, queue:, started_at:, queue_wait_ms:, error:)
+          return unless BrainzLab.configuration.pulse_enabled
+
+          ended_at = Time.now.utc
+          duration_ms = ((ended_at - started_at) * 1000).round(2)
+
+          # Collect spans
+          spans = Thread.current[:brainzlab_pulse_spans] || []
+          breakdown = Thread.current[:brainzlab_pulse_breakdown] || {}
+
+          formatted_spans = spans.map do |span|
+            {
+              span_id: span[:span_id],
+              name: span[:name],
+              kind: span[:kind],
+              started_at: format_timestamp(span[:started_at]),
+              ended_at: format_timestamp(span[:ended_at]),
+              duration_ms: span[:duration_ms],
+              data: span[:data]
+            }.compact
+          end
+
+          payload = {
+            trace_id: SecureRandom.uuid,
+            name: job_name,
+            kind: 'job',
+            started_at: started_at.utc.iso8601(3),
+            ended_at: ended_at.utc.iso8601(3),
+            duration_ms: duration_ms,
+            job_class: job_name,
+            job_id: job.id.to_s,
+            queue: queue,
+            queue_wait_ms: queue_wait_ms,
+            executions: (job.attempts || 0) + 1,
+            db_ms: breakdown[:db_ms],
+            error: error.present?,
+            error_class: error&.class&.name,
+            error_message: error&.message&.slice(0, 1000),
+            spans: formatted_spans,
+            environment: BrainzLab.configuration.environment,
+            commit: BrainzLab.configuration.commit,
+            host: BrainzLab.configuration.host
+          }
+
+          BrainzLab::Pulse.client.send_trace(payload.compact)
+        rescue StandardError => e
+          BrainzLab.debug_log("Delayed::Job trace recording failed: #{e.message}")
+        end
+
+        def record_error(job)
+          return unless job.last_error
+
+          BrainzLab::Reflex.add_breadcrumb(
+            "DelayedJob error: #{extract_job_name(job)}",
+            category: 'job.delayed_job.error',
+            level: :error,
+            data: {
+              job_id: job.id,
+              attempts: job.attempts,
+              error: job.last_error&.slice(0, 500)
+            }
+          )
+        rescue StandardError => e
+          BrainzLab.debug_log("Delayed::Job error recording failed: #{e.message}")
+        end
+
+        def record_failure(job)
+          BrainzLab::Reflex.add_breadcrumb(
+            "DelayedJob failed permanently: #{extract_job_name(job)}",
+            category: 'job.delayed_job.failure',
+            level: :error,
+            data: {
+              job_id: job.id,
+              attempts: job.attempts,
+              error: job.last_error&.slice(0, 500)
+            }
+          )
+        rescue StandardError => e
+          BrainzLab.debug_log("Delayed::Job failure recording failed: #{e.message}")
+        end
+
+        def extract_job_name(job)
+          payload = job.payload_object
+          case payload
+          when ::Delayed::PerformableMethod
+            "#{payload.object.class}##{payload.method_name}"
+          when ::Delayed::PerformableMailer
+            "#{payload.object}##{payload.method_name}"
+          else
+            payload.class.name
+          end
+        rescue StandardError
+          job.name || 'Unknown'
+        end
+
+        def format_timestamp(ts)
+          return nil unless ts
+
+          case ts
+          when Time, DateTime then ts.utc.iso8601(3)
+          when Float, Integer then Time.at(ts).utc.iso8601(3)
+          when String then ts
+          else ts.to_s
+          end
+        end
+      end
+
+      # Delayed::Job Plugin (alternative installation method)
+      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
+    end
+  end
+end