fluyenta-ruby 0.1.14

data/lib/brainzlab/instrumentation/sidekiq.rb

@@ -0,0 +1,265 @@
+# 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

data/lib/brainzlab/instrumentation/solid_queue.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module SolidQueueInstrumentation
+      class << self
+        def install!
+          return unless defined?(::SolidQueue)
+
+          install_job_instrumentation!
+          install_worker_instrumentation!
+
+          BrainzLab.debug_log('[Instrumentation] SolidQueue instrumentation installed')
+        end
+
+        private
+
+        def install_job_instrumentation!
+          return unless defined?(::ActiveJob::Base)
+
+          ::ActiveJob::Base.class_eval do
+            around_perform do |job, block|
+              BrainzLab::Instrumentation::SolidQueueInstrumentation.around_perform(job, &block)
+            end
+
+            around_enqueue do |job, block|
+              BrainzLab::Instrumentation::SolidQueueInstrumentation.around_enqueue(job, &block)
+            end
+          end
+        end
+
+        def install_worker_instrumentation!
+          # Subscribe to ActiveSupport notifications for SolidQueue
+          return unless defined?(::ActiveSupport::Notifications)
+
+          ::ActiveSupport::Notifications.subscribe(/solid_queue/) do |name, start, finish, _id, payload|
+            handle_notification(name, start, finish, payload)
+          end
+        end
+
+        def handle_notification(name, start, finish, payload)
+          duration_ms = ((finish - start) * 1000).round(2)
+
+          case name
+          when 'perform.solid_queue'
+            track_job_perform(payload, duration_ms)
+          when 'enqueue.solid_queue'
+            track_job_enqueue(payload)
+          when 'discard.solid_queue'
+            track_job_discard(payload)
+          when 'retry.solid_queue'
+            track_job_retry(payload)
+          end
+        end
+
+        def track_job_perform(payload, duration_ms)
+          job_class = payload[:job]&.class&.name || payload[:job_class]
+          queue = payload[:queue] || 'default'
+
+          # Track with Pulse
+          if BrainzLab.configuration.pulse_effectively_enabled?
+            BrainzLab::Pulse.record_trace(
+              "job.#{job_class}",
+              kind: 'job',
+              started_at: Time.now - (duration_ms / 1000.0),
+              ended_at: Time.now,
+              job_class: job_class,
+              job_id: payload[:job_id],
+              queue: queue,
+              executions: payload[:executions] || 1,
+              error: payload[:error].present?,
+              error_class: payload[:error]&.class&.name,
+              error_message: payload[:error]&.message
+            )
+          end
+
+          # Track with Flux
+          if BrainzLab.configuration.flux_effectively_enabled?
+            tags = { job_class: job_class, queue: queue }
+            BrainzLab::Flux.distribution('solid_queue.job.duration_ms', duration_ms, tags: tags)
+            BrainzLab::Flux.increment('solid_queue.job.processed', tags: tags)
+
+            BrainzLab::Flux.increment('solid_queue.job.failed', tags: tags) if payload[:error]
+          end
+
+          # Add breadcrumb for Reflex
+          BrainzLab::Reflex.add_breadcrumb(
+            "Job #{job_class} completed in #{duration_ms}ms",
+            category: 'job',
+            level: payload[:error] ? :error : :info,
+            data: { queue: queue, job_id: payload[:job_id], duration_ms: duration_ms }
+          )
+        end
+
+        def track_job_enqueue(payload)
+          job_class = payload[:job]&.class&.name || payload[:job_class]
+          queue = payload[:queue] || 'default'
+
+          return unless BrainzLab.configuration.flux_effectively_enabled?
+
+          BrainzLab::Flux.increment('solid_queue.job.enqueued', tags: { job_class: job_class, queue: queue })
+        end
+
+        def track_job_discard(payload)
+          job_class = payload[:job]&.class&.name || payload[:job_class]
+
+          return unless BrainzLab.configuration.flux_effectively_enabled?
+
+          BrainzLab::Flux.increment('solid_queue.job.discarded', tags: { job_class: job_class })
+        end
+
+        def track_job_retry(payload)
+          job_class = payload[:job]&.class&.name || payload[:job_class]
+
+          return unless BrainzLab.configuration.flux_effectively_enabled?
+
+          BrainzLab::Flux.increment('solid_queue.job.retried', tags: { job_class: job_class })
+        end
+      end
+
+      def self.around_perform(job)
+        job_class = job.class.name
+        queue = job.queue_name || 'default'
+        started_at = Time.now
+
+        # Set context for the job
+        BrainzLab::Context.current.set_context(
+          job_class: job_class,
+          job_id: job.job_id,
+          queue: queue
+        )
+
+        begin
+          yield
+        rescue StandardError => e
+          # Capture error with Reflex
+          if BrainzLab.configuration.reflex_effectively_enabled?
+            BrainzLab::Reflex.capture(e,
+                                      tags: { job_class: job_class, queue: queue },
+                                      extra: {
+                                        job_id: job.job_id,
+                                        arguments: safe_arguments(job),
+                                        executions: job.executions
+                                      })
+          end
+          raise
+        ensure
+          duration_ms = ((Time.now - started_at) * 1000).round(2)
+
+          # Record trace
+          if BrainzLab.configuration.pulse_effectively_enabled?
+            BrainzLab::Pulse.record_trace(
+              "job.#{job_class}",
+              kind: 'job',
+              started_at: started_at,
+              ended_at: Time.now,
+              job_class: job_class,
+              job_id: job.job_id,
+              queue: queue,
+              executions: job.executions
+            )
+          end
+
+          # Record metrics
+          if BrainzLab.configuration.flux_effectively_enabled?
+            tags = { job_class: job_class, queue: queue }
+            BrainzLab::Flux.distribution('solid_queue.job.duration_ms', duration_ms, tags: tags)
+          end
+
+          # Clear context
+          BrainzLab.clear_context!
+        end
+      end
+
+      def self.around_enqueue(job)
+        yield
+      rescue StandardError => e
+        if BrainzLab.configuration.reflex_effectively_enabled?
+          BrainzLab::Reflex.capture(e,
+                                    tags: { job_class: job.class.name, queue: job.queue_name },
+                                    extra: { job_id: job.job_id, arguments: safe_arguments(job) })
+        end
+        raise
+      end
+
+      def self.safe_arguments(job)
+        args = job.arguments
+        BrainzLab::Reflex.send(:filter_params, args) if args
+      rescue StandardError
+        '[Unable to serialize]'
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/stripe.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module StripeInstrumentation
+      class << self
+        def install!
+          return unless defined?(::Stripe)
+
+          install_instrumentation!
+
+          BrainzLab.debug_log('[Instrumentation] Stripe instrumentation installed')
+        end
+
+        private
+
+        def install_instrumentation!
+          # Stripe uses a request callback system
+          if ::Stripe.respond_to?(:add_instrumentation)
+            ::Stripe.add_instrumentation do |event|
+              track_event(event)
+            end
+          else
+            # Fallback: monkey-patch the API resource
+            install_api_resource_patch!
+          end
+        end
+
+        def install_api_resource_patch!
+          return unless defined?(::Stripe::StripeClient)
+          return unless ::Stripe::StripeClient.respond_to?(:execute_request)
+
+          ::Stripe::StripeClient.class_eval do
+            class << self
+              alias_method :original_execute_request, :execute_request
+
+              def execute_request(method, path, api_base: nil, api_key: nil, headers: {}, params: {}, usage: [])
+                started_at = Time.now
+                resource = extract_resource(path)
+
+                begin
+                  response = original_execute_request(
+                    method, path,
+                    api_base: api_base,
+                    api_key: api_key,
+                    headers: headers,
+                    params: params,
+                    usage: usage
+                  )
+
+                  BrainzLab::Instrumentation::StripeInstrumentation.track_success(
+                    method, resource, path, started_at, response
+                  )
+
+                  response
+                rescue StandardError => e
+                  BrainzLab::Instrumentation::StripeInstrumentation.track_error(
+                    method, resource, path, started_at, e
+                  )
+                  raise
+                end
+              end
+
+              def extract_resource(path)
+                # /v1/customers/cus_xxx -> customers
+                parts = path.to_s.split('/').reject(&:empty?)
+                parts[1] || 'unknown'
+              end
+            end
+          end
+        end
+
+        def track_event(event)
+          duration_ms = (event[:duration] * 1000).round(2) if event[:duration]
+          method = event[:method].to_s.upcase
+          resource = event[:path].to_s.split('/')[2] || 'unknown'
+
+          BrainzLab::Reflex.add_breadcrumb(
+            "Stripe #{method} #{resource}",
+            category: 'payment',
+            level: event[:error] ? :error : :info,
+            data: {
+              method: method,
+              resource: resource,
+              status: event[:http_status],
+              duration_ms: duration_ms,
+              request_id: event[:request_id]
+            }
+          )
+
+          return unless BrainzLab.configuration.flux_effectively_enabled?
+
+          tags = { method: method, resource: resource }
+          BrainzLab::Flux.distribution('stripe.duration_ms', duration_ms, tags: tags) if duration_ms
+          BrainzLab::Flux.increment('stripe.requests', tags: tags)
+
+          return unless event[:error]
+
+          BrainzLab::Flux.increment('stripe.errors', tags: tags.merge(error_type: event[:error_type]))
+        end
+      end
+
+      def self.track_success(method, resource, path, started_at, _response)
+        duration_ms = ((Time.now - started_at) * 1000).round(2)
+
+        BrainzLab::Reflex.add_breadcrumb(
+          "Stripe #{method.to_s.upcase} #{resource}",
+          category: 'payment',
+          level: :info,
+          data: {
+            method: method.to_s.upcase,
+            resource: resource,
+            path: path,
+            duration_ms: duration_ms
+          }
+        )
+
+        return unless BrainzLab.configuration.flux_effectively_enabled?
+
+        tags = { method: method.to_s.upcase, resource: resource }
+        BrainzLab::Flux.distribution('stripe.duration_ms', duration_ms, tags: tags)
+        BrainzLab::Flux.increment('stripe.requests', tags: tags)
+      end
+
+      def self.track_error(method, resource, _path, started_at, error)
+        ((Time.now - started_at) * 1000).round(2)
+        error_type = case error
+                     when Stripe::CardError then 'card_error'
+                     when Stripe::RateLimitError then 'rate_limit'
+                     when Stripe::InvalidRequestError then 'invalid_request'
+                     when Stripe::AuthenticationError then 'authentication'
+                     when Stripe::APIConnectionError then 'connection'
+                     when Stripe::StripeError then 'stripe_error'
+                     else 'unknown'
+                     end
+
+        BrainzLab::Reflex.add_breadcrumb(
+          "Stripe #{method.to_s.upcase} #{resource} failed: #{error.message}",
+          category: 'payment',
+          level: :error,
+          data: {
+            method: method.to_s.upcase,
+            resource: resource,
+            error_type: error_type,
+            error: error.class.name
+          }
+        )
+
+        if BrainzLab.configuration.flux_effectively_enabled?
+          tags = { method: method.to_s.upcase, resource: resource, error_type: error_type }
+          BrainzLab::Flux.increment('stripe.errors', tags: tags)
+        end
+
+        # Capture with Reflex (but filter sensitive data)
+        return unless BrainzLab.configuration.reflex_effectively_enabled?
+
+        BrainzLab::Reflex.capture(error,
+                                  tags: { source: 'stripe', resource: resource },
+                                  extra: { error_type: error_type })
+      end
+    end
+  end
+end