brainzlab-rails 0.1.1

data/lib/brainzlab/rails/collectors/action_controller.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Rails
+    module Collectors
+      # Collects Action Controller events and routes to products
+      # Primary source for HTTP request observability
+      class ActionController < Base
+        def process(event_data)
+          case event_data[:name]
+          when 'start_processing.action_controller'
+            handle_start_processing(event_data)
+          when 'process_action.action_controller'
+            handle_process_action(event_data)
+          when 'redirect_to.action_controller'
+            handle_redirect(event_data)
+          when 'halted_callback.action_controller'
+            handle_halted_callback(event_data)
+          when 'send_file.action_controller', 'send_data.action_controller', 'send_stream.action_controller'
+            handle_send_file(event_data)
+          when 'unpermitted_parameters.action_controller'
+            handle_unpermitted_parameters(event_data)
+          when 'rate_limit.action_controller'
+            handle_rate_limit(event_data)
+          when /fragment.*\.action_controller$/
+            handle_fragment_cache(event_data)
+          when 'deprecation.rails'
+            handle_deprecation(event_data)
+          when 'process_middleware.action_dispatch'
+            handle_middleware(event_data)
+          when 'redirect.action_dispatch'
+            handle_dispatch_redirect(event_data)
+          when 'request.action_dispatch'
+            handle_dispatch_request(event_data)
+          end
+        end
+
+        private
+
+        def handle_start_processing(event_data)
+          payload = event_data[:payload]
+          controller = payload[:controller]
+          action = payload[:action]
+
+          return if @configuration.ignored_action?(controller, action)
+
+          # Add breadcrumb for request start
+          add_breadcrumb(
+            "#{controller}##{action} started",
+            category: 'http.request',
+            level: :info,
+            data: {
+              method: payload[:method],
+              path: payload[:path],
+              format: payload[:format]
+            }
+          )
+        end
+
+        def handle_process_action(event_data)
+          payload = event_data[:payload]
+          controller = payload[:controller]
+          action = payload[:action]
+          duration_ms = event_data[:duration_ms]
+
+          return if @configuration.ignored_action?(controller, action)
+
+          # Check for exception
+          if payload[:exception_object]
+            handle_request_error(event_data, payload[:exception_object])
+          end
+
+          # === PULSE: APM Span ===
+          send_to_pulse(event_data, {
+            name: "#{controller}##{action}",
+            category: 'http.request',
+            attributes: {
+              controller: controller,
+              action: action,
+              method: payload[:method],
+              path: payload[:path],
+              status: payload[:status],
+              format: payload[:format],
+              view_runtime_ms: payload[:view_runtime]&.round(2),
+              db_runtime_ms: payload[:db_runtime]&.round(2)
+            }
+          })
+
+          # === RECALL: Structured Log ===
+          log_level = payload[:status].to_i >= 400 ? :warn : :info
+          send_to_recall(log_level, "#{payload[:method]} #{payload[:path]}", {
+            controller: controller,
+            action: action,
+            status: payload[:status],
+            duration_ms: duration_ms,
+            view_runtime_ms: payload[:view_runtime]&.round(2),
+            db_runtime_ms: payload[:db_runtime]&.round(2),
+            format: payload[:format],
+            params: sanitize_params(payload[:params])
+          })
+
+          # === FLUX: Metrics ===
+          tags = { controller: controller, action: action, status: payload[:status] }
+          send_to_flux(:increment, 'rails.requests.total', 1, tags)
+          send_to_flux(:timing, 'rails.requests.duration_ms', duration_ms, tags)
+
+          if payload[:view_runtime]
+            send_to_flux(:timing, 'rails.view.runtime_ms', payload[:view_runtime], tags)
+          end
+
+          if payload[:db_runtime]
+            send_to_flux(:timing, 'rails.db.runtime_ms', payload[:db_runtime], tags)
+          end
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "#{controller}##{action} completed (#{payload[:status]})",
+            category: 'http.request',
+            level: payload[:status].to_i >= 400 ? :warning : :info,
+            data: {
+              status: payload[:status],
+              duration_ms: duration_ms
+            }
+          )
+        end
+
+        def handle_request_error(event_data, exception)
+          payload = event_data[:payload]
+
+          send_to_reflex(exception, {
+            controller: payload[:controller],
+            action: payload[:action],
+            request_context: extract_request_context(payload),
+            params: sanitize_params(payload[:params])
+          })
+
+          send_to_flux(:increment, 'rails.requests.errors', 1, {
+            controller: payload[:controller],
+            action: payload[:action],
+            exception_class: exception.class.name
+          })
+        end
+
+        def handle_redirect(event_data)
+          payload = event_data[:payload]
+
+          add_breadcrumb(
+            "Redirect to #{payload[:location]}",
+            category: 'http.redirect',
+            level: :info,
+            data: {
+              status: payload[:status],
+              location: payload[:location]
+            }
+          )
+
+          send_to_flux(:increment, 'rails.redirects.total', 1, {
+            status: payload[:status]
+          })
+        end
+
+        def handle_halted_callback(event_data)
+          payload = event_data[:payload]
+          filter = payload[:filter]
+
+          # This is often auth failures - important for security monitoring
+          add_breadcrumb(
+            "Callback halted by #{filter}",
+            category: 'http.callback',
+            level: :warning,
+            data: { filter: filter.to_s }
+          )
+
+          send_to_recall(:warn, "Request halted by callback", {
+            filter: filter.to_s
+          })
+
+          send_to_flux(:increment, 'rails.callbacks.halted', 1, {
+            filter: filter.to_s
+          })
+        end
+
+        def handle_send_file(event_data)
+          payload = event_data[:payload]
+
+          send_to_pulse(event_data, {
+            name: "send_file",
+            category: 'http.file',
+            attributes: payload.slice(:path, :filename, :type, :disposition).compact
+          })
+
+          send_to_flux(:increment, 'rails.files.sent', 1)
+        end
+
+        def handle_unpermitted_parameters(event_data)
+          payload = event_data[:payload]
+          keys = payload[:keys]
+          context = payload[:context] || {}
+
+          # Security-relevant: log unpermitted params
+          send_to_recall(:warn, "Unpermitted parameters detected", {
+            keys: keys,
+            controller: context[:controller],
+            action: context[:action]
+          })
+
+          add_breadcrumb(
+            "Unpermitted params: #{keys.join(', ')}",
+            category: 'security.params',
+            level: :warning,
+            data: { keys: keys }
+          )
+
+          send_to_flux(:increment, 'rails.params.unpermitted', keys.size, {
+            controller: context[:controller],
+            action: context[:action]
+          })
+        end
+
+        def handle_rate_limit(event_data)
+          payload = event_data[:payload]
+
+          send_to_recall(:warn, "Rate limit exceeded", {
+            count: payload[:count],
+            limit: payload[:to],
+            within: payload[:within],
+            name: payload[:name]
+          })
+
+          send_to_flux(:increment, 'rails.rate_limit.exceeded', 1, {
+            name: payload[:name]
+          })
+        end
+
+        def handle_fragment_cache(event_data)
+          payload = event_data[:payload]
+          operation = event_data[:name].split('.').first # read_fragment, write_fragment, etc.
+
+          send_to_flux(:increment, "rails.fragment_cache.#{operation}", 1)
+
+          add_breadcrumb(
+            "Fragment cache #{operation}: #{payload[:key]}",
+            category: 'cache.fragment',
+            level: :debug,
+            data: { key: payload[:key] }
+          )
+        end
+
+        def handle_deprecation(event_data)
+          payload = event_data[:payload]
+
+          send_to_recall(:warn, "Deprecation warning: #{payload[:message]}", {
+            gem_name: payload[:gem_name],
+            deprecation_horizon: payload[:deprecation_horizon],
+            callstack: payload[:callstack]&.first(5)&.map(&:to_s)
+          })
+
+          send_to_flux(:increment, 'rails.deprecations.total', 1, {
+            gem_name: payload[:gem_name]
+          })
+        end
+
+        def handle_middleware(event_data)
+          payload = event_data[:payload]
+
+          send_to_pulse(event_data, {
+            name: "middleware.#{payload[:middleware]}",
+            category: 'http.middleware',
+            attributes: { middleware: payload[:middleware] }
+          })
+        end
+
+        def handle_dispatch_redirect(event_data)
+          payload = event_data[:payload]
+
+          add_breadcrumb(
+            "Dispatch redirect to #{payload[:location]}",
+            category: 'http.dispatch',
+            level: :info,
+            data: {
+              status: payload[:status],
+              location: payload[:location],
+              source_location: payload[:source_location]
+            }
+          )
+        end
+
+        def handle_dispatch_request(event_data)
+          # Initial request dispatch - useful for timing the full request lifecycle
+          send_to_pulse(event_data, {
+            name: 'request.dispatch',
+            category: 'http.dispatch',
+            attributes: {}
+          })
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/rails/collectors/action_mailer.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Rails
+    module Collectors
+      # Collects Action Mailer events for email observability
+      class ActionMailer < Base
+        def process(event_data)
+          case event_data[:name]
+          when 'deliver.action_mailer'
+            handle_deliver(event_data)
+          when 'process.action_mailer'
+            handle_process(event_data)
+          when 'process.action_mailbox'
+            handle_mailbox_process(event_data)
+          end
+        end
+
+        private
+
+        def handle_deliver(event_data)
+          payload = event_data[:payload]
+          mailer = payload[:mailer]
+          message_id = payload[:message_id]
+          subject = payload[:subject]
+          duration_ms = event_data[:duration_ms]
+
+          to_count = Array(payload[:to]).size
+          perform_deliveries = payload[:perform_deliveries]
+
+          # === PULSE: Email delivery span ===
+          send_to_pulse(event_data, {
+            name: "mailer.#{mailer}.deliver",
+            category: 'email.deliver',
+            attributes: {
+              mailer: mailer,
+              message_id: message_id,
+              subject: truncate_subject(subject),
+              to_count: to_count,
+              performed: perform_deliveries
+            }
+          })
+
+          # === FLUX: Metrics ===
+          tags = { mailer: mailer, performed: perform_deliveries }
+          send_to_flux(:increment, 'rails.mailer.delivered', 1, tags)
+          send_to_flux(:timing, 'rails.mailer.delivery_ms', duration_ms, tags)
+          send_to_flux(:histogram, 'rails.mailer.recipients', to_count, tags)
+
+          # === RECALL: Log delivery ===
+          send_to_recall(:info, "Email delivered", {
+            mailer: mailer,
+            message_id: message_id,
+            subject: truncate_subject(subject),
+            to_count: to_count,
+            from: payload[:from],
+            duration_ms: duration_ms,
+            performed: perform_deliveries
+          })
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "Email: #{mailer} - #{truncate_subject(subject)}",
+            category: 'email.deliver',
+            level: :info,
+            data: {
+              mailer: mailer,
+              message_id: message_id,
+              to_count: to_count,
+              duration_ms: duration_ms
+            }
+          )
+        end
+
+        def handle_process(event_data)
+          payload = event_data[:payload]
+          mailer = payload[:mailer]
+          action = payload[:action]
+          duration_ms = event_data[:duration_ms]
+
+          # === PULSE: Mailer processing span ===
+          send_to_pulse(event_data, {
+            name: "mailer.#{mailer}##{action}",
+            category: 'email.process',
+            attributes: {
+              mailer: mailer,
+              action: action,
+              args: sanitize_mailer_args(payload[:args])
+            }
+          })
+
+          # === FLUX: Metrics ===
+          send_to_flux(:increment, 'rails.mailer.processed', 1, {
+            mailer: mailer,
+            action: action
+          })
+          send_to_flux(:timing, 'rails.mailer.process_ms', duration_ms, {
+            mailer: mailer,
+            action: action
+          })
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "Mailer: #{mailer}##{action}",
+            category: 'email.process',
+            level: :debug,
+            data: {
+              mailer: mailer,
+              action: action,
+              duration_ms: duration_ms
+            }
+          )
+        end
+
+        def handle_mailbox_process(event_data)
+          payload = event_data[:payload]
+          mailbox = payload[:mailbox]
+          inbound_email = payload[:inbound_email] || {}
+          duration_ms = event_data[:duration_ms]
+
+          # === PULSE: Mailbox processing span ===
+          send_to_pulse(event_data, {
+            name: "mailbox.#{mailbox.class.name}",
+            category: 'email.inbound',
+            attributes: {
+              mailbox: mailbox.class.name,
+              message_id: inbound_email[:message_id],
+              status: inbound_email[:status]
+            }
+          })
+
+          # === FLUX: Metrics ===
+          send_to_flux(:increment, 'rails.mailbox.processed', 1, {
+            mailbox: mailbox.class.name,
+            status: inbound_email[:status]
+          })
+          send_to_flux(:timing, 'rails.mailbox.process_ms', duration_ms, {
+            mailbox: mailbox.class.name
+          })
+
+          # === RECALL: Log inbound email ===
+          send_to_recall(:info, "Inbound email processed", {
+            mailbox: mailbox.class.name,
+            message_id: inbound_email[:message_id],
+            status: inbound_email[:status],
+            duration_ms: duration_ms
+          })
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "Mailbox: #{mailbox.class.name}",
+            category: 'email.inbound',
+            level: :info,
+            data: {
+              mailbox: mailbox.class.name,
+              status: inbound_email[:status],
+              duration_ms: duration_ms
+            }
+          )
+        end
+
+        def truncate_subject(subject, max_length = 100)
+          return '' if subject.nil?
+
+          subject.length > max_length ? "#{subject[0, max_length]}..." : subject
+        end
+
+        def sanitize_mailer_args(args)
+          return [] unless args.is_a?(Array)
+
+          args.map do |arg|
+            case arg
+            when Hash
+              sanitize_params(arg)
+            when String, Numeric, Symbol, TrueClass, FalseClass, NilClass
+              arg
+            else
+              arg.class.name
+            end
+          end
+        rescue StandardError
+          []
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/rails/collectors/action_view.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Rails
+    module Collectors
+      # Collects Action View rendering events
+      # Tracks template, partial, and layout rendering performance
+      class ActionView < Base
+        def process(event_data)
+          case event_data[:name]
+          when 'render_template.action_view'
+            handle_render_template(event_data)
+          when 'render_partial.action_view'
+            handle_render_partial(event_data)
+          when 'render_collection.action_view'
+            handle_render_collection(event_data)
+          when 'render_layout.action_view'
+            handle_render_layout(event_data)
+          end
+        end
+
+        private
+
+        def handle_render_template(event_data)
+          payload = event_data[:payload]
+          identifier = extract_template_name(payload[:identifier])
+          duration_ms = event_data[:duration_ms]
+
+          # === PULSE: View rendering span ===
+          send_to_pulse(event_data, {
+            name: "render_template.#{identifier}",
+            category: 'view.template',
+            attributes: {
+              identifier: identifier,
+              layout: payload[:layout]
+            }
+          })
+
+          # === FLUX: Metrics ===
+          send_to_flux(:timing, 'rails.view.template_ms', duration_ms, {
+            template: identifier
+          })
+          send_to_flux(:increment, 'rails.view.templates_rendered', 1)
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "Rendered #{identifier}",
+            category: 'view.render',
+            level: :debug,
+            data: {
+              template: identifier,
+              layout: payload[:layout],
+              duration_ms: duration_ms
+            }
+          )
+        end
+
+        def handle_render_partial(event_data)
+          payload = event_data[:payload]
+          identifier = extract_template_name(payload[:identifier])
+          duration_ms = event_data[:duration_ms]
+
+          # === PULSE: Partial rendering span ===
+          send_to_pulse(event_data, {
+            name: "render_partial.#{identifier}",
+            category: 'view.partial',
+            attributes: {
+              identifier: identifier
+            }
+          })
+
+          # === FLUX: Metrics ===
+          send_to_flux(:timing, 'rails.view.partial_ms', duration_ms, {
+            partial: identifier
+          })
+          send_to_flux(:increment, 'rails.view.partials_rendered', 1)
+
+          # Flag slow partials (> 50ms is concerning for a partial)
+          if duration_ms > 50
+            send_to_recall(:warn, "Slow partial rendering", {
+              partial: identifier,
+              duration_ms: duration_ms
+            })
+          end
+        end
+
+        def handle_render_collection(event_data)
+          payload = event_data[:payload]
+          identifier = extract_template_name(payload[:identifier])
+          count = payload[:count] || 0
+          cache_hits = payload[:cache_hits] || 0
+          duration_ms = event_data[:duration_ms]
+
+          # === PULSE: Collection rendering span ===
+          send_to_pulse(event_data, {
+            name: "render_collection.#{identifier}",
+            category: 'view.collection',
+            attributes: {
+              identifier: identifier,
+              count: count,
+              cache_hits: cache_hits,
+              cache_hit_rate: count > 0 ? (cache_hits.to_f / count * 100).round(1) : 0
+            }
+          })
+
+          # === FLUX: Metrics ===
+          send_to_flux(:timing, 'rails.view.collection_ms', duration_ms, {
+            partial: identifier
+          })
+          send_to_flux(:gauge, 'rails.view.collection_size', count)
+
+          if cache_hits > 0
+            send_to_flux(:increment, 'rails.view.collection_cache_hits', cache_hits)
+          end
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "Rendered collection #{identifier} (#{count} items, #{cache_hits} cached)",
+            category: 'view.collection',
+            level: :debug,
+            data: {
+              partial: identifier,
+              count: count,
+              cache_hits: cache_hits,
+              duration_ms: duration_ms
+            }
+          )
+
+          # Flag potentially slow collection renders
+          if count > 0 && duration_ms / count > 10
+            send_to_recall(:warn, "Slow collection item rendering", {
+              partial: identifier,
+              count: count,
+              avg_ms_per_item: (duration_ms / count).round(2),
+              total_duration_ms: duration_ms
+            })
+          end
+        end
+
+        def handle_render_layout(event_data)
+          payload = event_data[:payload]
+          identifier = extract_template_name(payload[:identifier])
+          duration_ms = event_data[:duration_ms]
+
+          # === PULSE: Layout rendering span ===
+          send_to_pulse(event_data, {
+            name: "render_layout.#{identifier}",
+            category: 'view.layout',
+            attributes: {
+              identifier: identifier
+            }
+          })
+
+          # === FLUX: Metrics ===
+          send_to_flux(:timing, 'rails.view.layout_ms', duration_ms, {
+            layout: identifier
+          })
+        end
+
+        # Extract clean template name from full path
+        def extract_template_name(identifier)
+          return 'unknown' if identifier.nil?
+
+          # Extract the relative path from app/views
+          if identifier.include?('/app/views/')
+            identifier.split('/app/views/').last
+          elsif identifier.include?('/views/')
+            identifier.split('/views/').last
+          else
+            File.basename(identifier)
+          end
+        end
+      end
+    end
+  end
+end