brainzlab 0.1.0 → 0.1.2

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
+        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
+        end
+      end
+
+      def self.track_error(command, args, started_at, error)
+        duration_ms = ((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 }
+        )
+
+        if BrainzLab.configuration.flux_effectively_enabled?
+          BrainzLab::Flux.increment("memcached.errors", tags: { command: command })
+        end
+      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/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
+          if ::Excon.defaults[:middlewares]
+            ::Excon.defaults[:middlewares] = [Middleware] + ::Excon.defaults[:middlewares]
+          end
+        end
+      end
+
+      # Excon Instrumentor for ActiveSupport-style notifications
+      module BrainzLabInstrumentor
+        def self.instrument(name, params = {}, &block)
+          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
+          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)
+
+            if error || (status && status >= 400)
+              BrainzLab::Flux.increment("http.excon.errors", tags: tags)
+            end
+          end
+        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 }
+          )
+
+          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
+        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

data/lib/brainzlab/instrumentation/good_job.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module GoodJobInstrumentation
+      class << self
+        def install!
+          return unless defined?(::GoodJob)
+
+          install_notifier!
+          install_middleware!
+
+          BrainzLab.debug_log("[Instrumentation] GoodJob instrumentation installed")
+        end
+
+        private
+
+        def install_notifier!
+          return unless defined?(::ActiveSupport::Notifications)
+
+          # GoodJob emits ActiveSupport notifications
+          ::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|
+            event = ::ActiveSupport::Notifications::Event.new(*args)
+            handle_finished(event)
+          end
+        end
+
+        def install_middleware!
+          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?
+            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"
+          duration_ms = event.duration.round(2)
+
+          # Track with Pulse
+          if BrainzLab.configuration.pulse_effectively_enabled?
+            BrainzLab::Pulse.record_trace(
+              "job.#{job_class}",
+              kind: "job",
+              started_at: event.time,
+              ended_at: event.end,
+              job_class: job_class,
+              job_id: job&.job_id || payload[:job_id],
+              queue: queue,
+              error: payload[:error].present?,
+              error_class: payload[:error]&.class&.name,
+              error_message: payload[:error]&.message
+            )
+          end
+
+          # 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)
+
+            if payload[:error]
+              BrainzLab::Flux.increment("good_job.job.failed", tags: tags)
+            end
+          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
+        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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/resque.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module ResqueInstrumentation
+      class << self
+        def install!
+          return unless defined?(::Resque)
+
+          install_hooks!
+          install_failure_backend!
+
+          BrainzLab.debug_log("[Instrumentation] Resque instrumentation installed")
+        end
+
+        private
+
+        def install_hooks!
+          ::Resque.before_fork do |job|
+            # Clear any stale connections before forking
+            BrainzLab::Recall.reset! if defined?(BrainzLab::Recall)
+            BrainzLab::Pulse.reset! if defined?(BrainzLab::Pulse)
+          end
+
+          ::Resque.after_fork do |job|
+            # Re-establish connections after forking
+          end
+        end
+
+        def install_failure_backend!
+          # Create a custom failure backend
+          failure_backend = Class.new do
+            def initialize(exception, worker, queue, payload)
+              @exception = exception
+              @worker = worker
+              @queue = queue
+              @payload = payload
+            end
+
+            def save
+              job_class = @payload["class"] || "Unknown"
+
+              if BrainzLab.configuration.reflex_effectively_enabled?
+                BrainzLab::Reflex.capture(@exception,
+                  tags: { job_class: job_class, queue: @queue, source: "resque" },
+                  extra: {
+                    worker: @worker.to_s,
+                    args: @payload["args"]
+                  }
+                )
+              end
+
+              if BrainzLab.configuration.flux_effectively_enabled?
+                BrainzLab::Flux.increment("resque.job.failed", tags: { job_class: job_class, queue: @queue })
+              end
+            end
+          end
+
+          # Add our failure backend to the chain
+          if defined?(::Resque::Failure)
+            ::Resque::Failure.backend = ::Resque::Failure::Multiple.new(
+              ::Resque::Failure.backend,
+              failure_backend
+            )
+          end
+        end
+      end
+
+      # Middleware module to include in Resque jobs
+      module Middleware
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def around_perform_brainzlab(*args)
+            job_class = self.name
+            queue = Resque.queue_from_class(self) || "default"
+            started_at = Time.now
+
+            BrainzLab::Context.current.set_context(
+              job_class: job_class,
+              queue: queue
+            )
+
+            begin
+              yield
+            ensure
+              duration_ms = ((Time.now - started_at) * 1000).round(2)
+
+              if BrainzLab.configuration.pulse_effectively_enabled?
+                BrainzLab::Pulse.record_trace(
+                  "job.#{job_class}",
+                  kind: "job",
+                  started_at: started_at,
+                  ended_at: Time.now,
+                  job_class: job_class,
+                  queue: queue
+                )
+              end
+
+              if BrainzLab.configuration.flux_effectively_enabled?
+                tags = { job_class: job_class, queue: queue }
+                BrainzLab::Flux.distribution("resque.job.duration_ms", duration_ms, tags: tags)
+                BrainzLab::Flux.increment("resque.job.processed", tags: tags)
+              end
+
+              BrainzLab.clear_context!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/solid_queue.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module SolidQueueInstrumentation
+      class << self
+        def install!
+          return unless defined?(::SolidQueue)
+
+          install_job_instrumentation!
+          install_worker_instrumentation!
+
+          BrainzLab.debug_log("[Instrumentation] SolidQueue instrumentation installed")
+        end
+
+        private
+
+        def install_job_instrumentation!
+          return unless defined?(::ActiveJob::Base)
+
+          ::ActiveJob::Base.class_eval do
+            around_perform do |job, block|
+              BrainzLab::Instrumentation::SolidQueueInstrumentation.around_perform(job, &block)
+            end
+
+            around_enqueue do |job, block|
+              BrainzLab::Instrumentation::SolidQueueInstrumentation.around_enqueue(job, &block)
+            end
+          end
+        end
+
+        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
+          end
+        end
+
+        def handle_notification(name, start, finish, payload)
+          duration_ms = ((finish - start) * 1000).round(2)
+
+          case name
+          when "perform.solid_queue"
+            track_job_perform(payload, duration_ms)
+          when "enqueue.solid_queue"
+            track_job_enqueue(payload)
+          when "discard.solid_queue"
+            track_job_discard(payload)
+          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"
+
+          # Track with Pulse
+          if BrainzLab.configuration.pulse_effectively_enabled?
+            BrainzLab::Pulse.record_trace(
+              "job.#{job_class}",
+              kind: "job",
+              started_at: Time.now - (duration_ms / 1000.0),
+              ended_at: Time.now,
+              job_class: job_class,
+              job_id: payload[:job_id],
+              queue: queue,
+              executions: payload[:executions] || 1,
+              error: payload[:error].present?,
+              error_class: payload[:error]&.class&.name,
+              error_message: payload[:error]&.message
+            )
+          end
+
+          # 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)
+
+            if payload[:error]
+              BrainzLab::Flux.increment("solid_queue.job.failed", tags: tags)
+            end
+          end
+
+          # Add breadcrumb for Reflex
+          BrainzLab::Reflex.add_breadcrumb(
+            "Job #{job_class} completed in #{duration_ms}ms",
+            category: "job",
+            level: payload[:error] ? :error : :info,
+            data: { queue: queue, job_id: payload[:job_id], duration_ms: duration_ms }
+          )
+        end
+
+        def track_job_enqueue(payload)
+          job_class = payload[:job]&.class&.name || payload[:job_class]
+          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
+        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
+        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
+        end
+      end
+
+      def self.around_perform(job)
+        job_class = job.class.name
+        queue = job.queue_name || "default"
+        started_at = Time.now
+
+        # Set context for the job
+        BrainzLab::Context.current.set_context(
+          job_class: job_class,
+          job_id: job.job_id,
+          queue: queue
+        )
+
+        begin
+          yield
+        rescue StandardError => e
+          # 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
+              }
+            )
+          end
+          raise
+        ensure
+          duration_ms = ((Time.now - started_at) * 1000).round(2)
+
+          # Record trace
+          if BrainzLab.configuration.pulse_effectively_enabled?
+            BrainzLab::Pulse.record_trace(
+              "job.#{job_class}",
+              kind: "job",
+              started_at: started_at,
+              ended_at: Time.now,
+              job_class: job_class,
+              job_id: job.job_id,
+              queue: queue,
+              executions: job.executions
+            )
+          end
+
+          # 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)
+          end
+
+          # Clear context
+          BrainzLab.clear_context!
+        end
+      end
+
+      def self.around_enqueue(job)
+        yield
+      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) }
+          )
+        end
+        raise
+      end
+
+      def self.safe_arguments(job)
+        args = job.arguments
+        BrainzLab::Reflex.send(:filter_params, args) if args
+      rescue StandardError
+        "[Unable to serialize]"
+      end
+    end
+  end
+end