brainzlab 0.1.0

data/lib/brainzlab/instrumentation/graphql.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    module GraphQLInstrumentation
+      @installed = false
+
+      class << self
+        def install!
+          return unless defined?(::GraphQL::Schema)
+          return if @installed
+
+          # For GraphQL Ruby 2.0+
+          if ::GraphQL::Schema.respond_to?(:trace_with)
+            # Will be installed per-schema via BrainzLab::GraphQL::Tracer
+            BrainzLab.debug_log("GraphQL tracer available - add `trace_with BrainzLab::Instrumentation::GraphQLInstrumentation::Tracer` to your schema")
+          end
+
+          # Subscribe to ActiveSupport notifications if available
+          install_notifications!
+
+          @installed = true
+          BrainzLab.debug_log("GraphQL instrumentation installed")
+        end
+
+        def installed?
+          @installed
+        end
+
+        def reset!
+          @installed = false
+        end
+
+        private
+
+        def install_notifications!
+          # GraphQL-ruby emits ActiveSupport notifications
+          ActiveSupport::Notifications.subscribe("execute.graphql") do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            record_execution(event)
+          end
+
+          ActiveSupport::Notifications.subscribe("analyze.graphql") do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            record_analyze(event)
+          end
+
+          ActiveSupport::Notifications.subscribe("validate.graphql") do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            record_validate(event)
+          end
+        rescue StandardError => e
+          BrainzLab.debug_log("GraphQL notifications setup failed: #{e.message}")
+        end
+
+        def record_execution(event)
+          payload = event.payload
+          query = payload[:query]
+          operation_name = query&.operation_name || "anonymous"
+          operation_type = query&.selected_operation&.operation_type || "query"
+          duration_ms = event.duration.round(2)
+
+          # Add breadcrumb
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "GraphQL #{operation_type} #{operation_name}",
+              category: "graphql.execute",
+              level: payload[:errors]&.any? ? :error : :info,
+              data: {
+                operation_name: operation_name,
+                operation_type: operation_type,
+                duration_ms: duration_ms,
+                error_count: payload[:errors]&.size || 0
+              }.compact
+            )
+          end
+
+          # Record span
+          record_span(
+            name: "GraphQL #{operation_type} #{operation_name}",
+            kind: "graphql",
+            duration_ms: duration_ms,
+            started_at: event.time,
+            ended_at: event.end,
+            data: {
+              operation_name: operation_name,
+              operation_type: operation_type,
+              query: truncate_query(query&.query_string),
+              variables: sanitize_variables(query&.variables&.to_h),
+              error_count: payload[:errors]&.size || 0
+            }.compact,
+            error: payload[:errors]&.any?
+          )
+        rescue StandardError => e
+          BrainzLab.debug_log("GraphQL execution recording failed: #{e.message}")
+        end
+
+        def record_analyze(event)
+          record_span(
+            name: "GraphQL analyze",
+            kind: "graphql",
+            duration_ms: event.duration.round(2),
+            started_at: event.time,
+            ended_at: event.end,
+            data: { phase: "analyze" }
+          )
+        rescue StandardError => e
+          BrainzLab.debug_log("GraphQL analyze recording failed: #{e.message}")
+        end
+
+        def record_validate(event)
+          record_span(
+            name: "GraphQL validate",
+            kind: "graphql",
+            duration_ms: event.duration.round(2),
+            started_at: event.time,
+            ended_at: event.end,
+            data: { phase: "validate" }
+          )
+        rescue StandardError => e
+          BrainzLab.debug_log("GraphQL validate recording failed: #{e.message}")
+        end
+
+        def record_span(name:, kind:, duration_ms:, started_at:, ended_at:, data:, error: false)
+          spans = Thread.current[:brainzlab_pulse_spans]
+          return unless spans
+
+          spans << {
+            span_id: SecureRandom.uuid,
+            name: name,
+            kind: kind,
+            started_at: started_at,
+            ended_at: ended_at,
+            duration_ms: duration_ms,
+            data: data,
+            error: error
+          }
+        end
+
+        def truncate_query(query)
+          return nil unless query
+          query.to_s[0, 2000]
+        end
+
+        def sanitize_variables(variables)
+          return nil unless variables
+
+          scrub_fields = BrainzLab.configuration.scrub_fields
+          variables.transform_values do |value|
+            if scrub_fields.any? { |f| value.to_s.downcase.include?(f.to_s) }
+              "[FILTERED]"
+            else
+              value
+            end
+          end
+        rescue StandardError
+          nil
+        end
+      end
+
+      # GraphQL Ruby 2.0+ Tracer module
+      # Add to your schema: trace_with BrainzLab::Instrumentation::GraphQLInstrumentation::Tracer
+      module Tracer
+        def execute_query(query:)
+          started_at = Time.now.utc
+          operation_name = query.operation_name || "anonymous"
+          operation_type = query.selected_operation&.operation_type || "query"
+
+          result = super
+
+          duration_ms = ((Time.now.utc - started_at) * 1000).round(2)
+          has_errors = result.to_h["errors"]&.any?
+
+          # Add breadcrumb
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "GraphQL #{operation_type} #{operation_name}",
+              category: "graphql.execute",
+              level: has_errors ? :error : :info,
+              data: {
+                operation_name: operation_name,
+                operation_type: operation_type,
+                duration_ms: duration_ms
+              }
+            )
+          end
+
+          # Record span
+          spans = Thread.current[:brainzlab_pulse_spans]
+          if spans
+            spans << {
+              span_id: SecureRandom.uuid,
+              name: "GraphQL #{operation_type} #{operation_name}",
+              kind: "graphql",
+              started_at: started_at,
+              ended_at: Time.now.utc,
+              duration_ms: duration_ms,
+              data: {
+                operation_name: operation_name,
+                operation_type: operation_type
+              },
+              error: has_errors
+            }
+          end
+
+          result
+        rescue StandardError => e
+          # Record error
+          if BrainzLab.configuration.reflex_enabled
+            BrainzLab::Reflex.add_breadcrumb(
+              "GraphQL #{operation_type} #{operation_name} failed",
+              category: "graphql.error",
+              level: :error,
+              data: { error: e.class.name }
+            )
+          end
+          raise
+        end
+
+        def execute_field(field:, query:, ast_node:, arguments:, object:)
+          started_at = Time.now.utc
+
+          result = super
+
+          duration_ms = ((Time.now.utc - started_at) * 1000).round(2)
+
+          # Only track slow field resolutions (> 10ms) to avoid noise
+          if duration_ms > 10
+            spans = Thread.current[:brainzlab_pulse_spans]
+            if spans
+              spans << {
+                span_id: SecureRandom.uuid,
+                name: "GraphQL field #{field.owner.graphql_name}.#{field.graphql_name}",
+                kind: "graphql.field",
+                started_at: started_at,
+                ended_at: Time.now.utc,
+                duration_ms: duration_ms,
+                data: {
+                  field: field.graphql_name,
+                  parent_type: field.owner.graphql_name
+                }
+              }
+            end
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/httparty.rb

@@ -0,0 +1,194 @@
+# 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 = {}, &block)
+          return super unless should_track?(path, options)
+
+          # Inject distributed tracing headers
+          options = inject_trace_context(options)
+
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          error_info = nil
+
+          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
+          if ::Mongoid.respond_to?(:subscribe)
+            ::Mongoid.subscribe(CommandSubscriber.new)
+          end
+        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