pingops 0.0.1

data/lib/pingops/otel/span_processor.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require 'opentelemetry-sdk'
+require 'opentelemetry/exporter/otlp'
+
+module Pingops
+  module Otel
+    # PingOps Span Processor
+    # Implements OpenTelemetry SpanProcessor interface:
+    # - onStart: copy propagated attributes from context onto span
+    # - onEnd: filter eligible spans and export via OTLP
+    class SpanProcessor
+      # @param config [Pingops::Core::Configuration] Resolved configuration
+      def initialize(config)
+        @config = config
+        @debug = config.debug
+        @underlying_processor = create_underlying_processor(config)
+        @mutex = Mutex.new
+
+        log_debug("SpanProcessor initialized with export_mode=#{config.export_mode}")
+      end
+
+      # Called when a span is started
+      # Copy propagated attributes from parent context onto the span
+      # @param span [OpenTelemetry::SDK::Trace::Span] The span being started
+      # @param parent_context [OpenTelemetry::Context] The parent context
+      def on_start(span, parent_context)
+        # Extract PingOps attributes from context and set on span
+        begin
+          attributes = Core::ContextKeys.extract_attributes(parent_context)
+          attributes.each do |key, value|
+            next if value.nil?
+
+            if value.is_a?(Array)
+              span.set_attribute(key, value)
+            else
+              span.set_attribute(key, value.to_s)
+            end
+          end
+        rescue StandardError => e
+          log_debug("Error in on_start: #{e.message}")
+        end
+
+        # Delegate to underlying processor
+        @underlying_processor.on_start(span, parent_context)
+      end
+
+      # Called when a span ends
+      # Check eligibility, apply filters, and export
+      # @param span [OpenTelemetry::SDK::Trace::Span] The span that ended
+      def on_end(span)
+        # Step 1: Check eligibility (CLIENT kind + HTTP attributes)
+        unless Core::SpanEligibility.eligible?(span)
+          log_debug("Span not eligible: kind=#{span.kind}, name=#{span.name}")
+          return
+        end
+
+        # Step 2: Extract URL and check domain filter
+        attributes = span.attributes || {}
+        url = Core::DomainFilter.extract_url(attributes)
+
+        if url && !url.empty?
+          result = Core::DomainFilter.check(
+            url,
+            allow_list: @config.domain_allow_list,
+            deny_list: @config.domain_deny_list
+          )
+
+          if result.denied?
+            log_debug("Span denied by domain filter: url=#{url}")
+            return
+          end
+        end
+
+        # Step 3: Create filtered span with header/body filtering applied
+        filtered_span = create_filtered_span(span, url)
+
+        # Step 4: Pass to underlying processor for export
+        @underlying_processor.on_end(filtered_span)
+      rescue StandardError => e
+        log_debug("Error in on_end: #{e.message}\n#{e.backtrace&.first(5)&.join("\n")}")
+      end
+
+      # Force flush any pending spans
+      # @param timeout [Numeric, nil] Optional timeout in seconds
+      # @return [Integer] Export result code
+      def force_flush(timeout: nil)
+        @underlying_processor.force_flush(timeout: timeout)
+      end
+
+      # Shut down the processor
+      # @param timeout [Numeric, nil] Optional timeout in seconds
+      # @return [Integer] Export result code
+      def shutdown(timeout: nil)
+        @underlying_processor.shutdown(timeout: timeout)
+      end
+
+      # Alias for on_end (OpenTelemetry SDK compatibility)
+      alias on_finish on_end
+
+      private
+
+      def create_underlying_processor(config)
+        exporter = create_exporter(config)
+
+        if config.export_mode == Core::Constants::EXPORT_MODE_IMMEDIATE
+          OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(exporter)
+        else
+          OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
+            exporter,
+            max_export_batch_size: config.batch_size,
+            schedule_delay: config.batch_timeout
+          )
+        end
+      end
+
+      def create_exporter(config)
+        endpoint = "#{config.base_url}/v1/traces"
+
+        headers = {
+          'Content-Type' => 'application/json'
+        }
+
+        headers['Authorization'] = "Bearer #{config.api_key}" if config.api_key && !config.api_key.empty?
+
+        OpenTelemetry::Exporter::OTLP::Exporter.new(
+          endpoint: endpoint,
+          headers: headers,
+          timeout: Core::Constants::DEFAULT_EXPORT_TIMEOUT / 1000.0
+        )
+      end
+
+      def create_filtered_span(span, url)
+        # Find matching domain rule for header/body overrides
+        domain_rule = Core::DomainFilter.find_matching_rule(url, @config.domain_allow_list)
+
+        # Get current context for body capture settings
+        context = OpenTelemetry::Context.current
+
+        # Determine header filtering settings
+        headers_allow = domain_rule&.headers_allow_list || @config.headers_allow_list
+        headers_deny = domain_rule&.headers_deny_list || @config.headers_deny_list
+
+        # Filter span attributes (headers)
+        filtered_attributes = Core::HeaderFilter.filter_span_attributes(
+          span.attributes || {},
+          allow_list: headers_allow,
+          deny_list: headers_deny,
+          redaction_config: @config.header_redaction
+        )
+
+        # Filter body attributes
+        capture_request = Core::BodyCapture.should_capture_request_body?(
+          context, domain_rule, @config
+        )
+        capture_response = Core::BodyCapture.should_capture_response_body?(
+          context, domain_rule, @config
+        )
+
+        filtered_attributes = Core::BodyCapture.filter_body_attributes(
+          filtered_attributes,
+          capture_request: capture_request,
+          capture_response: capture_response
+        )
+
+        # Create a wrapper that presents filtered attributes
+        FilteredSpan.new(span, filtered_attributes)
+      end
+
+      def log_debug(message)
+        return unless @debug
+
+        puts "[Pingops DEBUG] #{message}"
+      end
+    end
+
+    # Wrapper for a span with filtered attributes
+    # Delegates all methods to the underlying span except attributes
+    class FilteredSpan
+      def initialize(span, filtered_attributes)
+        @span = span
+        @filtered_attributes = filtered_attributes
+      end
+
+      def attributes
+        @filtered_attributes
+      end
+
+      # Delegate all other methods to the underlying span
+      def method_missing(method, ...)
+        @span.send(method, ...)
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        @span.respond_to?(method, include_private)
+      end
+
+      # Explicitly delegate common span methods for better performance
+      def name
+        @span.name
+      end
+
+      def kind
+        @span.kind
+      end
+
+      def status
+        @span.status
+      end
+
+      def parent_span_id
+        @span.parent_span_id
+      end
+
+      def start_timestamp
+        @span.start_timestamp
+      end
+
+      def end_timestamp
+        @span.end_timestamp
+      end
+
+      def links
+        @span.links
+      end
+
+      def events
+        @span.events
+      end
+
+      def resource
+        @span.resource
+      end
+
+      def instrumentation_scope
+        @span.instrumentation_scope
+      end
+
+      def instrumentation_library
+        @span.instrumentation_library
+      end
+
+      def span_context
+        @span.span_context
+      end
+
+      def trace_id
+        @span.trace_id
+      end
+
+      def span_id
+        @span.span_id
+      end
+
+      def trace_flags
+        @span.trace_flags
+      end
+
+      def tracestate
+        @span.tracestate
+      end
+
+      def to_span_data
+        # For OTLP export, we need to return span data with filtered attributes
+        if @span.respond_to?(:to_span_data)
+          span_data = @span.to_span_data
+          # The OTLP exporter uses span_data, so we need to ensure our filtered
+          # attributes are used. SpanData is immutable, so we create a new one.
+          OpenTelemetry::SDK::Trace::SpanData.new(
+            span_data.name,
+            span_data.kind,
+            span_data.status,
+            span_data.parent_span_id,
+            span_data.total_recorded_attributes,
+            span_data.total_recorded_events,
+            span_data.total_recorded_links,
+            span_data.start_timestamp,
+            span_data.end_timestamp,
+            @filtered_attributes,
+            span_data.links,
+            span_data.events,
+            span_data.resource,
+            span_data.instrumentation_scope,
+            span_data.span_context,
+            span_data.tracestate
+          )
+        else
+          @span
+        end
+      end
+    end
+  end
+end

data/lib/pingops/otel/tracer_provider.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'opentelemetry-sdk'
+
+module Pingops
+  module Otel
+    # Tracer Provider management for PingOps
+    # Manages the isolated TracerProvider that is registered globally
+    module TracerProvider
+      @provider = nil
+      @mutex = Mutex.new
+
+      class << self
+        # Set the PingOps TracerProvider
+        # @param provider [OpenTelemetry::SDK::Trace::TracerProvider, nil] The provider to set
+        def set(provider)
+          @mutex.synchronize do
+            @provider = provider
+          end
+        end
+
+        # Get the PingOps TracerProvider
+        # @return [OpenTelemetry::SDK::Trace::TracerProvider] The stored provider or global provider
+        def get
+          @mutex.synchronize do
+            @provider || OpenTelemetry.tracer_provider
+          end
+        end
+
+        # Get a tracer from the PingOps TracerProvider
+        # @param name [String] Tracer name (default: "pingops-sdk")
+        # @param version [String] Tracer version (default: "0.0.1")
+        # @return [OpenTelemetry::Trace::Tracer]
+        def tracer(name: Core::Constants::TRACER_NAME, version: Core::Constants::TRACER_VERSION)
+          get.tracer(name, version)
+        end
+
+        # Create an isolated TracerProvider with the given resource and span processor
+        # @param resource [OpenTelemetry::SDK::Resources::Resource] The resource
+        # @param span_processor [Pingops::Otel::SpanProcessor] The span processor
+        # @return [OpenTelemetry::SDK::Trace::TracerProvider]
+        def create_isolated(resource:, span_processor:)
+          provider = OpenTelemetry::SDK::Trace::TracerProvider.new(resource: resource)
+          provider.add_span_processor(span_processor)
+          provider
+        end
+
+        # Shutdown the stored TracerProvider
+        # @param timeout [Numeric, nil] Optional timeout in seconds
+        # @return [void]
+        def shutdown(timeout: nil)
+          @mutex.synchronize do
+            return unless @provider
+
+            @provider.shutdown(timeout: timeout) if @provider.respond_to?(:shutdown)
+            @provider = nil
+          end
+        end
+
+        # Force flush the stored TracerProvider
+        # @param timeout [Numeric, nil] Optional timeout in seconds
+        # @return [Integer] Export result code
+        def force_flush(timeout: nil)
+          @mutex.synchronize do
+            return OpenTelemetry::SDK::Trace::Export::SUCCESS unless @provider
+
+            if @provider.respond_to?(:force_flush)
+              @provider.force_flush(timeout: timeout)
+            else
+              OpenTelemetry::SDK::Trace::Export::SUCCESS
+            end
+          end
+        end
+
+        # Check if a provider is set
+        # @return [Boolean]
+        def set?
+          @mutex.synchronize do
+            !@provider.nil?
+          end
+        end
+
+        # Clear the stored provider (for testing)
+        # @return [void]
+        def clear!
+          @mutex.synchronize do
+            @provider = nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pingops/register.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Register entry point for auto-initialization
+# Usage: ruby -r pingops/register your_app.rb
+# Or: require "pingops/register" at the top of your application
+
+require_relative '../pingops'
+
+# Auto-initialize from environment and/or config file
+module Pingops
+  module Register
+    class << self
+      def auto_initialize
+        config_file = ENV.fetch('PINGOPS_CONFIG_FILE', nil)
+
+        config = if config_file && File.exist?(config_file)
+                   # Load from file and merge with env
+                   Core::Configuration.load_with_env(config_file)
+                 else
+                   # Use env only
+                   Core::Configuration.from_env
+                 end
+
+        # Only initialize if we have required fields
+        if config.base_url && config.service_name
+          Pingops.initialize(config)
+          log_debug('Auto-initialized PingOps SDK')
+        else
+          log_debug('Skipping auto-init: missing baseUrl or serviceName')
+        end
+      rescue StandardError => e
+        # Don't crash the application on auto-init failure
+        warn "[Pingops] Auto-initialization failed: #{e.message}"
+      end
+
+      private
+
+      def log_debug(message)
+        return unless ENV.fetch('PINGOPS_DEBUG', nil) == 'true'
+
+        puts "[Pingops DEBUG] #{message}"
+      end
+    end
+  end
+end
+
+# Run auto-initialization when this file is required
+Pingops::Register.auto_initialize