brainzlab 0.1.0

data/lib/brainzlab/instrumentation/action_mailer.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module ActionMailerInstrumentation
+      @installed = false
+
+      class << self
+        def install!
+          return unless defined?(::ActionMailer::Base)
+          return if @installed
+
+          # Subscribe to deliver notification
+          ActiveSupport::Notifications.subscribe("deliver.action_mailer") do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            record_delivery(event)
+          end
+
+          # Subscribe to process notification (when mail is being prepared)
+          ActiveSupport::Notifications.subscribe("process.action_mailer") do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            record_process(event)
+          end
+
+          @installed = true
+          BrainzLab.debug_log("ActionMailer instrumentation installed")
+        end
+
+        def installed?
+          @installed
+        end
+
+        def reset!
+          @installed = false
+        end
+
+        private
+
+        def record_delivery(event)
+          payload = event.payload
+          mailer = payload[:mailer]
+          message_id = payload[:message_id]
+          duration_ms = event.duration.round(2)
+
+          # Get mail details
+          mail = payload[:mail]
+          to = sanitize_recipients(mail&.to)
+          subject = mail&.subject
+          delivery_method = payload[:perform_deliveries] ? "delivered" : "skipped"
+
+          # Add breadcrumb for Reflex
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "Mail #{delivery_method}: #{mailer}",
+              category: "mailer.deliver",
+              level: :info,
+              data: {
+                mailer: mailer,
+                to: to,
+                subject: truncate_subject(subject),
+                message_id: message_id,
+                duration_ms: duration_ms
+              }.compact
+            )
+          end
+
+          # Record span for Pulse
+          record_span(
+            name: "Mail deliver #{mailer}",
+            kind: "mailer",
+            started_at: event.time,
+            ended_at: event.end,
+            duration_ms: duration_ms,
+            data: {
+              mailer: mailer,
+              action: "deliver",
+              to: to,
+              subject: truncate_subject(subject),
+              message_id: message_id,
+              delivery_method: delivery_method
+            }.compact
+          )
+
+          # Log to Recall
+          if BrainzLab.configuration.recall_enabled
+            BrainzLab::Recall.info(
+              "Mail #{delivery_method}: #{mailer} to #{to} (#{duration_ms}ms)",
+              mailer: mailer,
+              to: to,
+              subject: truncate_subject(subject),
+              message_id: message_id,
+              duration_ms: duration_ms
+            )
+          end
+        rescue StandardError => e
+          BrainzLab.debug_log("ActionMailer delivery recording failed: #{e.message}")
+        end
+
+        def record_process(event)
+          payload = event.payload
+          mailer = payload[:mailer]
+          action = payload[:action]
+          duration_ms = event.duration.round(2)
+
+          # Add breadcrumb
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "Mail process: #{mailer}##{action}",
+              category: "mailer.process",
+              level: :info,
+              data: {
+                mailer: mailer,
+                action: action,
+                duration_ms: duration_ms
+              }
+            )
+          end
+
+          # Record span for Pulse
+          record_span(
+            name: "Mail process #{mailer}##{action}",
+            kind: "mailer",
+            started_at: event.time,
+            ended_at: event.end,
+            duration_ms: duration_ms,
+            data: {
+              mailer: mailer,
+              action: action
+            }
+          )
+        rescue StandardError => e
+          BrainzLab.debug_log("ActionMailer process recording failed: #{e.message}")
+        end
+
+        def record_span(name:, kind:, started_at:, ended_at:, duration_ms:, data:)
+          spans = Thread.current[:brainzlab_pulse_spans]
+          return unless spans
+
+          spans << {
+            span_id: SecureRandom.uuid,
+            name: name,
+            kind: kind,
+            started_at: started_at,
+            ended_at: ended_at,
+            duration_ms: duration_ms,
+            data: data
+          }
+        end
+
+        def sanitize_recipients(recipients)
+          return nil unless recipients
+
+          case recipients
+          when Array
+            recipients.map { |r| mask_email(r) }.join(", ")
+          else
+            mask_email(recipients.to_s)
+          end
+        end
+
+        def mask_email(email)
+          return email unless email.include?("@")
+
+          local, domain = email.split("@", 2)
+          if local.length > 2
+            "#{local[0..1]}***@#{domain}"
+          else
+            "***@#{domain}"
+          end
+        rescue StandardError
+          "[email]"
+        end
+
+        def truncate_subject(subject)
+          return nil unless subject
+          subject.to_s[0, 100]
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/active_record.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    class ActiveRecord
+      SCHEMA_QUERIES = ["SCHEMA", "EXPLAIN"].freeze
+      INTERNAL_TABLES = %w[pg_ information_schema sqlite_ mysql.].freeze
+
+      class << self
+        def install!
+          return unless defined?(::ActiveRecord)
+          return if @installed
+
+          ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            next if skip_query?(event.payload)
+
+            record_breadcrumb(event)
+          end
+
+          @installed = true
+          BrainzLab.debug_log("ActiveRecord breadcrumbs installed")
+        end
+
+        def installed?
+          @installed == true
+        end
+
+        private
+
+        def record_breadcrumb(event)
+          payload = event.payload
+          sql = payload[:sql]
+          name = payload[:name] || "SQL"
+          duration = event.duration.round(2)
+
+          # Extract operation type from SQL
+          operation = extract_operation(sql)
+
+          # Build breadcrumb message
+          message = if payload[:cached]
+                      "#{name} (cached)"
+                    else
+                      "#{name} (#{duration}ms)"
+                    end
+
+          # Determine level based on duration
+          level = if duration > 100
+                    :warning
+                  elsif duration > 1000
+                    :error
+                  else
+                    :info
+                  end
+
+          BrainzLab::Reflex.add_breadcrumb(
+            message,
+            category: "db.#{operation}",
+            level: level,
+            data: {
+              sql: truncate_sql(sql),
+              duration_ms: duration,
+              cached: payload[:cached] || false,
+              connection_name: payload[:connection]&.pool&.connection_class&.name
+            }.compact
+          )
+        rescue StandardError => e
+          BrainzLab.debug_log("ActiveRecord breadcrumb failed: #{e.message}")
+        end
+
+        def extract_operation(sql)
+          return "query" unless sql
+
+          case sql.to_s.strip.upcase
+          when /\ASELECT/i then "select"
+          when /\AINSERT/i then "insert"
+          when /\AUPDATE/i then "update"
+          when /\ADELETE/i then "delete"
+          when /\ABEGIN/i, /\ACOMMIT/i, /\AROLLBACK/i then "transaction"
+          else "query"
+          end
+        end
+
+        def skip_query?(payload)
+          # Skip schema queries
+          return true if SCHEMA_QUERIES.include?(payload[:name])
+
+          # Skip internal/system table queries
+          sql = payload[:sql].to_s.downcase
+          return true if INTERNAL_TABLES.any? { |t| sql.include?(t) }
+
+          # Skip if no SQL (shouldn't happen but be safe)
+          return true if payload[:sql].nil? || payload[:sql].empty?
+
+          false
+        end
+
+        def truncate_sql(sql)
+          return nil unless sql
+
+          truncated = sql.to_s.gsub(/\s+/, " ").strip
+          if truncated.length > 500
+            "#{truncated[0, 497]}..."
+          else
+            truncated
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/delayed_job.rb

@@ -0,0 +1,236 @@
+# 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
+          if defined?(::Delayed::Worker)
+            install_lifecycle_hooks!
+          end
+
+          # Install plugin if Delayed::Plugin is available
+          if defined?(::Delayed::Plugin)
+            ::Delayed::Worker.plugins << Plugin
+          end
+
+          @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)
+      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 if defined?(::Delayed::Plugin)
+    end
+  end
+end