fluyenta-ruby 0.1.14

data/lib/brainzlab/instrumentation/railties.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    class Railties
+      # Thresholds for slow initializers (in milliseconds)
+      SLOW_INITIALIZER_THRESHOLD = 100   # 100ms
+      VERY_SLOW_INITIALIZER_THRESHOLD = 500  # 500ms
+
+      class << self
+        def install!
+          return unless defined?(::Rails)
+          return if @installed
+
+          install_load_config_initializer_subscriber!
+
+          @installed = true
+          BrainzLab.debug_log('Railties instrumentation installed')
+        end
+
+        def installed?
+          @installed == true
+        end
+
+        private
+
+        # ============================================
+        # load_config_initializer.railties
+        # Fired when each config initializer is loaded
+        # ============================================
+        def install_load_config_initializer_subscriber!
+          ActiveSupport::Notifications.subscribe('load_config_initializer.railties') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            handle_load_config_initializer(event)
+          end
+        end
+
+        def handle_load_config_initializer(event)
+          payload = event.payload
+          duration = event.duration.round(2)
+
+          initializer = payload[:initializer]
+
+          # Extract just the filename for cleaner display
+          initializer_name = extract_initializer_name(initializer)
+
+          # Determine level based on duration
+          level = case duration
+                  when 0...SLOW_INITIALIZER_THRESHOLD then :info
+                  when SLOW_INITIALIZER_THRESHOLD...VERY_SLOW_INITIALIZER_THRESHOLD then :warning
+                  else :error
+                  end
+
+          # Record breadcrumb (only for slow initializers to reduce noise during boot)
+          if duration >= 10 && BrainzLab.configuration.reflex_effectively_enabled?
+            BrainzLab::Reflex.add_breadcrumb(
+              "Initializer loaded: #{initializer_name} (#{duration}ms)",
+              category: 'rails.initializer',
+              level: level,
+              data: {
+                initializer: initializer_name,
+                path: initializer,
+                duration_ms: duration
+              }.compact
+            )
+          end
+
+          # Add Pulse span for tracking boot time
+          record_initializer_span(event, initializer_name, initializer, duration)
+
+          # Log slow initializers
+          log_slow_initializer(initializer_name, initializer, duration) if duration >= SLOW_INITIALIZER_THRESHOLD
+        rescue StandardError => e
+          BrainzLab.debug_log("Railties load_config_initializer instrumentation failed: #{e.message}")
+        end
+
+        # ============================================
+        # Span Recording
+        # ============================================
+        def record_initializer_span(event, name, path, duration)
+          return unless BrainzLab.configuration.pulse_effectively_enabled?
+
+          tracer = BrainzLab::Pulse.tracer
+          return unless tracer.current_trace
+
+          span_data = {
+            span_id: SecureRandom.uuid,
+            name: "rails.initializer.#{name}",
+            kind: 'internal',
+            started_at: event.time,
+            ended_at: event.end,
+            duration_ms: duration,
+            error: false,
+            data: {
+              'rails.initializer.name' => name,
+              'rails.initializer.path' => path
+            }.compact
+          }
+
+          tracer.current_spans << span_data
+        end
+
+        # ============================================
+        # Logging
+        # ============================================
+        def log_slow_initializer(name, path, duration)
+          return unless BrainzLab.configuration.recall_effectively_enabled?
+
+          level = duration >= VERY_SLOW_INITIALIZER_THRESHOLD ? :error : :warn
+
+          BrainzLab::Recall.send(
+            level,
+            "Slow initializer: #{name} (#{duration}ms)",
+            initializer: name,
+            path: path,
+            duration_ms: duration,
+            threshold_exceeded: duration >= VERY_SLOW_INITIALIZER_THRESHOLD ? 'critical' : 'warning'
+          )
+        end
+
+        # ============================================
+        # Helper Methods
+        # ============================================
+        def extract_initializer_name(path)
+          return 'unknown' unless path
+
+          # Extract filename without extension from path
+          # e.g., "/app/config/initializers/devise.rb" -> "devise"
+          File.basename(path.to_s, '.*')
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/redis.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module RedisInstrumentation
+      @installed = false
+
+      class << self
+        def install!
+          return unless defined?(::Redis)
+          return if @installed
+
+          # Redis 5+ uses middleware, older versions need patching
+          if redis_5_or_newer?
+            install_middleware!
+          else
+            install_patch!
+          end
+
+          @installed = true
+          BrainzLab.debug_log('Redis instrumentation installed')
+        end
+
+        def installed?
+          @installed
+        end
+
+        def reset!
+          @installed = false
+        end
+
+        private
+
+        def redis_5_or_newer?
+          defined?(::Redis::VERSION) && Gem::Version.new(::Redis::VERSION) >= Gem::Version.new('5.0')
+        end
+
+        def install_middleware!
+          # Redis 5+ uses RedisClient with middleware support
+          return unless defined?(::RedisClient)
+
+          ::RedisClient.register(Middleware)
+        end
+
+        def install_patch!
+          # Redis < 5 - patch the client
+          ::Redis::Client.prepend(LegacyPatch)
+        end
+      end
+
+      # Middleware for Redis 5+ (RedisClient)
+      module Middleware
+        def call(command, redis_config)
+          return super unless should_track?
+
+          track_command(command) { super }
+        end
+
+        def call_pipelined(commands, redis_config)
+          return super unless should_track?
+
+          track_pipeline(commands) { super }
+        end
+
+        private
+
+        def should_track?
+          BrainzLab.configuration.instrument_redis
+        end
+
+        def should_skip_command?(command)
+          cmd_name = command.first.to_s.downcase
+          ignore = BrainzLab.configuration.redis_ignore_commands || []
+          ignore.map(&:downcase).include?(cmd_name)
+        end
+
+        def track_command(command)
+          return yield if should_skip_command?(command)
+
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          begin
+            result = yield
+            record_command(command, started_at)
+            result
+          rescue StandardError => e
+            error_info = e.class.name
+            record_command(command, started_at, error_info)
+            raise
+          end
+        end
+
+        def track_pipeline(commands)
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          begin
+            result = yield
+            record_pipeline(commands, started_at)
+            result
+          rescue StandardError => e
+            error_info = e.class.name
+            record_pipeline(commands, started_at, error_info)
+            raise
+          end
+        end
+
+        def record_command(command, started_at, error = nil)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+          cmd_name = command.first.to_s.upcase
+          key = extract_key(command)
+          level = error ? :error : :info
+
+          # Add breadcrumb for Reflex
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "Redis #{cmd_name}",
+              category: 'redis',
+              level: level,
+              data: {
+                command: cmd_name,
+                key: truncate_key(key),
+                duration_ms: duration_ms,
+                error: error
+              }.compact
+            )
+          end
+
+          # Record span for Pulse APM
+          record_pulse_span(cmd_name, key, duration_ms, error)
+        rescue StandardError => e
+          BrainzLab.debug_log("Redis instrumentation error: #{e.message}")
+        end
+
+        def record_pipeline(commands, started_at, error = nil)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+          cmd_names = commands.map { |c| c.first.to_s.upcase }.uniq.join(', ')
+          level = error ? :error : :info
+
+          # Add breadcrumb for Reflex
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "Redis PIPELINE (#{commands.size} commands)",
+              category: 'redis',
+              level: level,
+              data: {
+                commands: cmd_names,
+                count: commands.size,
+                duration_ms: duration_ms,
+                error: error
+              }.compact
+            )
+          end
+
+          # Record span for Pulse APM
+          record_pulse_span('PIPELINE', nil, duration_ms, error, commands.size)
+        rescue StandardError => e
+          BrainzLab.debug_log("Redis instrumentation error: #{e.message}")
+        end
+
+        def record_pulse_span(command, key, duration_ms, error, pipeline_count = nil)
+          spans = Thread.current[:brainzlab_pulse_spans]
+          return unless spans
+
+          span = {
+            span_id: SecureRandom.uuid,
+            name: "Redis #{command}",
+            kind: 'redis',
+            started_at: Time.now.utc - (duration_ms / 1000.0),
+            ended_at: Time.now.utc,
+            duration_ms: duration_ms,
+            data: {
+              command: command,
+              key: truncate_key(key),
+              pipeline_count: pipeline_count
+            }.compact
+          }
+
+          if error
+            span[:error] = true
+            span[:error_class] = error
+          end
+
+          spans << span
+        end
+
+        def extract_key(command)
+          return nil if command.size < 2
+
+          # Most Redis commands have the key as the second argument
+          key = command[1]
+          key.is_a?(String) ? key : key.to_s
+        end
+
+        def truncate_key(key)
+          return nil unless key
+
+          key.to_s[0, 100]
+        end
+      end
+
+      # Patch for Redis < 5
+      module LegacyPatch
+        def call(command)
+          return super unless should_track?
+          return super if should_skip_command?(command)
+
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          begin
+            result = super
+            record_command(command, started_at)
+            result
+          rescue StandardError => e
+            error_info = e.class.name
+            record_command(command, started_at, error_info)
+            raise
+          end
+        end
+
+        def call_pipeline(pipeline)
+          return super unless should_track?
+
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          commands = pipeline.commands
+
+          begin
+            result = super
+            record_pipeline(commands, started_at)
+            result
+          rescue StandardError => e
+            error_info = e.class.name
+            record_pipeline(commands, started_at, error_info)
+            raise
+          end
+        end
+
+        private
+
+        def should_track?
+          BrainzLab.configuration.instrument_redis
+        end
+
+        def should_skip_command?(command)
+          cmd_name = command.first.to_s.downcase
+          ignore = BrainzLab.configuration.redis_ignore_commands || []
+          ignore.map(&:downcase).include?(cmd_name)
+        end
+
+        def record_command(command, started_at, error = nil)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+          cmd_name = command.first.to_s.upcase
+          key = command[1]&.to_s
+          level = error ? :error : :info
+
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "Redis #{cmd_name}",
+              category: 'redis',
+              level: level,
+              data: {
+                command: cmd_name,
+                key: key&.slice(0, 100),
+                duration_ms: duration_ms,
+                error: error
+              }.compact
+            )
+          end
+
+          record_pulse_span(cmd_name, key, duration_ms, error)
+        rescue StandardError => e
+          BrainzLab.debug_log("Redis instrumentation error: #{e.message}")
+        end
+
+        def record_pipeline(commands, started_at, error = nil)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+          level = error ? :error : :info
+
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "Redis PIPELINE (#{commands.size} commands)",
+              category: 'redis',
+              level: level,
+              data: {
+                count: commands.size,
+                duration_ms: duration_ms,
+                error: error
+              }.compact
+            )
+          end
+
+          record_pulse_span('PIPELINE', nil, duration_ms, error, commands.size)
+        rescue StandardError => e
+          BrainzLab.debug_log("Redis instrumentation error: #{e.message}")
+        end
+
+        def record_pulse_span(command, key, duration_ms, error, pipeline_count = nil)
+          spans = Thread.current[:brainzlab_pulse_spans]
+          return unless spans
+
+          span = {
+            span_id: SecureRandom.uuid,
+            name: "Redis #{command}",
+            kind: 'redis',
+            started_at: Time.now.utc - (duration_ms / 1000.0),
+            ended_at: Time.now.utc,
+            duration_ms: duration_ms,
+            data: {
+              command: command,
+              key: key&.slice(0, 100),
+              pipeline_count: pipeline_count
+            }.compact
+          }
+
+          if error
+            span[:error] = true
+            span[:error_class] = error
+          end
+
+          spans << span
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/resque.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module ResqueInstrumentation
+      class << self
+        def install!
+          return unless defined?(::Resque)
+
+          install_hooks!
+          install_failure_backend!
+
+          BrainzLab.debug_log('[Instrumentation] Resque instrumentation installed')
+        end
+
+        private
+
+        def install_hooks!
+          ::Resque.before_fork do |_job|
+            # Clear any stale connections before forking
+            BrainzLab::Recall.reset! if defined?(BrainzLab::Recall)
+            BrainzLab::Pulse.reset! if defined?(BrainzLab::Pulse)
+          end
+
+          ::Resque.after_fork do |job|
+            # Re-establish connections after forking
+          end
+        end
+
+        def install_failure_backend!
+          # Create a custom failure backend
+          failure_backend = Class.new do
+            def initialize(exception, worker, queue, payload)
+              @exception = exception
+              @worker = worker
+              @queue = queue
+              @payload = payload
+            end
+
+            def save
+              job_class = @payload['class'] || 'Unknown'
+
+              if BrainzLab.configuration.reflex_effectively_enabled?
+                BrainzLab::Reflex.capture(@exception,
+                                          tags: { job_class: job_class, queue: @queue, source: 'resque' },
+                                          extra: {
+                                            worker: @worker.to_s,
+                                            args: @payload['args']
+                                          })
+              end
+
+              return unless BrainzLab.configuration.flux_effectively_enabled?
+
+              BrainzLab::Flux.increment('resque.job.failed', tags: { job_class: job_class, queue: @queue })
+            end
+          end
+
+          # Add our failure backend to the chain
+          return unless defined?(::Resque::Failure)
+
+          ::Resque::Failure.backend = ::Resque::Failure::Multiple.new(
+            ::Resque::Failure.backend,
+            failure_backend
+          )
+        end
+      end
+
+      # Middleware module to include in Resque jobs
+      module Middleware
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def around_perform_brainzlab(*_args)
+            job_class = name
+            queue = Resque.queue_from_class(self) || 'default'
+            started_at = Time.now
+
+            BrainzLab::Context.current.set_context(
+              job_class: job_class,
+              queue: queue
+            )
+
+            begin
+              yield
+            ensure
+              duration_ms = ((Time.now - started_at) * 1000).round(2)
+
+              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,
+                  queue: queue
+                )
+              end
+
+              if BrainzLab.configuration.flux_effectively_enabled?
+                tags = { job_class: job_class, queue: queue }
+                BrainzLab::Flux.distribution('resque.job.duration_ms', duration_ms, tags: tags)
+                BrainzLab::Flux.increment('resque.job.processed', tags: tags)
+              end
+
+              BrainzLab.clear_context!
+            end
+          end
+        end
+      end
+    end
+  end
+end