fluyenta-ruby 0.1.14

data/lib/brainzlab/instrumentation/elasticsearch.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module ElasticsearchInstrumentation
+      @installed = false
+
+      class << self
+        def install!
+          return if @installed
+
+          installed_any = false
+
+          # Elasticsearch gem (elasticsearch-ruby)
+          if defined?(::Elasticsearch::Transport::Client)
+            install_elasticsearch_transport!
+            installed_any = true
+          end
+
+          # OpenSearch gem
+          if defined?(::OpenSearch::Client)
+            install_opensearch!
+            installed_any = true
+          end
+
+          # Elasticsearch 8.x with new client
+          if defined?(::Elastic::Transport::Client)
+            install_elastic_transport!
+            installed_any = true
+          end
+
+          return unless installed_any
+
+          @installed = true
+          BrainzLab.debug_log('Elasticsearch instrumentation installed')
+        end
+
+        def installed?
+          @installed
+        end
+
+        def reset!
+          @installed = false
+        end
+
+        private
+
+        def install_elasticsearch_transport!
+          ::Elasticsearch::Transport::Client.prepend(ClientPatch)
+        end
+
+        def install_opensearch!
+          ::OpenSearch::Client.prepend(ClientPatch)
+        end
+
+        def install_elastic_transport!
+          ::Elastic::Transport::Client.prepend(ClientPatch)
+        end
+      end
+
+      # Patch for Elasticsearch/OpenSearch clients
+      module ClientPatch
+        def perform_request(method, path, params = {}, body = nil, headers = nil)
+          return super unless should_track?
+
+          started_at = Time.now.utc
+
+          begin
+            response = super
+            record_request(method, path, params, started_at, response.status)
+            response
+          rescue StandardError => e
+            record_request(method, path, params, started_at, nil, e)
+            raise
+          end
+        end
+
+        private
+
+        def should_track?
+          BrainzLab.configuration.instrument_elasticsearch
+        end
+
+        def record_request(method, path, _params, started_at, status, error = nil)
+          duration_ms = ((Time.now.utc - started_at) * 1000).round(2)
+          operation = extract_operation(method, path)
+          index = extract_index(path)
+          level = error || (status && status >= 400) ? :error : :info
+
+          # Add breadcrumb for Reflex
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "ES #{operation}",
+              category: 'elasticsearch',
+              level: level,
+              data: {
+                method: method.to_s.upcase,
+                path: truncate_path(path),
+                index: index,
+                status: status,
+                duration_ms: duration_ms,
+                error: error&.class&.name
+              }.compact
+            )
+          end
+
+          # Record span for Pulse
+          record_span(
+            operation: operation,
+            method: method,
+            path: path,
+            index: index,
+            started_at: started_at,
+            duration_ms: duration_ms,
+            status: status,
+            error: error
+          )
+
+          # Log to Recall
+          if BrainzLab.configuration.recall_enabled
+            log_method = error ? :warn : :debug
+            BrainzLab::Recall.send(
+              log_method,
+              "ES #{method.to_s.upcase} #{path} -> #{status || 'ERROR'} (#{duration_ms}ms)",
+              method: method.to_s.upcase,
+              path: path,
+              index: index,
+              status: status,
+              duration_ms: duration_ms,
+              error: error&.message
+            )
+          end
+        rescue StandardError => e
+          BrainzLab.debug_log("Elasticsearch recording failed: #{e.message}")
+        end
+
+        def record_span(operation:, method:, path:, index:, started_at:, duration_ms:, status:, error:)
+          spans = Thread.current[:brainzlab_pulse_spans]
+          return unless spans
+
+          span = {
+            span_id: SecureRandom.uuid,
+            name: "ES #{operation}",
+            kind: 'elasticsearch',
+            started_at: started_at,
+            ended_at: Time.now.utc,
+            duration_ms: duration_ms,
+            data: {
+              method: method.to_s.upcase,
+              path: truncate_path(path),
+              index: index,
+              status: status
+            }.compact
+          }
+
+          if error
+            span[:error] = true
+            span[:error_class] = error.class.name
+            span[:error_message] = error.message&.slice(0, 500)
+          end
+
+          spans << span
+        end
+
+        def extract_operation(method, path)
+          method_str = method.to_s.upcase
+
+          case path
+          when %r{/_search} then 'search'
+          when %r{/_bulk} then 'bulk'
+          when %r{/_count} then 'count'
+          when %r{/_mget} then 'mget'
+          when %r{/_msearch} then 'msearch'
+          when %r{/_update_by_query} then 'update_by_query'
+          when %r{/_delete_by_query} then 'delete_by_query'
+          when %r{/_refresh} then 'refresh'
+          when %r{/_mapping} then 'mapping'
+          when %r{/_settings} then 'settings'
+          when %r{/_alias} then 'alias'
+          when %r{/_analyze} then 'analyze'
+          else
+            case method_str
+            when 'GET' then 'get'
+            when 'POST' then 'index'
+            when 'PUT' then 'update'
+            when 'DELETE' then 'delete'
+            when 'HEAD' then 'exists'
+            else method_str.downcase
+            end
+          end
+        end
+
+        def extract_index(path)
+          # Extract index name from path like /my-index/_search
+          match = path.match(%r{^/([^/_]+)})
+          match[1] if match && !match[1].start_with?('_')
+        rescue StandardError
+          nil
+        end
+
+        def truncate_path(path)
+          return nil unless path
+
+          path.to_s[0, 200]
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/excon.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module ExconInstrumentation
+      class << self
+        def install!
+          return unless defined?(::Excon)
+
+          install_middleware!
+
+          BrainzLab.debug_log('[Instrumentation] Excon instrumentation installed')
+        end
+
+        private
+
+        def install_middleware!
+          # Add our instrumentor to Excon defaults
+          ::Excon.defaults[:instrumentor] = BrainzLabInstrumentor
+
+          # Also set up middleware
+          return unless ::Excon.defaults[:middlewares]
+
+          ::Excon.defaults[:middlewares] = [Middleware] + ::Excon.defaults[:middlewares]
+        end
+      end
+
+      # Excon Instrumentor for ActiveSupport-style notifications
+      module BrainzLabInstrumentor
+        def self.instrument(name, params = {})
+          started_at = Time.now
+
+          begin
+            result = yield if block_given?
+            track_request(name, params, started_at, nil)
+            result
+          rescue StandardError => e
+            track_request(name, params, started_at, e)
+            raise
+          end
+        end
+
+        def self.track_request(_name, params, started_at, error)
+          return if skip_tracking?(params)
+
+          duration_ms = ((Time.now - started_at) * 1000).round(2)
+          host = params[:host] || 'unknown'
+          method = (params[:method] || 'GET').to_s.upcase
+          path = params[:path] || '/'
+          status = params[:status]
+
+          # Add breadcrumb
+          BrainzLab::Reflex.add_breadcrumb(
+            "HTTP #{method} #{host}#{path}",
+            category: 'http',
+            level: error ? :error : :info,
+            data: {
+              method: method,
+              host: host,
+              path: path,
+              status: status,
+              duration_ms: duration_ms
+            }
+          )
+
+          # Track with Pulse
+          if BrainzLab.configuration.pulse_effectively_enabled?
+            BrainzLab::Pulse.span('http.excon', kind: 'http') do
+              # Already completed, just recording
+            end
+          end
+
+          # Track with Flux
+          return unless BrainzLab.configuration.flux_effectively_enabled?
+
+          tags = { host: host, method: method, status: status.to_s }
+          BrainzLab::Flux.distribution('http.excon.duration_ms', duration_ms, tags: tags)
+          BrainzLab::Flux.increment('http.excon.requests', tags: tags)
+
+          return unless error || (status && status >= 400)
+
+          BrainzLab::Flux.increment('http.excon.errors', tags: tags)
+        end
+
+        def self.skip_tracking?(params)
+          host = params[:host]
+          return true unless host
+
+          ignore_hosts = BrainzLab.configuration.http_ignore_hosts || []
+          ignore_hosts.any? { |h| host.include?(h) }
+        end
+      end
+
+      # Excon Middleware
+      class Middleware
+        def initialize(stack)
+          @stack = stack
+        end
+
+        def request_call(datum)
+          datum[:brainzlab_started_at] = Time.now
+          @stack.request_call(datum)
+        end
+
+        def response_call(datum)
+          track_response(datum)
+          @stack.response_call(datum)
+        end
+
+        def error_call(datum)
+          track_response(datum, error: true)
+          @stack.error_call(datum)
+        end
+
+        private
+
+        def track_response(datum, error: false)
+          started_at = datum[:brainzlab_started_at]
+          return unless started_at
+
+          host = datum[:host]
+          return if skip_host?(host)
+
+          duration_ms = ((Time.now - started_at) * 1000).round(2)
+          method = (datum[:method] || 'GET').to_s.upcase
+          path = datum[:path] || '/'
+          status = datum[:response]&.dig(:status)
+
+          BrainzLab::Reflex.add_breadcrumb(
+            "HTTP #{method} #{host}#{path} -> #{status || 'error'}",
+            category: 'http',
+            level: error ? :error : :info,
+            data: { method: method, host: host, status: status, duration_ms: duration_ms }
+          )
+
+          return unless BrainzLab.configuration.flux_effectively_enabled?
+
+          tags = { host: host, method: method }
+          tags[:status] = status.to_s if status
+          BrainzLab::Flux.distribution('http.excon.duration_ms', duration_ms, tags: tags)
+        end
+
+        def skip_host?(host)
+          return true unless host
+
+          ignore_hosts = BrainzLab.configuration.http_ignore_hosts || []
+          ignore_hosts.any? { |h| host.include?(h) }
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/faraday.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module FaradayMiddleware
+      @installed = false
+
+      class << self
+        def install!
+          return unless defined?(::Faraday)
+          return if @installed
+
+          # Register the middleware with Faraday
+          ::Faraday::Middleware.register_middleware(brainzlab: Middleware)
+
+          @installed = true
+          BrainzLab.debug_log('Faraday instrumentation installed')
+        end
+
+        def installed?
+          @installed
+        end
+
+        def reset!
+          @installed = false
+        end
+      end
+
+      # Faraday middleware for HTTP request instrumentation
+      # Usage:
+      #   conn = Faraday.new do |f|
+      #     f.use :brainzlab
+      #     # or
+      #     f.use BrainzLab::Instrumentation::FaradayMiddleware::Middleware
+      #   end
+      class Middleware < ::Faraday::Middleware
+        def initialize(app, options = {})
+          super(app)
+          @options = options
+        end
+
+        def call(env)
+          return @app.call(env) unless should_track?(env)
+
+          # Inject distributed tracing context
+          inject_trace_context(env)
+
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          begin
+            response = @app.call(env)
+            track_request(env, response.status, started_at)
+            response
+          rescue ::Faraday::Error => e
+            error_info = e.class.name
+            track_request(env, e.response&.dig(:status), started_at, error_info)
+            raise
+          rescue StandardError => e
+            error_info = e.class.name
+            track_request(env, nil, started_at, error_info)
+            raise
+          end
+        end
+
+        private
+
+        def should_track?(env)
+          return false unless BrainzLab.configuration.instrument_http
+
+          ignore_hosts = BrainzLab.configuration.http_ignore_hosts || []
+          host = env.url.host
+          !ignore_hosts.include?(host)
+        end
+
+        def inject_trace_context(env)
+          return unless BrainzLab.configuration.pulse_enabled
+
+          headers = {}
+          BrainzLab::Pulse.inject(headers, format: :all)
+
+          headers.each do |key, value|
+            env.request_headers[key] = value
+          end
+        rescue StandardError => e
+          BrainzLab.debug_log("Failed to inject trace context: #{e.message}")
+        end
+
+        def track_request(env, status, started_at, error = nil)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+          method = env.method.to_s.upcase
+          url = sanitize_url(env.url)
+          host = env.url.host
+          path = env.url.path
+          level = error || (status && status >= 400) ? :error : :info
+
+          # Add breadcrumb for Reflex
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "#{method} #{url}",
+              category: 'http.faraday',
+              level: level,
+              data: {
+                method: method,
+                url: url,
+                host: host,
+                path: path,
+                status_code: status,
+                duration_ms: duration_ms,
+                error: error
+              }.compact
+            )
+          end
+
+          # Record span for Pulse APM
+          record_pulse_span(method, host, path, status, duration_ms, error)
+
+          # Log to Recall at debug level
+          if BrainzLab.configuration.recall_enabled
+            BrainzLab::Recall.debug(
+              "HTTP #{method} #{url} -> #{status || 'ERROR'}",
+              method: method,
+              url: url,
+              host: host,
+              status_code: status,
+              duration_ms: duration_ms,
+              error: error
+            )
+          end
+        rescue StandardError => e
+          BrainzLab.debug_log("Faraday instrumentation error: #{e.message}")
+        end
+
+        def record_pulse_span(method, host, path, status, duration_ms, error)
+          spans = Thread.current[:brainzlab_pulse_spans]
+          return unless spans
+
+          span = {
+            span_id: SecureRandom.uuid,
+            name: "HTTP #{method} #{host}",
+            kind: 'http',
+            started_at: Time.now.utc - (duration_ms / 1000.0),
+            ended_at: Time.now.utc,
+            duration_ms: duration_ms,
+            data: {
+              method: method,
+              host: host,
+              path: path,
+              status: status
+            }.compact
+          }
+
+          if error
+            span[:error] = true
+            span[:error_class] = error
+          end
+
+          spans << span
+        end
+
+        def sanitize_url(url)
+          # Remove sensitive query parameters
+          uri = url.dup
+          if uri.query
+            params = URI.decode_www_form(uri.query).reject do |key, _|
+              sensitive_param?(key)
+            end
+            uri.query = params.empty? ? nil : URI.encode_www_form(params)
+          end
+          uri.to_s
+        rescue StandardError
+          url.to_s
+        end
+
+        def sensitive_param?(key)
+          key = key.to_s.downcase
+          %w[token api_key apikey secret password auth key].any? { |s| key.include?(s) }
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/good_job.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module GoodJobInstrumentation
+      class << self
+        def install!
+          return unless defined?(::GoodJob)
+
+          install_notifier!
+          install_middleware!
+
+          BrainzLab.debug_log('[Instrumentation] GoodJob instrumentation installed')
+        end
+
+        private
+
+        def install_notifier!
+          return unless defined?(::ActiveSupport::Notifications)
+
+          # GoodJob emits ActiveSupport notifications
+          ::ActiveSupport::Notifications.subscribe('perform_job.good_job') do |*args|
+            event = ::ActiveSupport::Notifications::Event.new(*args)
+            handle_perform(event)
+          end
+
+          ::ActiveSupport::Notifications.subscribe('finished_job_task.good_job') do |*args|
+            event = ::ActiveSupport::Notifications::Event.new(*args)
+            handle_finished(event)
+          end
+        end
+
+        def install_middleware!
+          return unless defined?(::GoodJob::Adapter)
+
+          # Add our callback to GoodJob
+          return unless ::GoodJob.respond_to?(:on_thread_error)
+
+          ::GoodJob.on_thread_error = lambda { |error|
+            if BrainzLab.configuration.reflex_effectively_enabled?
+              BrainzLab::Reflex.capture(error,
+                                        tags: { source: 'good_job' })
+            end
+          }
+        end
+
+        def handle_perform(event)
+          payload = event.payload
+          job = payload[:job]
+          job_class = job&.class&.name || payload[:job_class] || 'Unknown'
+          queue = job&.queue_name || payload[:queue_name] || 'default'
+          duration_ms = event.duration.round(2)
+
+          # Track with Pulse
+          if BrainzLab.configuration.pulse_effectively_enabled?
+            BrainzLab::Pulse.record_trace(
+              "job.#{job_class}",
+              kind: 'job',
+              started_at: event.time,
+              ended_at: event.end,
+              job_class: job_class,
+              job_id: job&.job_id || payload[:job_id],
+              queue: queue,
+              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('good_job.job.duration_ms', duration_ms, tags: tags)
+            BrainzLab::Flux.increment('good_job.job.processed', tags: tags)
+
+            BrainzLab::Flux.increment('good_job.job.failed', tags: tags) if payload[:error]
+          end
+
+          # Capture error with Reflex
+          return unless payload[:error] && BrainzLab.configuration.reflex_effectively_enabled?
+
+          BrainzLab::Reflex.capture(payload[:error],
+                                    tags: { job_class: job_class, queue: queue, source: 'good_job' },
+                                    extra: { job_id: job&.job_id, duration_ms: duration_ms })
+        end
+
+        def handle_finished(event)
+          payload = event.payload
+
+          return unless BrainzLab.configuration.flux_effectively_enabled?
+
+          result = payload[:result]
+          if result == :discarded
+            BrainzLab::Flux.increment('good_job.job.discarded')
+          elsif result == :retried
+            BrainzLab::Flux.increment('good_job.job.retried')
+          end
+        end
+      end
+    end
+  end
+end