brainzlab 0.1.2 → 0.1.4

data/lib/brainzlab/instrumentation/action_dispatch.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    class ActionDispatch
+      # Thresholds for slow operations (in milliseconds)
+      SLOW_MIDDLEWARE_THRESHOLD = 50
+      VERY_SLOW_MIDDLEWARE_THRESHOLD = 200
+
+      class << self
+        def install!
+          return unless defined?(::ActionDispatch)
+          return if @installed
+
+          install_process_middleware_subscriber!
+          install_redirect_subscriber!
+          install_request_subscriber!
+
+          @installed = true
+          BrainzLab.debug_log('ActionDispatch instrumentation installed')
+        end
+
+        def installed?
+          @installed == true
+        end
+
+        private
+
+        # ============================================
+        # process_middleware.action_dispatch
+        # Fired when a middleware in the stack runs
+        # ============================================
+        def install_process_middleware_subscriber!
+          ActiveSupport::Notifications.subscribe('process_middleware.action_dispatch') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            handle_process_middleware(event)
+          end
+        end
+
+        def handle_process_middleware(event)
+          payload = event.payload
+          duration = event.duration.round(2)
+
+          middleware = payload[:middleware]
+
+          # Skip fast middleware to reduce noise
+          return if duration < 1
+
+          # Determine level based on duration
+          level = case duration
+                  when 0...SLOW_MIDDLEWARE_THRESHOLD then :info
+                  when SLOW_MIDDLEWARE_THRESHOLD...VERY_SLOW_MIDDLEWARE_THRESHOLD then :warning
+                  else :error
+                  end
+
+          # Record breadcrumb
+          if BrainzLab.configuration.reflex_effectively_enabled?
+            BrainzLab::Reflex.add_breadcrumb(
+              "Middleware: #{middleware} (#{duration}ms)",
+              category: 'dispatch.middleware',
+              level: level,
+              data: {
+                middleware: middleware,
+                duration_ms: duration
+              }.compact
+            )
+          end
+
+          # Add Pulse span
+          record_middleware_span(event, middleware, duration)
+
+          # Log slow middleware
+          if duration >= SLOW_MIDDLEWARE_THRESHOLD && BrainzLab.configuration.recall_effectively_enabled?
+            log_level = duration >= VERY_SLOW_MIDDLEWARE_THRESHOLD ? :error : :warn
+            BrainzLab::Recall.send(
+              log_level,
+              "Slow middleware: #{middleware} (#{duration}ms)",
+              middleware: middleware,
+              duration_ms: duration
+            )
+          end
+        rescue StandardError => e
+          BrainzLab.debug_log("ActionDispatch process_middleware instrumentation failed: #{e.message}")
+        end
+
+        # ============================================
+        # redirect.action_dispatch
+        # Fired when a redirect response is sent
+        # ============================================
+        def install_redirect_subscriber!
+          ActiveSupport::Notifications.subscribe('redirect.action_dispatch') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            handle_redirect(event)
+          end
+        end
+
+        def handle_redirect(event)
+          payload = event.payload
+          duration = event.duration.round(2)
+
+          status = payload[:status]
+          location = payload[:location]
+          request = payload[:request]
+
+          # Record breadcrumb
+          if BrainzLab.configuration.reflex_effectively_enabled?
+            BrainzLab::Reflex.add_breadcrumb(
+              "Redirect #{status}: #{truncate_url(location)}",
+              category: 'dispatch.redirect',
+              level: :info,
+              data: {
+                status: status,
+                location: truncate_url(location),
+                duration_ms: duration
+              }.compact
+            )
+          end
+
+          # Add Pulse span
+          record_redirect_span(event, status, location, duration)
+        rescue StandardError => e
+          BrainzLab.debug_log("ActionDispatch redirect instrumentation failed: #{e.message}")
+        end
+
+        # ============================================
+        # request.action_dispatch
+        # Fired for the full request lifecycle
+        # ============================================
+        def install_request_subscriber!
+          ActiveSupport::Notifications.subscribe('request.action_dispatch') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            handle_request(event)
+          end
+        end
+
+        def handle_request(event)
+          payload = event.payload
+          duration = event.duration.round(2)
+
+          request = payload[:request]
+          response = payload[:response]
+
+          method = request&.method
+          path = request&.path
+          status = response&.status
+
+          # Record breadcrumb
+          if BrainzLab.configuration.reflex_effectively_enabled?
+            level = status && status >= 400 ? :warning : :info
+            level = :error if status && status >= 500
+
+            BrainzLab::Reflex.add_breadcrumb(
+              "Request: #{method} #{path} -> #{status} (#{duration}ms)",
+              category: 'dispatch.request',
+              level: level,
+              data: {
+                method: method,
+                path: path,
+                status: status,
+                duration_ms: duration
+              }.compact
+            )
+          end
+
+          # Add Pulse span
+          record_request_span(event, method, path, status, duration)
+        rescue StandardError => e
+          BrainzLab.debug_log("ActionDispatch request instrumentation failed: #{e.message}")
+        end
+
+        # ============================================
+        # Span Recording Helpers
+        # ============================================
+        def record_middleware_span(event, middleware, duration)
+          return unless BrainzLab.configuration.pulse_effectively_enabled?
+
+          tracer = BrainzLab::Pulse.tracer
+          return unless tracer.current_trace
+
+          span_data = {
+            span_id: SecureRandom.uuid,
+            name: "middleware.#{middleware.to_s.demodulize.underscore}",
+            kind: 'middleware',
+            started_at: event.time,
+            ended_at: event.end,
+            duration_ms: duration,
+            error: false,
+            data: {
+              'middleware.class' => middleware
+            }.compact
+          }
+
+          tracer.current_spans << span_data
+        end
+
+        def record_redirect_span(event, status, location, duration)
+          return unless BrainzLab.configuration.pulse_effectively_enabled?
+
+          tracer = BrainzLab::Pulse.tracer
+          return unless tracer.current_trace
+
+          span_data = {
+            span_id: SecureRandom.uuid,
+            name: 'dispatch.redirect',
+            kind: 'http',
+            started_at: event.time,
+            ended_at: event.end,
+            duration_ms: duration,
+            error: false,
+            data: {
+              'http.status' => status,
+              'http.redirect_location' => truncate_url(location)
+            }.compact
+          }
+
+          tracer.current_spans << span_data
+        end
+
+        def record_request_span(event, method, path, status, duration)
+          return unless BrainzLab.configuration.pulse_effectively_enabled?
+
+          tracer = BrainzLab::Pulse.tracer
+          return unless tracer.current_trace
+
+          span_data = {
+            span_id: SecureRandom.uuid,
+            name: 'dispatch.request',
+            kind: 'http',
+            started_at: event.time,
+            ended_at: event.end,
+            duration_ms: duration,
+            error: status && status >= 500,
+            data: {
+              'http.method' => method,
+              'http.path' => path,
+              'http.status' => status
+            }.compact
+          }
+
+          tracer.current_spans << span_data
+        end
+
+        # ============================================
+        # Helper Methods
+        # ============================================
+        def truncate_url(url, max_length = 200)
+          return 'unknown' unless url
+
+          url_str = url.to_s
+          if url_str.length > max_length
+            "#{url_str[0, max_length - 3]}..."
+          else
+            url_str
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/action_mailbox.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    class ActionMailbox
+      # Thresholds for slow processing (in milliseconds)
+      SLOW_PROCESSING_THRESHOLD = 1000    # 1 second
+      VERY_SLOW_PROCESSING_THRESHOLD = 5000  # 5 seconds
+
+      class << self
+        def install!
+          return unless defined?(::ActionMailbox)
+          return if @installed
+
+          install_process_subscriber!
+
+          @installed = true
+          BrainzLab.debug_log('ActionMailbox instrumentation installed')
+        end
+
+        def installed?
+          @installed == true
+        end
+
+        private
+
+        # ============================================
+        # process.action_mailbox
+        # Fired when an inbound email is processed
+        # ============================================
+        def install_process_subscriber!
+          ActiveSupport::Notifications.subscribe('process.action_mailbox') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            handle_process(event)
+          end
+        end
+
+        def handle_process(event)
+          payload = event.payload
+          duration = event.duration.round(2)
+
+          mailbox = payload[:mailbox]
+          inbound_email = payload[:inbound_email]
+
+          mailbox_class = mailbox.is_a?(Class) ? mailbox.name : mailbox.class.name
+          email_id = inbound_email&.id
+          email_status = inbound_email&.status
+          message_id = inbound_email&.message_id
+
+          # Extract sender/recipient info if available
+          from = extract_from(inbound_email)
+          to = extract_to(inbound_email)
+          subject = extract_subject(inbound_email)
+
+          # Determine level based on duration
+          level = case duration
+                  when 0...SLOW_PROCESSING_THRESHOLD then :info
+                  when SLOW_PROCESSING_THRESHOLD...VERY_SLOW_PROCESSING_THRESHOLD then :warning
+                  else :error
+                  end
+
+          # Record breadcrumb
+          if BrainzLab.configuration.reflex_effectively_enabled?
+            BrainzLab::Reflex.add_breadcrumb(
+              "Mailbox process: #{mailbox_class} (#{duration}ms)",
+              category: 'mailbox.process',
+              level: level,
+              data: {
+                mailbox: mailbox_class,
+                email_id: email_id,
+                status: email_status,
+                message_id: truncate(message_id),
+                from: truncate(from),
+                subject: truncate(subject, 100),
+                duration_ms: duration
+              }.compact
+            )
+          end
+
+          # Add Pulse span
+          record_process_span(event, mailbox_class, email_id, duration, email_status, from, to, subject)
+
+          # Log to Recall
+          log_email_processing(mailbox_class, email_id, email_status, duration, from, to, subject)
+        rescue StandardError => e
+          BrainzLab.debug_log("ActionMailbox process instrumentation failed: #{e.message}")
+        end
+
+        # ============================================
+        # Span Recording
+        # ============================================
+        def record_process_span(event, mailbox_class, email_id, duration, status, from, to, subject)
+          return unless BrainzLab.configuration.pulse_effectively_enabled?
+
+          tracer = BrainzLab::Pulse.tracer
+          return unless tracer.current_trace
+
+          span_data = {
+            span_id: SecureRandom.uuid,
+            name: "mailbox.process.#{mailbox_class.underscore}",
+            kind: 'mailbox',
+            started_at: event.time,
+            ended_at: event.end,
+            duration_ms: duration,
+            error: status == 'bounced' || status == 'failed',
+            data: {
+              'mailbox.class' => mailbox_class,
+              'mailbox.email_id' => email_id,
+              'mailbox.status' => status,
+              'mailbox.from' => truncate(from),
+              'mailbox.to' => truncate(to),
+              'mailbox.subject' => truncate(subject, 100)
+            }.compact
+          }
+
+          tracer.current_spans << span_data
+        end
+
+        # ============================================
+        # Logging
+        # ============================================
+        def log_email_processing(mailbox_class, email_id, status, duration, from, to, subject)
+          return unless BrainzLab.configuration.recall_effectively_enabled?
+
+          # Determine log level based on status and duration
+          if status == 'bounced' || status == 'failed'
+            BrainzLab::Recall.error(
+              "Mailbox processing failed: #{mailbox_class}",
+              mailbox: mailbox_class,
+              email_id: email_id,
+              status: status,
+              from: from,
+              to: to,
+              subject: truncate(subject, 200),
+              duration_ms: duration
+            )
+          elsif duration >= SLOW_PROCESSING_THRESHOLD
+            level = duration >= VERY_SLOW_PROCESSING_THRESHOLD ? :error : :warn
+            BrainzLab::Recall.send(
+              level,
+              "Slow mailbox processing: #{mailbox_class} (#{duration}ms)",
+              mailbox: mailbox_class,
+              email_id: email_id,
+              status: status,
+              duration_ms: duration,
+              threshold_exceeded: duration >= VERY_SLOW_PROCESSING_THRESHOLD ? 'critical' : 'warning'
+            )
+          end
+        end
+
+        # ============================================
+        # Helper Methods
+        # ============================================
+        def extract_from(inbound_email)
+          return nil unless inbound_email
+
+          if inbound_email.respond_to?(:mail) && inbound_email.mail.respond_to?(:from)
+            Array(inbound_email.mail.from).first
+          end
+        rescue StandardError
+          nil
+        end
+
+        def extract_to(inbound_email)
+          return nil unless inbound_email
+
+          if inbound_email.respond_to?(:mail) && inbound_email.mail.respond_to?(:to)
+            Array(inbound_email.mail.to).first
+          end
+        rescue StandardError
+          nil
+        end
+
+        def extract_subject(inbound_email)
+          return nil unless inbound_email
+
+          if inbound_email.respond_to?(:mail) && inbound_email.mail.respond_to?(:subject)
+            inbound_email.mail.subject
+          end
+        rescue StandardError
+          nil
+        end
+
+        def truncate(value, max_length = 200)
+          return nil unless value
+
+          str = value.to_s
+          if str.length > max_length
+            "#{str[0, max_length - 3]}..."
+          else
+            str
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/action_mailer.rb

@@ -11,19 +11,19 @@ module BrainzLab
           return if @installed
 
           # Subscribe to deliver notification
-          ActiveSupport::Notifications.subscribe("deliver.action_mailer") do |*args|
+          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|
+          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")
+          BrainzLab.debug_log('ActionMailer instrumentation installed')
         end
 
         def installed?
@@ -46,13 +46,13 @@ module BrainzLab
           mail = payload[:mail]
           to = sanitize_recipients(mail&.to)
           subject = mail&.subject
-          delivery_method = payload[:perform_deliveries] ? "delivered" : "skipped"
+          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",
+              category: 'mailer.deliver',
               level: :info,
               data: {
                 mailer: mailer,
@@ -67,13 +67,13 @@ module BrainzLab
           # Record span for Pulse
           record_span(
             name: "Mail deliver #{mailer}",
-            kind: "mailer",
+            kind: 'mailer',
             started_at: event.time,
             ended_at: event.end,
             duration_ms: duration_ms,
             data: {
               mailer: mailer,
-              action: "deliver",
+              action: 'deliver',
               to: to,
               subject: truncate_subject(subject),
               message_id: message_id,
@@ -106,7 +106,7 @@ module BrainzLab
           if BrainzLab.configuration.reflex_enabled
             BrainzLab::Reflex.add_breadcrumb(
               "Mail process: #{mailer}##{action}",
-              category: "mailer.process",
+              category: 'mailer.process',
               level: :info,
               data: {
                 mailer: mailer,
@@ -119,7 +119,7 @@ module BrainzLab
           # Record span for Pulse
           record_span(
             name: "Mail process #{mailer}##{action}",
-            kind: "mailer",
+            kind: 'mailer',
             started_at: event.time,
             ended_at: event.end,
             duration_ms: duration_ms,
@@ -152,27 +152,28 @@ module BrainzLab
 
           case recipients
           when Array
-            recipients.map { |r| mask_email(r) }.join(", ")
+            recipients.map { |r| mask_email(r) }.join(', ')
           else
             mask_email(recipients.to_s)
           end
         end
 
         def mask_email(email)
-          return email unless email.include?("@")
+          return email unless email.include?('@')
 
-          local, domain = email.split("@", 2)
+          local, domain = email.split('@', 2)
           if local.length > 2
             "#{local[0..1]}***@#{domain}"
           else
             "***@#{domain}"
           end
         rescue StandardError
-          "[email]"
+          '[email]'
         end
 
         def truncate_subject(subject)
           return nil unless subject
+
           subject.to_s[0, 100]
         end
       end