brainzlab-rails 0.1.1

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

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Rails
+    module Collectors
+      # Collects Active Storage events for file operation observability
+      class ActiveStorage < Base
+        def process(event_data)
+          case event_data[:name]
+          when 'service_upload.active_storage'
+            handle_upload(event_data)
+          when 'service_download.active_storage', 'service_streaming_download.active_storage'
+            handle_download(event_data)
+          when 'service_download_chunk.active_storage'
+            handle_download_chunk(event_data)
+          when 'service_delete.active_storage'
+            handle_delete(event_data)
+          when 'service_delete_prefixed.active_storage'
+            handle_delete_prefixed(event_data)
+          when 'service_exist.active_storage'
+            handle_exist(event_data)
+          when 'service_url.active_storage'
+            handle_url(event_data)
+          when 'service_update_metadata.active_storage'
+            handle_update_metadata(event_data)
+          when 'preview.active_storage'
+            handle_preview(event_data)
+          when 'transform.active_storage'
+            handle_transform(event_data)
+          when 'analyze.active_storage'
+            handle_analyze(event_data)
+          end
+        end
+
+        private
+
+        def handle_upload(event_data)
+          payload = event_data[:payload]
+          key = payload[:key]
+          service = payload[:service]
+          checksum = payload[:checksum]
+          duration_ms = event_data[:duration_ms]
+
+          # === PULSE: Upload span ===
+          send_to_pulse(event_data, {
+            name: "storage.upload",
+            category: 'storage.upload',
+            attributes: {
+              key: key,
+              service: service,
+              checksum: checksum
+            }
+          })
+
+          # === FLUX: Metrics ===
+          send_to_flux(:increment, 'rails.storage.uploads', 1, {
+            service: service
+          })
+          send_to_flux(:timing, 'rails.storage.upload_ms', duration_ms, {
+            service: service
+          })
+
+          # === RECALL: Log upload ===
+          send_to_recall(:info, "File uploaded", {
+            key: key,
+            service: service,
+            duration_ms: duration_ms
+          })
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "Storage upload: #{key}",
+            category: 'storage.upload',
+            level: :info,
+            data: {
+              key: key,
+              service: service,
+              duration_ms: duration_ms
+            }
+          )
+        end
+
+        def handle_download(event_data)
+          payload = event_data[:payload]
+          key = payload[:key]
+          service = payload[:service]
+          duration_ms = event_data[:duration_ms]
+          streaming = event_data[:name].include?('streaming')
+
+          # === PULSE: Download span ===
+          send_to_pulse(event_data, {
+            name: streaming ? "storage.stream" : "storage.download",
+            category: 'storage.download',
+            attributes: {
+              key: key,
+              service: service,
+              streaming: streaming
+            }
+          })
+
+          # === FLUX: Metrics ===
+          metric_name = streaming ? 'rails.storage.streams' : 'rails.storage.downloads'
+          send_to_flux(:increment, metric_name, 1, { service: service })
+          send_to_flux(:timing, 'rails.storage.download_ms', duration_ms, {
+            service: service,
+            streaming: streaming
+          })
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "Storage #{streaming ? 'stream' : 'download'}: #{key}",
+            category: 'storage.download',
+            level: :debug,
+            data: {
+              key: key,
+              service: service,
+              duration_ms: duration_ms
+            }
+          )
+        end
+
+        def handle_download_chunk(event_data)
+          payload = event_data[:payload]
+          key = payload[:key]
+          service = payload[:service]
+          range = payload[:range]
+
+          # === FLUX: Chunk metrics ===
+          send_to_flux(:increment, 'rails.storage.chunks', 1, {
+            service: service
+          })
+
+          # === REFLEX: Breadcrumb (debug level for chunks) ===
+          add_breadcrumb(
+            "Storage chunk: #{key}",
+            category: 'storage.chunk',
+            level: :debug,
+            data: {
+              key: key,
+              range: range.to_s
+            }
+          )
+        end
+
+        def handle_delete(event_data)
+          payload = event_data[:payload]
+          key = payload[:key]
+          service = payload[:service]
+          duration_ms = event_data[:duration_ms]
+
+          # === PULSE: Delete span ===
+          send_to_pulse(event_data, {
+            name: "storage.delete",
+            category: 'storage.delete',
+            attributes: {
+              key: key,
+              service: service
+            }
+          })
+
+          # === FLUX: Metrics ===
+          send_to_flux(:increment, 'rails.storage.deletes', 1, {
+            service: service
+          })
+
+          # === RECALL: Log deletion ===
+          send_to_recall(:info, "File deleted", {
+            key: key,
+            service: service,
+            duration_ms: duration_ms
+          })
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "Storage delete: #{key}",
+            category: 'storage.delete',
+            level: :info,
+            data: { key: key, service: service }
+          )
+        end
+
+        def handle_delete_prefixed(event_data)
+          payload = event_data[:payload]
+          prefix = payload[:prefix]
+          service = payload[:service]
+
+          # === FLUX: Bulk delete metrics ===
+          send_to_flux(:increment, 'rails.storage.bulk_deletes', 1, {
+            service: service
+          })
+
+          # === RECALL: Log bulk deletion ===
+          send_to_recall(:info, "Bulk file deletion", {
+            prefix: prefix,
+            service: service
+          })
+        end
+
+        def handle_exist(event_data)
+          payload = event_data[:payload]
+          key = payload[:key]
+          service = payload[:service]
+          exist = payload[:exist]
+
+          # === FLUX: Existence check metrics ===
+          send_to_flux(:increment, 'rails.storage.exist_checks', 1, {
+            service: service,
+            exists: exist
+          })
+        end
+
+        def handle_url(event_data)
+          payload = event_data[:payload]
+          key = payload[:key]
+          service = payload[:service]
+          duration_ms = event_data[:duration_ms]
+
+          # === FLUX: URL generation metrics ===
+          send_to_flux(:increment, 'rails.storage.url_generations', 1, {
+            service: service
+          })
+          send_to_flux(:timing, 'rails.storage.url_ms', duration_ms, {
+            service: service
+          })
+        end
+
+        def handle_update_metadata(event_data)
+          payload = event_data[:payload]
+          key = payload[:key]
+          service = payload[:service]
+
+          # === FLUX: Metadata update metrics ===
+          send_to_flux(:increment, 'rails.storage.metadata_updates', 1, {
+            service: service
+          })
+
+          # === REFLEX: Breadcrumb ===
+          add_breadcrumb(
+            "Storage metadata update: #{key}",
+            category: 'storage.metadata',
+            level: :debug,
+            data: {
+              key: key,
+              content_type: payload[:content_type],
+              disposition: payload[:disposition]
+            }
+          )
+        end
+
+        def handle_preview(event_data)
+          payload = event_data[:payload]
+          key = payload[:key]
+          duration_ms = event_data[:duration_ms]
+
+          # === PULSE: Preview generation span ===
+          send_to_pulse(event_data, {
+            name: "storage.preview",
+            category: 'storage.preview',
+            attributes: { key: key }
+          })
+
+          # === FLUX: Preview metrics ===
+          send_to_flux(:increment, 'rails.storage.previews', 1)
+          send_to_flux(:timing, 'rails.storage.preview_ms', duration_ms)
+        end
+
+        def handle_transform(event_data)
+          payload = event_data[:payload]
+          duration_ms = event_data[:duration_ms]
+
+          # === PULSE: Transform span ===
+          send_to_pulse(event_data, {
+            name: "storage.transform",
+            category: 'storage.transform',
+            attributes: {}
+          })
+
+          # === FLUX: Transform metrics ===
+          send_to_flux(:increment, 'rails.storage.transforms', 1)
+          send_to_flux(:timing, 'rails.storage.transform_ms', duration_ms)
+        end
+
+        def handle_analyze(event_data)
+          payload = event_data[:payload]
+          analyzer = payload[:analyzer]
+          duration_ms = event_data[:duration_ms]
+
+          # === PULSE: Analyze span ===
+          send_to_pulse(event_data, {
+            name: "storage.analyze.#{analyzer}",
+            category: 'storage.analyze',
+            attributes: { analyzer: analyzer }
+          })
+
+          # === FLUX: Analyze metrics ===
+          send_to_flux(:increment, 'rails.storage.analyzes', 1, {
+            analyzer: analyzer
+          })
+          send_to_flux(:timing, 'rails.storage.analyze_ms', duration_ms, {
+            analyzer: analyzer
+          })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Rails
+    module Collectors
+      # Base class for all event collectors
+      # Provides common functionality for routing events to products
+      class Base
+        attr_reader :configuration
+
+        def initialize(configuration)
+          @configuration = configuration
+        end
+
+        def process(event_data)
+          raise NotImplementedError, "#{self.class} must implement #process"
+        end
+
+        protected
+
+        # Send to Pulse (APM) - performance tracing
+        def send_to_pulse(event_data, span_data)
+          return unless @configuration.pulse_effectively_enabled?
+
+          BrainzLab::Pulse.record_span(
+            name: span_data[:name],
+            duration_ms: event_data[:duration_ms],
+            category: span_data[:category],
+            attributes: span_data[:attributes] || {},
+            timestamp: event_data[:timestamp]
+          )
+        end
+
+        # Send to Recall (Logs) - structured logging
+        def send_to_recall(level, message, data = {})
+          return unless @configuration.recall_effectively_enabled?
+
+          case level
+          when :debug
+            BrainzLab::Recall.debug(message, **data)
+          when :info
+            BrainzLab::Recall.info(message, **data)
+          when :warn
+            BrainzLab::Recall.warn(message, **data)
+          when :error
+            BrainzLab::Recall.error(message, **data)
+          end
+        end
+
+        # Send to Reflex (Errors) - error tracking with context
+        def send_to_reflex(exception, context = {})
+          return unless @configuration.reflex_effectively_enabled?
+
+          BrainzLab::Reflex.capture(exception, context: context)
+        end
+
+        # Add breadcrumb to Reflex
+        def add_breadcrumb(message, category:, level: :info, data: {})
+          return unless @configuration.reflex_effectively_enabled?
+
+          BrainzLab::Reflex.add_breadcrumb(
+            message,
+            category: category,
+            level: level,
+            data: data
+          )
+        end
+
+        # Send to Flux (Metrics) - counters, gauges, histograms
+        def send_to_flux(metric_type, metric_name, value, tags = {})
+          return unless @configuration.flux_effectively_enabled?
+
+          case metric_type
+          when :increment
+            BrainzLab::Flux.increment(metric_name, value, tags: tags)
+          when :gauge
+            BrainzLab::Flux.gauge(metric_name, value, tags: tags)
+          when :histogram
+            BrainzLab::Flux.histogram(metric_name, value, tags: tags)
+          when :timing
+            BrainzLab::Flux.timing(metric_name, value, tags: tags)
+          end
+        end
+
+        # Send to Nerve (Jobs) - job-specific tracking
+        def send_to_nerve(job_event_type, job_data)
+          return unless @configuration.nerve_effectively_enabled?
+
+          # Nerve integration for job monitoring
+          # This will be expanded as Nerve product develops
+          BrainzLab.debug_log("[Nerve] #{job_event_type}: #{job_data.inspect}")
+        end
+
+        # Extract common request context
+        def extract_request_context(payload)
+          request = payload[:request]
+          return {} unless request
+
+          {
+            request_id: request.request_id,
+            method: request.method,
+            path: request.path,
+            format: request.format&.to_s,
+            remote_ip: request.remote_ip,
+            user_agent: request.user_agent
+          }.compact
+        end
+
+        # Sanitize sensitive data from params
+        def sanitize_params(params)
+          return {} unless params.is_a?(Hash)
+
+          sensitive_keys = %w[password password_confirmation token api_key secret]
+          params.transform_values.with_index do |(key, value), _|
+            if sensitive_keys.any? { |sk| key.to_s.downcase.include?(sk) }
+              '[FILTERED]'
+            elsif value.is_a?(Hash)
+              sanitize_params(value)
+            else
+              value
+            end
+          end
+        rescue StandardError
+          {}
+        end
+      end
+    end
+  end
+end