pingops 0.0.1

data/lib/pingops/core/types.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Pingops
+  module Core
+    # Domain rule for allow/deny lists
+    # @attr domain [String] Domain to match (exact or suffix if starts with ".")
+    # @attr paths [Array<String>, nil] If set, URL path must start with one of these
+    # @attr headers_allow_list [Array<String>, nil] Override global: only these headers for this domain
+    # @attr headers_deny_list [Array<String>, nil] Override global: exclude these headers for this domain
+    # @attr capture_request_body [Boolean, nil] Override global/context for this domain
+    # @attr capture_response_body [Boolean, nil] Override global/context for this domain
+    class DomainRule
+      attr_reader :domain, :paths, :headers_allow_list, :headers_deny_list,
+                  :capture_request_body, :capture_response_body
+
+      def initialize(
+        domain:,
+        paths: nil,
+        headers_allow_list: nil,
+        headers_deny_list: nil,
+        capture_request_body: nil,
+        capture_response_body: nil
+      )
+        @domain = domain.to_s
+        @paths = paths&.map(&:to_s)
+        @headers_allow_list = headers_allow_list&.map { |h| h.to_s.downcase }
+        @headers_deny_list = headers_deny_list&.map { |h| h.to_s.downcase }
+        @capture_request_body = capture_request_body
+        @capture_response_body = capture_response_body
+      end
+
+      # Check if this rule matches the given domain
+      # @param target_domain [String] The domain to check
+      # @return [Boolean]
+      def matches_domain?(target_domain)
+        return false if target_domain.nil? || target_domain.empty?
+
+        target = target_domain.downcase
+        rule_domain = @domain.downcase
+
+        if rule_domain.start_with?('.')
+          # Suffix match: ".example.com" matches "api.example.com" or "example.com"
+          target.end_with?(rule_domain) || target == rule_domain[1..]
+        else
+          # Exact match
+          target == rule_domain
+        end
+      end
+
+      # Check if this rule matches the given path
+      # @param path [String] The path to check
+      # @return [Boolean]
+      def matches_path?(path)
+        return true if @paths.nil? || @paths.empty?
+
+        @paths.any? { |p| path.to_s.start_with?(p) }
+      end
+
+      # Create from hash (for config loading)
+      # @param hash [Hash] Hash representation
+      # @return [DomainRule]
+      def self.from_hash(hash)
+        return hash if hash.is_a?(DomainRule)
+
+        new(
+          domain: hash[:domain] || hash['domain'],
+          paths: hash[:paths] || hash['paths'],
+          headers_allow_list: hash[:headers_allow_list] || hash['headersAllowList'],
+          headers_deny_list: hash[:headers_deny_list] || hash['headersDenyList'],
+          capture_request_body: hash[:capture_request_body] || hash['captureRequestBody'],
+          capture_response_body: hash[:capture_response_body] || hash['captureResponseBody']
+        )
+      end
+    end
+
+    # Header redaction configuration
+    # @attr sensitive_patterns [Array<String>] Case-insensitive patterns to match header names
+    # @attr strategy [String] How to redact: replace, partial, partial_end, remove
+    # @attr redaction_string [String] String used for redaction
+    # @attr visible_chars [Integer] For partial strategies, how many chars to show
+    # @attr enabled [Boolean] If false, no redaction
+    class HeaderRedactionConfig
+      attr_reader :sensitive_patterns, :strategy, :redaction_string, :visible_chars, :enabled
+
+      def initialize(
+        sensitive_patterns: nil,
+        strategy: nil,
+        redaction_string: nil,
+        visible_chars: nil,
+        enabled: nil
+      )
+        @sensitive_patterns = (sensitive_patterns || Constants::DEFAULT_SENSITIVE_HEADER_PATTERNS).map(&:downcase)
+        @strategy = strategy || Constants::REDACTION_STRATEGY_REPLACE
+        @redaction_string = redaction_string || Constants::DEFAULT_REDACTION_STRING
+        @visible_chars = visible_chars || Constants::DEFAULT_VISIBLE_CHARS
+        @enabled = enabled.nil? || enabled
+      end
+
+      # Create from hash (for config loading)
+      # @param hash [Hash, nil] Hash representation
+      # @return [HeaderRedactionConfig]
+      def self.from_hash(hash)
+        return new if hash.nil?
+        return hash if hash.is_a?(HeaderRedactionConfig)
+
+        new(
+          sensitive_patterns: hash[:sensitive_patterns] || hash['sensitivePatterns'],
+          strategy: hash[:strategy] || hash['strategy'],
+          redaction_string: hash[:redaction_string] || hash['redactionString'],
+          visible_chars: hash[:visible_chars] || hash['visibleChars'],
+          enabled: hash[:enabled].nil? ? hash['enabled'] : hash[:enabled]
+        )
+      end
+    end
+
+    # Trace attributes for startTrace
+    # @attr trace_id [String, nil] Optional; if set, used as trace ID
+    # @attr user_id [String, nil] Propagated to context and span attribute
+    # @attr session_id [String, nil] Propagated to context and span attribute
+    # @attr tags [Array<String>, nil] Propagated to context and span attribute
+    # @attr metadata [Hash<String, String>, nil] Propagated to context and span attributes
+    # @attr capture_request_body [Boolean, nil] Override for request body capture
+    # @attr capture_response_body [Boolean, nil] Override for response body capture
+    class TraceAttributes
+      attr_reader :trace_id, :user_id, :session_id, :tags, :metadata,
+                  :capture_request_body, :capture_response_body
+
+      def initialize(
+        trace_id: nil,
+        user_id: nil,
+        session_id: nil,
+        tags: nil,
+        metadata: nil,
+        capture_request_body: nil,
+        capture_response_body: nil
+      )
+        @trace_id = trace_id
+        @user_id = user_id
+        @session_id = session_id
+        @tags = tags
+        @metadata = metadata
+        @capture_request_body = capture_request_body
+        @capture_response_body = capture_response_body
+      end
+
+      # Create from hash
+      # @param hash [Hash, nil] Hash representation
+      # @return [TraceAttributes, nil]
+      def self.from_hash(hash)
+        return nil if hash.nil?
+        return hash if hash.is_a?(TraceAttributes)
+
+        new(
+          trace_id: hash[:trace_id] || hash['traceId'],
+          user_id: hash[:user_id] || hash['userId'],
+          session_id: hash[:session_id] || hash['sessionId'],
+          tags: hash[:tags] || hash['tags'],
+          metadata: hash[:metadata] || hash['metadata'],
+          capture_request_body: hash[:capture_request_body] || hash['captureRequestBody'],
+          capture_response_body: hash[:capture_response_body] || hash['captureResponseBody']
+        )
+      end
+    end
+
+    # Options for startTrace
+    # @attr attributes [TraceAttributes, nil] Optional attributes to set in context
+    # @attr seed [String, nil] Optional. If provided, trace ID is deterministic
+    class StartTraceOptions
+      attr_reader :attributes, :seed
+
+      def initialize(attributes: nil, seed: nil)
+        @attributes = attributes.is_a?(Hash) ? TraceAttributes.from_hash(attributes) : attributes
+        @seed = seed
+      end
+
+      # Create from hash
+      # @param hash [Hash, nil] Hash representation
+      # @return [StartTraceOptions]
+      def self.from_hash(hash)
+        return new if hash.nil?
+        return hash if hash.is_a?(StartTraceOptions)
+
+        new(
+          attributes: hash[:attributes] || hash['attributes'],
+          seed: hash[:seed] || hash['seed']
+        )
+      end
+    end
+  end
+end

data/lib/pingops/errors.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pingops
+  # Base error class for all PingOps errors
+  class Error < StandardError; end
+
+  # Raised when configuration is invalid or missing required fields
+  class ConfigurationError < Error; end
+
+  # Raised when the SDK is not initialized
+  class NotInitializedError < Error; end
+
+  # Raised when auto-initialization fails
+  class AutoInitializationError < Error; end
+end

data/lib/pingops/instrumentation/manager.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Pingops
+  module Instrumentation
+    # Manages all PingOps instrumentations
+    module Manager
+      @installed = false
+      @mutex = Mutex.new
+
+      class << self
+        # Install all instrumentations
+        # @param config [Core::Configuration] Configuration
+        def install(config)
+          @mutex.synchronize do
+            return if @installed
+
+            # Store config in global store for instrumentations
+            Otel::ConfigStore.set(config)
+
+            # Install Net::HTTP instrumentation
+            NetHttp.install
+
+            @installed = true
+            log_debug(config, 'Instrumentations installed')
+          end
+        end
+
+        # Check if instrumentations are installed
+        # @return [Boolean]
+        def installed?
+          @mutex.synchronize do
+            @installed
+          end
+        end
+
+        # Reset state (for testing)
+        def reset!
+          @mutex.synchronize do
+            @installed = false
+            Otel::ConfigStore.clear!
+            NetHttp.reset!
+          end
+        end
+
+        # Get OpenTelemetry instrumentations to register with the SDK
+        # @return [Array] Array of instrumentation instances
+        def otel_instrumentations
+          instrumentations = []
+
+          # Add Net::HTTP instrumentation
+          begin
+            require 'opentelemetry/instrumentation/net_http'
+            instrumentations << OpenTelemetry::Instrumentation::Net::HTTP::Instrumentation.instance
+          rescue LoadError
+            # Net::HTTP instrumentation not available
+          end
+
+          # Add Faraday instrumentation if available
+          begin
+            require 'opentelemetry/instrumentation/faraday'
+            instrumentations << OpenTelemetry::Instrumentation::Faraday::Instrumentation.instance
+          rescue LoadError
+            # Faraday instrumentation not available
+          end
+
+          # Add HTTP client instrumentation if available
+          begin
+            require 'opentelemetry/instrumentation/http_client'
+            instrumentations << OpenTelemetry::Instrumentation::HttpClient::Instrumentation.instance
+          rescue LoadError
+            # HTTP client instrumentation not available
+          end
+
+          instrumentations
+        end
+
+        private
+
+        def log_debug(config, message)
+          return unless config.debug
+
+          puts "[Pingops DEBUG] #{message}"
+        end
+      end
+    end
+  end
+end

data/lib/pingops/instrumentation/net_http.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module Pingops
+  module Instrumentation
+    # Net::HTTP instrumentation for capturing headers and bodies
+    # This enhances the standard OpenTelemetry Net::HTTP instrumentation
+    module NetHttp
+      class << self
+        # Install the instrumentation
+        def install
+          return if @installed
+
+          # Prepend our module to Net::HTTP
+          ::Net::HTTP.prepend(RequestPatch)
+          @installed = true
+        end
+
+        # Check if installed
+        # @return [Boolean]
+        def installed?
+          @installed || false
+        end
+
+        # Uninstall (for testing)
+        def reset!
+          @installed = false
+        end
+      end
+
+      # Patch for Net::HTTP#request
+      module RequestPatch
+        def request(req, body = nil, &block)
+          # Get current span from context
+          span = OpenTelemetry::Trace.current_span
+          return super unless span&.recording?
+
+          # Capture request headers
+          capture_request_headers(span, req)
+
+          # Capture request body if enabled
+          capture_request_body(span, body || req.body)
+
+          # Execute the request
+          response = super
+
+          # Capture response headers
+          capture_response_headers(span, response)
+
+          # Capture response body if enabled
+          capture_response_body(span, response)
+
+          response
+        end
+
+        private
+
+        def capture_request_headers(span, request)
+          request.each_header do |name, value|
+            attr_name = "#{Core::Constants::ATTR_HTTP_REQUEST_HEADER_PREFIX}#{name.downcase}"
+            span.set_attribute(attr_name, value)
+          end
+        rescue StandardError => e
+          log_debug("Error capturing request headers: #{e.message}")
+        end
+
+        def capture_response_headers(span, response)
+          response.each_header do |name, value|
+            attr_name = "#{Core::Constants::ATTR_HTTP_RESPONSE_HEADER_PREFIX}#{name.downcase}"
+            span.set_attribute(attr_name, value)
+          end
+        rescue StandardError => e
+          log_debug("Error capturing response headers: #{e.message}")
+        end
+
+        def capture_request_body(span, body)
+          return unless should_capture_request_body?
+          return if body.nil? || body.empty?
+
+          max_size = Otel::ConfigStore.max_request_body_size
+          truncated = Core::BodyCapture.truncate_body(body.to_s, max_size)
+          span.set_attribute(Core::Constants::ATTR_HTTP_REQUEST_BODY, truncated) if truncated
+        rescue StandardError => e
+          log_debug("Error capturing request body: #{e.message}")
+        end
+
+        def capture_response_body(span, response)
+          return unless should_capture_response_body?
+
+          body = read_response_body(response)
+          return if body.nil? || body.empty?
+
+          max_size = Otel::ConfigStore.max_response_body_size
+          content_encoding = response['Content-Encoding']
+
+          if Core::BodyCapture.compressed?(content_encoding)
+            encoded = Core::BodyCapture.encode_compressed_body(body, max_size)
+            if encoded
+              span.set_attribute(Core::Constants::ATTR_HTTP_RESPONSE_BODY, encoded)
+              span.set_attribute(Core::Constants::ATTR_HTTP_RESPONSE_CONTENT_ENCODING, content_encoding)
+            end
+          else
+            truncated = Core::BodyCapture.truncate_body(body, max_size)
+            span.set_attribute(Core::Constants::ATTR_HTTP_RESPONSE_BODY, truncated) if truncated
+          end
+        rescue StandardError => e
+          log_debug("Error capturing response body: #{e.message}")
+        end
+
+        def read_response_body(response)
+          # Try to get the body without consuming it
+          return unless response.respond_to?(:body)
+
+          response.body
+        end
+
+        def should_capture_request_body?
+          # Check context first
+          context = OpenTelemetry::Context.current
+          context_value = Core::ContextKeys.capture_request_body?(context)
+          return context_value unless context_value.nil?
+
+          # Fall back to global config
+          Otel::ConfigStore.capture_request_body?
+        end
+
+        def should_capture_response_body?
+          # Check context first
+          context = OpenTelemetry::Context.current
+          context_value = Core::ContextKeys.capture_response_body?(context)
+          return context_value unless context_value.nil?
+
+          # Fall back to global config
+          Otel::ConfigStore.capture_response_body?
+        end
+
+        def log_debug(message)
+          return unless Otel::ConfigStore.debug?
+
+          puts "[Pingops DEBUG] NetHttp: #{message}"
+        end
+      end
+    end
+  end
+end

data/lib/pingops/otel/config_store.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Pingops
+  module Otel
+    # Global configuration store for instrumentations
+    # Instrumentations read these settings at span creation/body capture time
+    module ConfigStore
+      @config = nil
+      @mutex = Mutex.new
+
+      class << self
+        # Set the global configuration
+        # @param config [Pingops::Core::Configuration] The configuration
+        def set(config)
+          @mutex.synchronize do
+            @config = config
+          end
+        end
+
+        # Get the global configuration
+        # @return [Pingops::Core::Configuration, nil]
+        def get
+          @mutex.synchronize do
+            @config
+          end
+        end
+
+        # Check if configuration is set
+        # @return [Boolean]
+        def set?
+          @mutex.synchronize do
+            !@config.nil?
+          end
+        end
+
+        # Clear the configuration (for testing/shutdown)
+        def clear!
+          @mutex.synchronize do
+            @config = nil
+          end
+        end
+
+        # Get capture request body setting
+        # @return [Boolean]
+        def capture_request_body?
+          @mutex.synchronize do
+            @config&.capture_request_body || false
+          end
+        end
+
+        # Get capture response body setting
+        # @return [Boolean]
+        def capture_response_body?
+          @mutex.synchronize do
+            @config&.capture_response_body || false
+          end
+        end
+
+        # Get max request body size
+        # @return [Integer]
+        def max_request_body_size
+          @mutex.synchronize do
+            @config&.max_request_body_size || Core::Constants::DEFAULT_MAX_REQUEST_BODY_SIZE
+          end
+        end
+
+        # Get max response body size
+        # @return [Integer]
+        def max_response_body_size
+          @mutex.synchronize do
+            @config&.max_response_body_size || Core::Constants::DEFAULT_MAX_RESPONSE_BODY_SIZE
+          end
+        end
+
+        # Get domain allow list
+        # @return [Array<Core::DomainRule>, nil]
+        def domain_allow_list
+          @mutex.synchronize do
+            @config&.domain_allow_list
+          end
+        end
+
+        # Get domain deny list
+        # @return [Array<Core::DomainRule>, nil]
+        def domain_deny_list
+          @mutex.synchronize do
+            @config&.domain_deny_list
+          end
+        end
+
+        # Check if debug mode is enabled
+        # @return [Boolean]
+        def debug?
+          @mutex.synchronize do
+            @config&.debug || false
+          end
+        end
+      end
+    end
+  end
+end