brainzlab 0.1.0

data/lib/brainzlab/instrumentation/net_http.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module NetHttp
+      @installed = false
+
+      class << self
+        def install!
+          return if @installed
+
+          ::Net::HTTP.prepend(Patch)
+          @installed = true
+        end
+
+        def installed?
+          @installed
+        end
+
+        # For testing purposes
+        def reset!
+          @installed = false
+        end
+      end
+
+      module Patch
+        def request(req, body = nil, &block)
+          return super unless should_track?
+
+          # Inject distributed tracing context into outgoing request headers
+          inject_trace_context(req)
+
+          url = build_url(req)
+          method = req.method
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          begin
+            response = super
+            track_request(method, url, response.code.to_i, started_at)
+            response
+          rescue => e
+            track_request(method, url, nil, started_at, e.class.name)
+            raise
+          end
+        end
+
+        def inject_trace_context(req)
+          return unless BrainzLab.configuration.pulse_enabled
+
+          # Build headers hash and inject trace context
+          headers = {}
+          BrainzLab::Pulse.inject(headers, format: :all)
+
+          # Apply headers to request
+          headers.each do |key, value|
+            req[key] = value
+          end
+        rescue StandardError => e
+          BrainzLab.debug_log("Failed to inject trace context: #{e.message}")
+        end
+
+        private
+
+        def should_track?
+          return false unless BrainzLab.configuration.instrument_http
+
+          ignore_hosts = BrainzLab.configuration.http_ignore_hosts || []
+          !ignore_hosts.include?(address)
+        end
+
+        def build_url(req)
+          scheme = use_ssl? ? "https" : "http"
+          port_str = if (use_ssl? && port == 443) || (!use_ssl? && port == 80)
+                       ""
+                     else
+                       ":#{port}"
+                     end
+          "#{scheme}://#{address}#{port_str}#{req.path}"
+        end
+
+        def track_request(method, url, status, started_at, error = nil)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+          level = error || (status && status >= 400) ? :error : :info
+
+          # Add breadcrumb for Reflex
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "#{method} #{url}",
+              category: "http",
+              level: level,
+              data: { method: method, url: url, status_code: status, duration_ms: duration_ms, error: error }.compact
+            )
+          end
+
+          # Log to Recall at debug level (avoid noise)
+          if BrainzLab.configuration.recall_enabled
+            BrainzLab::Recall.debug(
+              "HTTP #{method} #{url} -> #{status || 'ERROR'}",
+              method: method, url: url, status_code: status, duration_ms: duration_ms, error: error
+            )
+          end
+        rescue => e
+          # Don't let instrumentation errors crash the app
+          BrainzLab.configuration.logger&.error("[BrainzLab] HTTP instrumentation error: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/redis.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module RedisInstrumentation
+      @installed = false
+
+      class << self
+        def install!
+          return unless defined?(::Redis)
+          return if @installed
+
+          # Redis 5+ uses middleware, older versions need patching
+          if redis_5_or_newer?
+            install_middleware!
+          else
+            install_patch!
+          end
+
+          @installed = true
+          BrainzLab.debug_log("Redis instrumentation installed")
+        end
+
+        def installed?
+          @installed
+        end
+
+        def reset!
+          @installed = false
+        end
+
+        private
+
+        def redis_5_or_newer?
+          defined?(::Redis::VERSION) && Gem::Version.new(::Redis::VERSION) >= Gem::Version.new("5.0")
+        end
+
+        def install_middleware!
+          # Redis 5+ uses RedisClient with middleware support
+          return unless defined?(::RedisClient)
+
+          ::RedisClient.register(Middleware)
+        end
+
+        def install_patch!
+          # Redis < 5 - patch the client
+          ::Redis::Client.prepend(LegacyPatch)
+        end
+      end
+
+      # Middleware for Redis 5+ (RedisClient)
+      module Middleware
+        def connect(redis_config)
+          super
+        end
+
+        def call(command, redis_config)
+          return super unless should_track?
+
+          track_command(command) { super }
+        end
+
+        def call_pipelined(commands, redis_config)
+          return super unless should_track?
+
+          track_pipeline(commands) { super }
+        end
+
+        private
+
+        def should_track?
+          BrainzLab.configuration.instrument_redis
+        end
+
+        def should_skip_command?(command)
+          cmd_name = command.first.to_s.downcase
+          ignore = BrainzLab.configuration.redis_ignore_commands || []
+          ignore.map(&:downcase).include?(cmd_name)
+        end
+
+        def track_command(command, &block)
+          return yield if should_skip_command?(command)
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          error_info = nil
+
+          begin
+            result = yield
+            record_command(command, started_at)
+            result
+          rescue StandardError => e
+            error_info = e.class.name
+            record_command(command, started_at, error_info)
+            raise
+          end
+        end
+
+        def track_pipeline(commands, &block)
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          error_info = nil
+
+          begin
+            result = yield
+            record_pipeline(commands, started_at)
+            result
+          rescue StandardError => e
+            error_info = e.class.name
+            record_pipeline(commands, started_at, error_info)
+            raise
+          end
+        end
+
+        def record_command(command, started_at, error = nil)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+          cmd_name = command.first.to_s.upcase
+          key = extract_key(command)
+          level = error ? :error : :info
+
+          # Add breadcrumb for Reflex
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "Redis #{cmd_name}",
+              category: "redis",
+              level: level,
+              data: {
+                command: cmd_name,
+                key: truncate_key(key),
+                duration_ms: duration_ms,
+                error: error
+              }.compact
+            )
+          end
+
+          # Record span for Pulse APM
+          record_pulse_span(cmd_name, key, duration_ms, error)
+        rescue StandardError => e
+          BrainzLab.debug_log("Redis instrumentation error: #{e.message}")
+        end
+
+        def record_pipeline(commands, started_at, error = nil)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+          cmd_names = commands.map { |c| c.first.to_s.upcase }.uniq.join(", ")
+          level = error ? :error : :info
+
+          # Add breadcrumb for Reflex
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "Redis PIPELINE (#{commands.size} commands)",
+              category: "redis",
+              level: level,
+              data: {
+                commands: cmd_names,
+                count: commands.size,
+                duration_ms: duration_ms,
+                error: error
+              }.compact
+            )
+          end
+
+          # Record span for Pulse APM
+          record_pulse_span("PIPELINE", nil, duration_ms, error, commands.size)
+        rescue StandardError => e
+          BrainzLab.debug_log("Redis instrumentation error: #{e.message}")
+        end
+
+        def record_pulse_span(command, key, duration_ms, error, pipeline_count = nil)
+          spans = Thread.current[:brainzlab_pulse_spans]
+          return unless spans
+
+          span = {
+            span_id: SecureRandom.uuid,
+            name: "Redis #{command}",
+            kind: "redis",
+            started_at: Time.now.utc - (duration_ms / 1000.0),
+            ended_at: Time.now.utc,
+            duration_ms: duration_ms,
+            data: {
+              command: command,
+              key: truncate_key(key),
+              pipeline_count: pipeline_count
+            }.compact
+          }
+
+          if error
+            span[:error] = true
+            span[:error_class] = error
+          end
+
+          spans << span
+        end
+
+        def extract_key(command)
+          return nil if command.size < 2
+
+          # Most Redis commands have the key as the second argument
+          key = command[1]
+          key.is_a?(String) ? key : key.to_s
+        end
+
+        def truncate_key(key)
+          return nil unless key
+
+          key.to_s[0, 100]
+        end
+      end
+
+      # Patch for Redis < 5
+      module LegacyPatch
+        def call(command)
+          return super unless should_track?
+          return super if should_skip_command?(command)
+
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          error_info = nil
+
+          begin
+            result = super
+            record_command(command, started_at)
+            result
+          rescue StandardError => e
+            error_info = e.class.name
+            record_command(command, started_at, error_info)
+            raise
+          end
+        end
+
+        def call_pipeline(pipeline)
+          return super unless should_track?
+
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          error_info = nil
+          commands = pipeline.commands
+
+          begin
+            result = super
+            record_pipeline(commands, started_at)
+            result
+          rescue StandardError => e
+            error_info = e.class.name
+            record_pipeline(commands, started_at, error_info)
+            raise
+          end
+        end
+
+        private
+
+        def should_track?
+          BrainzLab.configuration.instrument_redis
+        end
+
+        def should_skip_command?(command)
+          cmd_name = command.first.to_s.downcase
+          ignore = BrainzLab.configuration.redis_ignore_commands || []
+          ignore.map(&:downcase).include?(cmd_name)
+        end
+
+        def record_command(command, started_at, error = nil)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+          cmd_name = command.first.to_s.upcase
+          key = command[1]&.to_s
+          level = error ? :error : :info
+
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "Redis #{cmd_name}",
+              category: "redis",
+              level: level,
+              data: {
+                command: cmd_name,
+                key: key&.slice(0, 100),
+                duration_ms: duration_ms,
+                error: error
+              }.compact
+            )
+          end
+
+          record_pulse_span(cmd_name, key, duration_ms, error)
+        rescue StandardError => e
+          BrainzLab.debug_log("Redis instrumentation error: #{e.message}")
+        end
+
+        def record_pipeline(commands, started_at, error = nil)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+          level = error ? :error : :info
+
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "Redis PIPELINE (#{commands.size} commands)",
+              category: "redis",
+              level: level,
+              data: {
+                count: commands.size,
+                duration_ms: duration_ms,
+                error: error
+              }.compact
+            )
+          end
+
+          record_pulse_span("PIPELINE", nil, duration_ms, error, commands.size)
+        rescue StandardError => e
+          BrainzLab.debug_log("Redis instrumentation error: #{e.message}")
+        end
+
+        def record_pulse_span(command, key, duration_ms, error, pipeline_count = nil)
+          spans = Thread.current[:brainzlab_pulse_spans]
+          return unless spans
+
+          span = {
+            span_id: SecureRandom.uuid,
+            name: "Redis #{command}",
+            kind: "redis",
+            started_at: Time.now.utc - (duration_ms / 1000.0),
+            ended_at: Time.now.utc,
+            duration_ms: duration_ms,
+            data: {
+              command: command,
+              key: key&.slice(0, 100),
+              pipeline_count: pipeline_count
+            }.compact
+          }
+
+          if error
+            span[:error] = true
+            span[:error_class] = error
+          end
+
+          spans << span
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/sidekiq.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module SidekiqInstrumentation
+      @installed = false
+
+      class << self
+        def install!
+          return unless defined?(::Sidekiq)
+          return if @installed
+
+          ::Sidekiq.configure_server do |config|
+            config.server_middleware do |chain|
+              chain.add ServerMiddleware
+            end
+
+            # Also add client middleware for distributed tracing
+            config.client_middleware do |chain|
+              chain.add ClientMiddleware
+            end
+          end
+
+          # Client-side middleware for when jobs are enqueued
+          ::Sidekiq.configure_client do |config|
+            config.client_middleware do |chain|
+              chain.add ClientMiddleware
+            end
+          end
+
+          @installed = true
+          BrainzLab.debug_log("Sidekiq instrumentation installed")
+        end
+
+        def installed?
+          @installed
+        end
+
+        def reset!
+          @installed = false
+        end
+      end
+
+      # Server middleware - runs when jobs are processed
+      class ServerMiddleware
+        def call(worker, job, queue)
+          return yield unless should_trace?
+
+          started_at = Time.now.utc
+          job_class = job["class"] || worker.class.name
+          job_id = job["jid"]
+
+          # Calculate queue wait time
+          enqueued_at = job["enqueued_at"] ? Time.at(job["enqueued_at"]) : nil
+          queue_wait_ms = enqueued_at ? ((started_at - enqueued_at) * 1000).round(2) : nil
+
+          # Extract parent trace context if present (distributed tracing)
+          parent_context = extract_trace_context(job)
+
+          # Set up context
+          setup_context(job, queue)
+
+          # Add breadcrumb
+          BrainzLab::Reflex.add_breadcrumb(
+            "Sidekiq #{job_class}",
+            category: "job.sidekiq",
+            level: :info,
+            data: { job_id: job_id, queue: queue, retry_count: job["retry_count"] }
+          )
+
+          # Initialize Pulse tracing
+          Thread.current[:brainzlab_pulse_spans] = []
+          Thread.current[:brainzlab_pulse_breakdown] = nil
+
+          error_occurred = nil
+          begin
+            yield
+          rescue StandardError => e
+            error_occurred = e
+            raise
+          ensure
+            record_trace(
+              job_class: job_class,
+              job_id: job_id,
+              queue: queue,
+              started_at: started_at,
+              queue_wait_ms: queue_wait_ms,
+              retry_count: job["retry_count"] || 0,
+              parent_context: parent_context,
+              error: error_occurred
+            )
+
+            cleanup_context
+          end
+        end
+
+        private
+
+        def should_trace?
+          BrainzLab.configuration.pulse_enabled
+        end
+
+        def setup_context(job, queue)
+          BrainzLab::Context.current.set_context(
+            job_class: job["class"],
+            job_id: job["jid"],
+            queue_name: queue,
+            retry_count: job["retry_count"],
+            arguments: job["args"]&.map(&:to_s)&.first(5)
+          )
+        end
+
+        def cleanup_context
+          Thread.current[:brainzlab_pulse_spans] = nil
+          Thread.current[:brainzlab_pulse_breakdown] = nil
+          BrainzLab::Context.clear!
+          BrainzLab::Pulse::Propagation.clear!
+        end
+
+        def extract_trace_context(job)
+          return nil unless job["_brainzlab_trace"]
+
+          trace_data = job["_brainzlab_trace"]
+          BrainzLab::Pulse::Propagation::Context.new(
+            trace_id: trace_data["trace_id"],
+            span_id: trace_data["span_id"],
+            sampled: trace_data["sampled"] != false
+          )
+        rescue StandardError
+          nil
+        end
+
+        def record_trace(job_class:, job_id:, queue:, started_at:, queue_wait_ms:, retry_count:, parent_context:, error:)
+          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],
+              error: span[:error],
+              error_class: span[:error_class],
+              error_message: span[:error_message]
+            }.compact
+          end
+
+          payload = {
+            trace_id: SecureRandom.uuid,
+            name: job_class,
+            kind: "job",
+            started_at: started_at.utc.iso8601(3),
+            ended_at: ended_at.utc.iso8601(3),
+            duration_ms: duration_ms,
+            job_class: job_class,
+            job_id: job_id,
+            queue: queue,
+            queue_wait_ms: queue_wait_ms,
+            executions: retry_count + 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
+          }
+
+          # Add parent trace info for distributed tracing
+          if parent_context&.valid?
+            payload[:parent_trace_id] = parent_context.trace_id
+            payload[:parent_span_id] = parent_context.span_id
+          end
+
+          BrainzLab::Pulse.client.send_trace(payload.compact)
+        rescue StandardError => e
+          BrainzLab.debug_log("Sidekiq trace recording failed: #{e.message}")
+        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
+
+      # Client middleware - runs when jobs are enqueued
+      class ClientMiddleware
+        def call(worker_class, job, queue, redis_pool)
+          # Inject trace context for distributed tracing
+          inject_trace_context(job)
+
+          # Add breadcrumb for job enqueue
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "Enqueue #{job['class']}",
+              category: "job.sidekiq.enqueue",
+              level: :info,
+              data: { queue: queue, job_id: job["jid"] }
+            )
+          end
+
+          # Record span for Pulse
+          record_enqueue_span(job, queue)
+
+          yield
+        end
+
+        private
+
+        def inject_trace_context(job)
+          return unless BrainzLab.configuration.pulse_enabled
+
+          # Get or create propagation context
+          ctx = BrainzLab::Pulse::Propagation.current
+          ctx ||= BrainzLab::Pulse.send(:create_propagation_context)
+
+          return unless ctx&.valid?
+
+          job["_brainzlab_trace"] = {
+            "trace_id" => ctx.trace_id,
+            "span_id" => ctx.span_id,
+            "sampled" => ctx.sampled
+          }
+        rescue StandardError => e
+          BrainzLab.debug_log("Failed to inject Sidekiq trace context: #{e.message}")
+        end
+
+        def record_enqueue_span(job, queue)
+          spans = Thread.current[:brainzlab_pulse_spans]
+          return unless spans
+
+          spans << {
+            span_id: SecureRandom.uuid,
+            name: "Enqueue #{job['class']}",
+            kind: "job",
+            started_at: Time.now.utc,
+            ended_at: Time.now.utc,
+            duration_ms: 0,
+            data: {
+              job_class: job["class"],
+              job_id: job["jid"],
+              queue: queue
+            }
+          }
+        end
+      end
+    end
+  end
+end