fluyenta-ruby 0.1.14

data/lib/brainzlab/instrumentation/httparty.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module HTTPartyInstrumentation
+      @installed = false
+
+      class << self
+        def install!
+          return unless defined?(::HTTParty)
+          return if @installed
+
+          ::HTTParty.singleton_class.prepend(Patch)
+
+          @installed = true
+          BrainzLab.debug_log('HTTParty instrumentation installed')
+        end
+
+        def installed?
+          @installed
+        end
+
+        def reset!
+          @installed = false
+        end
+      end
+
+      module Patch
+        def perform_request(http_method, path, options = {}, &)
+          return super unless should_track?(path, options)
+
+          # Inject distributed tracing headers
+          options = inject_trace_context(options)
+
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          begin
+            response = super
+            track_request(http_method, path, options, response.code, started_at)
+            response
+          rescue StandardError => e
+            error_info = e.class.name
+            track_request(http_method, path, options, nil, started_at, error_info)
+            raise
+          end
+        end
+
+        private
+
+        def should_track?(path, options)
+          return false unless BrainzLab.configuration.instrument_http
+
+          uri = parse_uri(path, options)
+          return true unless uri
+
+          ignore_hosts = BrainzLab.configuration.http_ignore_hosts || []
+          !ignore_hosts.include?(uri.host)
+        end
+
+        def inject_trace_context(options)
+          return options unless BrainzLab.configuration.pulse_enabled
+
+          options = options.dup
+          options[:headers] ||= {}
+
+          trace_headers = {}
+          BrainzLab::Pulse.inject(trace_headers, format: :all)
+
+          options[:headers] = options[:headers].merge(trace_headers)
+          options
+        rescue StandardError => e
+          BrainzLab.debug_log("Failed to inject trace context: #{e.message}")
+          options
+        end
+
+        def track_request(http_method, path, options, status, started_at, error = nil)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+          method = extract_method_name(http_method)
+          uri = parse_uri(path, options)
+          url = uri ? sanitize_url(uri) : path.to_s
+          host = uri&.host || 'unknown'
+          request_path = uri&.path || path.to_s
+          level = error || (status && status >= 400) ? :error : :info
+
+          # Add breadcrumb for Reflex
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "#{method} #{url}",
+              category: 'http.httparty',
+              level: level,
+              data: {
+                method: method,
+                url: url,
+                host: host,
+                path: request_path,
+                status_code: status,
+                duration_ms: duration_ms,
+                error: error
+              }.compact
+            )
+          end
+
+          # Record span for Pulse APM
+          record_pulse_span(method, host, request_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("HTTParty 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 extract_method_name(http_method)
+          case http_method.name
+          when /Get$/ then 'GET'
+          when /Post$/ then 'POST'
+          when /Put$/ then 'PUT'
+          when /Patch$/ then 'PATCH'
+          when /Delete$/ then 'DELETE'
+          when /Head$/ then 'HEAD'
+          when /Options$/ then 'OPTIONS'
+          else http_method.name.split('::').last.upcase
+          end
+        end
+
+        def parse_uri(path, options)
+          base_uri = options[:base_uri]
+          if base_uri
+            URI.join(base_uri.to_s, path.to_s)
+          else
+            URI.parse(path.to_s)
+          end
+        rescue URI::InvalidURIError
+          nil
+        end
+
+        def sanitize_url(uri)
+          result = uri.dup
+          if result.query
+            params = URI.decode_www_form(result.query).reject do |key, _|
+              sensitive_param?(key)
+            end
+            result.query = params.empty? ? nil : URI.encode_www_form(params)
+          end
+          result.to_s
+        rescue StandardError
+          uri.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/mongodb.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module MongoDBInstrumentation
+      @installed = false
+
+      class << self
+        def install!
+          return if @installed
+
+          installed_any = false
+
+          # Install MongoDB Ruby Driver monitoring
+          if defined?(::Mongo::Client)
+            install_mongo_driver!
+            installed_any = true
+          end
+
+          # Install Mongoid APM subscriber
+          if defined?(::Mongoid)
+            install_mongoid!
+            installed_any = true
+          end
+
+          return unless installed_any
+
+          @installed = true
+          BrainzLab.debug_log('MongoDB instrumentation installed')
+        end
+
+        def installed?
+          @installed
+        end
+
+        def reset!
+          @installed = false
+        end
+
+        private
+
+        def install_mongo_driver!
+          # Subscribe to command monitoring events
+          subscriber = CommandSubscriber.new
+
+          ::Mongo::Monitoring::Global.subscribe(
+            ::Mongo::Monitoring::COMMAND,
+            subscriber
+          )
+        end
+
+        def install_mongoid!
+          # For Mongoid 7+, use the APM module
+          return unless ::Mongoid.respond_to?(:subscribe)
+
+          ::Mongoid.subscribe(CommandSubscriber.new)
+        end
+      end
+
+      # MongoDB Command Subscriber
+      class CommandSubscriber
+        SKIP_COMMANDS = %w[isMaster ismaster buildInfo getLastError saslStart saslContinue].freeze
+
+        def initialize
+          @commands = {}
+        end
+
+        # Called when command starts
+        def started(event)
+          return if skip_command?(event.command_name)
+
+          @commands[event.request_id] = {
+            started_at: Time.now.utc,
+            command_name: event.command_name,
+            database: event.database_name,
+            collection: extract_collection(event)
+          }
+        end
+
+        # Called when command succeeds
+        def succeeded(event)
+          record_command(event, success: true)
+        end
+
+        # Called when command fails
+        def failed(event)
+          record_command(event, success: false, error: event.message)
+        end
+
+        private
+
+        def skip_command?(command_name)
+          SKIP_COMMANDS.include?(command_name.to_s)
+        end
+
+        def extract_collection(event)
+          # Try to extract collection name from command
+          cmd = event.command
+          cmd['collection'] || cmd[event.command_name] || cmd.keys.first
+        rescue StandardError
+          nil
+        end
+
+        def record_command(event, success:, error: nil)
+          command_data = @commands.delete(event.request_id)
+          return unless command_data
+
+          duration_ms = event.duration * 1000 # Convert seconds to ms
+          command_name = command_data[:command_name]
+          collection = command_data[:collection]
+          database = command_data[:database]
+
+          level = success ? :info : :error
+
+          # Add breadcrumb for Reflex
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "MongoDB #{command_name}",
+              category: 'mongodb',
+              level: level,
+              data: {
+                command: command_name,
+                collection: collection,
+                database: database,
+                duration_ms: duration_ms.round(2),
+                error: error
+              }.compact
+            )
+          end
+
+          # Record span for Pulse
+          record_span(
+            command_name: command_name,
+            collection: collection,
+            database: database,
+            started_at: command_data[:started_at],
+            duration_ms: duration_ms,
+            success: success,
+            error: error
+          )
+
+          # Log to Recall
+          if BrainzLab.configuration.recall_enabled
+            log_method = success ? :debug : :warn
+            BrainzLab::Recall.send(
+              log_method,
+              "MongoDB #{command_name} #{collection} (#{duration_ms.round(2)}ms)",
+              command: command_name,
+              collection: collection,
+              database: database,
+              duration_ms: duration_ms.round(2),
+              error: error
+            )
+          end
+        rescue StandardError => e
+          BrainzLab.debug_log("MongoDB command recording failed: #{e.message}")
+        end
+
+        def record_span(command_name:, collection:, database:, started_at:, duration_ms:, success:, error:)
+          spans = Thread.current[:brainzlab_pulse_spans]
+          return unless spans
+
+          span = {
+            span_id: SecureRandom.uuid,
+            name: "MongoDB #{command_name} #{collection}".strip,
+            kind: 'mongodb',
+            started_at: started_at,
+            ended_at: Time.now.utc,
+            duration_ms: duration_ms.round(2),
+            data: {
+              command: command_name,
+              collection: collection,
+              database: database
+            }.compact
+          }
+
+          unless success
+            span[:error] = true
+            span[:error_message] = error
+          end
+
+          spans << span
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/net_http.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module NetHttp
+      @installed = false
+
+      class << self
+        def install!
+          return if @installed
+
+          ::Net::HTTP.prepend(Patch)
+          @installed = true
+        end
+
+        def installed?
+          @installed
+        end
+
+        # For testing purposes
+        def reset!
+          @installed = false
+        end
+      end
+
+      module Patch
+        def request(req, body = nil, &)
+          return super unless should_track?
+
+          # Inject distributed tracing context into outgoing request headers
+          inject_trace_context(req)
+
+          url = build_url(req)
+          method = req.method
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          begin
+            response = super
+            track_request(method, url, response.code.to_i, started_at)
+            response
+          rescue StandardError => e
+            track_request(method, url, nil, started_at, e.class.name)
+            raise
+          end
+        end
+
+        def inject_trace_context(req)
+          return unless BrainzLab.configuration.pulse_enabled
+
+          # Build headers hash and inject trace context
+          headers = {}
+          BrainzLab::Pulse.inject(headers, format: :all)
+
+          # Apply headers to request
+          headers.each do |key, value|
+            req[key] = value
+          end
+        rescue StandardError => e
+          BrainzLab.debug_log("Failed to inject trace context: #{e.message}")
+        end
+
+        private
+
+        def should_track?
+          return false unless BrainzLab.configuration.instrument_http
+          # Skip tracking SDK's own HTTP calls to its service endpoints
+          # to prevent recursive cascading (SDK HTTP → track → Recall.debug → buffer → flush → SDK HTTP → ...)
+          return false if BrainzLab.configuration.sdk_service_hosts.include?(address)
+
+          ignore_hosts = BrainzLab.configuration.http_ignore_hosts || []
+          !ignore_hosts.include?(address)
+        end
+
+        def build_url(req)
+          scheme = use_ssl? ? 'https' : 'http'
+          port_str = if (use_ssl? && port == 443) || (!use_ssl? && port == 80)
+                       ''
+                     else
+                       ":#{port}"
+                     end
+          "#{scheme}://#{address}#{port_str}#{req.path}"
+        end
+
+        def track_request(method, url, status, started_at, error = nil)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+          level = error || (status && status >= 400) ? :error : :info
+
+          BrainzLab.with_instrumentation_guard do
+            # Add breadcrumb for Reflex (in-memory, safe)
+            if BrainzLab.configuration.reflex_enabled
+              BrainzLab::Reflex.add_breadcrumb(
+                "#{method} #{url}",
+                category: 'http',
+                level: level,
+                data: { method: method, url: url, status_code: status, duration_ms: duration_ms, error: error }.compact
+              )
+            end
+
+            # Log to Recall at debug level (skipped if already instrumenting)
+            if BrainzLab.configuration.recall_enabled
+              BrainzLab::Recall.debug(
+                "HTTP #{method} #{url} -> #{status || 'ERROR'}",
+                method: method, url: url, status_code: status, duration_ms: duration_ms, error: error
+              )
+            end
+          end
+        rescue StandardError => e
+          # Don't let instrumentation errors crash the app
+          BrainzLab.configuration.logger&.error("[BrainzLab] HTTP instrumentation error: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/rails_deprecation.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    class RailsDeprecation
+      class << self
+        def install!
+          return unless defined?(::Rails)
+          return if @installed
+
+          install_deprecation_subscriber!
+
+          @installed = true
+          BrainzLab.debug_log('Rails deprecation instrumentation installed')
+        end
+
+        def installed?
+          @installed == true
+        end
+
+        private
+
+        # ============================================
+        # deprecation.rails
+        # Fired when a deprecated Rails API is used
+        # ============================================
+        def install_deprecation_subscriber!
+          ActiveSupport::Notifications.subscribe('deprecation.rails') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            handle_deprecation(event)
+          end
+        end
+
+        def handle_deprecation(event)
+          payload = event.payload
+
+          message = payload[:message]
+          callstack = payload[:callstack]
+          gem_name = payload[:gem_name]
+          deprecation_horizon = payload[:deprecation_horizon]
+
+          # Extract relevant caller info
+          caller_info = extract_caller_info(callstack)
+
+          # Record breadcrumb with warning level
+          if BrainzLab.configuration.reflex_effectively_enabled?
+            BrainzLab::Reflex.add_breadcrumb(
+              "Deprecation: #{truncate_message(message)}",
+              category: 'rails.deprecation',
+              level: :warning,
+              data: {
+                message: truncate_message(message, 500),
+                gem_name: gem_name,
+                deprecation_horizon: deprecation_horizon,
+                caller: caller_info
+              }.compact
+            )
+          end
+
+          # Log to Recall for tracking
+          if BrainzLab.configuration.recall_effectively_enabled?
+            BrainzLab::Recall.warn(
+              "Rails deprecation warning",
+              message: truncate_message(message, 500),
+              gem_name: gem_name,
+              deprecation_horizon: deprecation_horizon,
+              caller: caller_info,
+              callstack: truncate_callstack(callstack)
+            )
+          end
+
+          # Track deprecation count in Pulse metrics
+          record_deprecation_metric(gem_name, deprecation_horizon)
+        rescue StandardError => e
+          BrainzLab.debug_log("Rails deprecation instrumentation failed: #{e.message}")
+        end
+
+        # ============================================
+        # Helper Methods
+        # ============================================
+        def extract_caller_info(callstack)
+          return nil unless callstack.is_a?(Array) && callstack.any?
+
+          # Find the first non-Rails, non-gem caller
+          app_caller = callstack.find do |line|
+            line_str = line.to_s
+            !line_str.include?('/gems/') &&
+              !line_str.include?('/ruby/') &&
+              !line_str.include?('/bundler/')
+          end
+
+          (app_caller || callstack.first).to_s
+        end
+
+        def truncate_callstack(callstack, max_lines = 5)
+          return nil unless callstack.is_a?(Array)
+
+          callstack.first(max_lines).map(&:to_s)
+        end
+
+        def truncate_message(message, max_length = 200)
+          return 'unknown' unless message
+
+          msg_str = message.to_s
+          if msg_str.length > max_length
+            "#{msg_str[0, max_length - 3]}..."
+          else
+            msg_str
+          end
+        end
+
+        def record_deprecation_metric(gem_name, horizon)
+          return unless BrainzLab.configuration.pulse_effectively_enabled?
+
+          # If Pulse has a counter/metric API, use it here
+          # For now, we just add a span to track it
+          tracer = BrainzLab::Pulse.tracer
+          return unless tracer.current_trace
+
+          span_data = {
+            span_id: SecureRandom.uuid,
+            name: 'rails.deprecation',
+            kind: 'internal',
+            started_at: Time.now,
+            ended_at: Time.now,
+            duration_ms: 0,
+            error: false,
+            data: {
+              'deprecation.gem_name' => gem_name,
+              'deprecation.horizon' => horizon
+            }.compact
+          }
+
+          tracer.current_spans << span_data
+        end
+      end
+    end
+  end
+end