lapsoss 0.4.10 → 0.4.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76c4609d94f1d9463922da6d1850b7b618977075dd0d96fa7d94d58186cd64b9
-  data.tar.gz: 8d5db54e63ef1e6a0d73962261bd13ce4cfca305c63570bf879c4dbf85bb3110
+  metadata.gz: a4370921854bb3be19bd9209a54da4a763833386b0ef917c6ec5a632a2941db9
+  data.tar.gz: 7df3efd16d2b889561b94a76c2d8ed7b7e764ca6b2a5b45e3edf510b58bcf8bc
 SHA512:
-  metadata.gz: ac8bc565e2d54b1c3f600de8b2a6fedc0e2da481ce3c9003c587b81bd4134209618ba77dd3ae1019188537217c09c2f8317640ea36d46b91a229116eeaafd032
-  data.tar.gz: eee117f27719db7cfe019466cfbe5ec1210e86c0cfb0a7bff6764984acb148fb2233dd0c84fb7029e0e643e38f2147989f41172035a41dbd79a35eecad79763f
+  metadata.gz: 23f1efbcc3d5fb6cceb32f9d7794f1ce8943dfe51696b42c95c2bdc257acb0a6770c0470d2d72729f45e9beb7919948c46dea8db6bfb903381466c7dfd2ab771
+  data.tar.gz: 3fd7dbd3eca37712e7eec4fa9908939b797805d779d62f242c6c6e30f1ca7baeeb49470f1a1f7a1cd97f5d3d0320ecd116048870a2bb4d530380bcfd716243e5

data/README.md

@@ -220,6 +220,8 @@ All adapters are pure Ruby implementations with no external SDK dependencies:
 - **AppSignal** - Error tracking and deploy markers
 - **Insight Hub** (formerly Bugsnag) - Error tracking with breadcrumbs
 - **Telebugs** - Sentry-compatible protocol (perfect for self-hosted alternatives)
+- **OpenObserve** - Open-source observability platform (logs, metrics, traces)
+- **OTLP** - OpenTelemetry Protocol (works with SigNoz, Jaeger, Tempo, Honeycomb, etc.)
 
 ## Configuration
 
@@ -254,6 +256,39 @@ Lapsoss.configure do |config|
 end
 ```
 
+### Using OpenObserve
+
+```ruby
+# OpenObserve - open-source observability platform
+Lapsoss.configure do |config|
+  config.use_openobserve(
+    endpoint: ENV['OPENOBSERVE_ENDPOINT'],  # e.g., "http://localhost:5080"
+    username: ENV['OPENOBSERVE_USERNAME'],
+    password: ENV['OPENOBSERVE_PASSWORD'],
+    org: "default",      # optional, defaults to "default"
+    stream: "errors"     # optional, defaults to "errors"
+  )
+end
+```
+
+### Using OTLP (OpenTelemetry Protocol)
+
+```ruby
+# Works with SigNoz, Jaeger, Tempo, Honeycomb, Datadog, etc.
+Lapsoss.configure do |config|
+  config.use_otlp(
+    endpoint: ENV['OTLP_ENDPOINT'],     # e.g., "http://localhost:4318"
+    service_name: "my-rails-app",
+    headers: { "X-Custom-Header" => "value" }  # optional custom headers
+  )
+
+  # Or use convenience helpers for specific services
+  config.use_signoz(signoz_api_key: ENV['SIGNOZ_API_KEY'])
+  config.use_jaeger(endpoint: "http://jaeger:4318")
+  config.use_tempo(endpoint: "http://tempo:4318")
+end
+```
+
 ### Advanced Configuration
 
 ```ruby
@@ -276,6 +311,22 @@ Lapsoss.configure do |config|
 end
 ```
 
+### Pipeline & Sampling (optional)
+
+```ruby
+Lapsoss.configure do |config|
+  # Build a middleware pipeline for every event
+  config.configure_pipeline do |pipeline|
+    pipeline.sample(rate: 0.1) # Drop 90% of events
+
+    pipeline.enhance_user_context(
+      provider: ->(event, _) { current_user&.slice(:id, :email) },
+      privacy_mode: true # keep only ids
+    )
+  end
+end
+```
+
 ### Filtering Errors
 
 You decide what errors to track. Lapsoss doesn't make assumptions:
@@ -351,6 +402,30 @@ Rails.application.config.filter_parameters += [:password, :token]
 # Lapsoss automatically uses these filters - no additional configuration needed!
 ```
 
+Additional controls:
+
+```ruby
+Lapsoss.configure do |config|
+  config.scrub_fields = %w[credit_card ssn api_key]
+  config.scrub_all = true                        # Mask everything by default
+  config.whitelist_fields = %w[user_id request_id] # Keep these fields as-is
+  config.randomize_scrub_length = true           # Avoid fixed "[FILTERED]" marker
+end
+```
+
+### Error Handler Hook
+
+Get a callback when an adapter fails to deliver:
+
+```ruby
+Lapsoss.configure do |config|
+  config.error_handler = lambda do |adapter, event, error|
+    Rails.logger.error("Delivery failed for #{adapter.name}: #{error.message}")
+    Rails.logger.error(event.to_h) if Rails.env.development?
+  end
+end
+```
+
 ### Custom Fingerprinting
 
 Control how errors are grouped:

data/lib/lapsoss/adapters/concerns/http_delivery.rb

@@ -12,8 +12,8 @@ module Lapsoss
         extend ActiveSupport::Concern
 
         included do
-          class_attribute :api_endpoint, instance_writer: false
-          class_attribute :api_path, default: "/", instance_writer: false
+          # Instance-level endpoint configuration for adapter isolation
+          attr_reader :api_endpoint, :api_path
 
           # Memoized git info using AS
           mattr_accessor :git_info_cache, default: {}
@@ -39,7 +39,7 @@ module Lapsoss
             handle_response(response)
           end
         rescue => error
-          handle_delivery_error(error)
+          handle_delivery_error(error, event)
         end
 
         # Common headers for all adapters
@@ -101,7 +101,7 @@ module Lapsoss
           raise DeliveryError.new("Client error: #{message}", response: response)
         end
 
-        def handle_delivery_error(error)
+        def handle_delivery_error(error, event = nil)
           ActiveSupport::Notifications.instrument("error.lapsoss",
             adapter: self.class.name,
             error: error.class.name,
@@ -109,10 +109,22 @@ module Lapsoss
           )
 
           Lapsoss.configuration.logger&.error("[#{self.class.name}] Delivery failed: #{error.message}")
-          Lapsoss.configuration.error_handler&.call(error)
+          Lapsoss.call_error_handler(adapter: self, event: event, error: error)
+          mark_error_handled(error)
 
-          raise error if error.is_a?(DeliveryError)
-          raise DeliveryError.new("Delivery failed: #{error.message}", cause: error)
+          if error.is_a?(DeliveryError)
+            raise error
+          else
+            delivery_error = DeliveryError.new("Delivery failed: #{error.message}", cause: error)
+            mark_error_handled(delivery_error)
+            raise delivery_error
+          end
+        end
+
+        def mark_error_handled(error)
+          error.instance_variable_set(:@lapsoss_error_handled, true)
+        rescue StandardError
+          # If setting the flag fails, we still continue
         end
 
         private

data/lib/lapsoss/adapters/concerns/level_mapping.rb

@@ -44,6 +44,16 @@ module Lapsoss
             error: "error",
             fatal: "error",
             critical: "error"
+          }.with_indifferent_access,
+
+          openobserve: {
+            debug: "DEBUG",
+            info: "INFO",
+            warning: "WARN",
+            warn: "WARN",
+            error: "ERROR",
+            fatal: "FATAL",
+            critical: "FATAL"
           }.with_indifferent_access
         }.freeze
 

data/lib/lapsoss/adapters/concerns/stacktrace_builder.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/core_ext/object/blank"
+
+module Lapsoss
+  module Adapters
+    module Concerns
+      # Shared stacktrace building logic for adapters
+      # Provides consistent frame formatting across Sentry, OpenObserve, OTLP, etc.
+      module StacktraceBuilder
+        extend ActiveSupport::Concern
+
+        # Build frames from event backtrace
+        # @param event [Lapsoss::Event] The event with backtrace_frames
+        # @param reverse [Boolean] Reverse frame order (Sentry expects oldest-to-newest)
+        # @return [Array<Hash>] Array of formatted frame hashes
+        def build_frames(event, reverse: false)
+          return [] unless event.has_backtrace?
+
+          frames = event.backtrace_frames.map { |frame| build_frame(frame) }
+          reverse ? frames.reverse : frames
+        end
+
+        # Build a single frame hash from a BacktraceFrame
+        # @param frame [Lapsoss::BacktraceFrame] The frame to format
+        # @return [Hash] Formatted frame hash
+        def build_frame(frame)
+          frame_hash = {
+            filename: frame.filename,
+            abs_path: frame.absolute_path || frame.filename,
+            function: frame.method_name || frame.function,
+            lineno: frame.line_number,
+            in_app: frame.in_app
+          }
+
+          add_code_context(frame_hash, frame) if frame.code_context.present?
+
+          frame_hash.compact
+        end
+
+        # Build raw stacktrace string for logging/simple formats
+        # @param event [Lapsoss::Event] The event with backtrace_frames
+        # @return [Array<String>] Array of formatted frame strings
+        def build_raw_stacktrace(event)
+          return [] unless event.has_backtrace?
+
+          event.backtrace_frames.map do |frame|
+            "#{frame.absolute_path || frame.filename}:#{frame.line_number} in `#{frame.method_name}`"
+          end
+        end
+
+        # Build stacktrace as single string (for OTLP exception.stacktrace)
+        # @param event [Lapsoss::Event] The event with backtrace_frames
+        # @return [String] Newline-separated stacktrace
+        def build_stacktrace_string(event)
+          build_raw_stacktrace(event).join("\n")
+        end
+
+        private
+
+        def add_code_context(frame_hash, frame)
+          frame_hash[:pre_context] = frame.code_context[:pre_context]
+          frame_hash[:context_line] = frame.code_context[:context_line]
+          frame_hash[:post_context] = frame.code_context[:post_context]
+        end
+      end
+    end
+  end
+end

data/lib/lapsoss/adapters/concerns/trace_context.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "securerandom"
+
+module Lapsoss
+  module Adapters
+    module Concerns
+      # Trace context utilities for OTLP and distributed tracing
+      # Provides trace/span ID generation and timestamp formatting
+      module TraceContext
+        extend ActiveSupport::Concern
+
+        # Generate a W3C Trace Context compliant trace ID (32 hex chars = 128 bits)
+        # @return [String] 32 character hex string
+        def generate_trace_id
+          SecureRandom.hex(16)
+        end
+
+        # Generate a W3C Trace Context compliant span ID (16 hex chars = 64 bits)
+        # @return [String] 16 character hex string
+        def generate_span_id
+          SecureRandom.hex(8)
+        end
+
+        # Convert time to nanoseconds since Unix epoch (OTLP format)
+        # @param time [Time] The time to convert
+        # @return [Integer] Nanoseconds since Unix epoch
+        def timestamp_nanos(time)
+          time ||= Time.current
+          (time.to_f * 1_000_000_000).to_i
+        end
+
+        # Convert time to microseconds since Unix epoch (OpenObserve format)
+        # @param time [Time] The time to convert
+        # @return [Integer] Microseconds since Unix epoch
+        def timestamp_micros(time)
+          time ||= Time.current
+          (time.to_f * 1_000_000).to_i
+        end
+
+        # Convert time to milliseconds since Unix epoch
+        # @param time [Time] The time to convert
+        # @return [Integer] Milliseconds since Unix epoch
+        def timestamp_millis(time)
+          time ||= Time.current
+          (time.to_f * 1_000).to_i
+        end
+      end
+    end
+  end
+end

data/lib/lapsoss/adapters/openobserve_adapter.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+require "base64"
+
+module Lapsoss
+  module Adapters
+    # OpenObserve adapter - sends errors as structured JSON logs
+    # OpenObserve is an observability platform that accepts logs via simple JSON API
+    # Docs: https://openobserve.ai/docs/ingestion/
+    class OpenobserveAdapter < Base
+      include Concerns::LevelMapping
+      include Concerns::HttpDelivery
+
+      self.level_mapping_type = :openobserve
+
+      DEFAULT_STREAM = "errors"
+      DEFAULT_ORG = "default"
+
+      def initialize(name, settings = {})
+        super
+
+        @endpoint = settings[:endpoint].presence || ENV["OPENOBSERVE_ENDPOINT"]
+        @username = settings[:username].presence || ENV["OPENOBSERVE_USERNAME"]
+        @password = settings[:password].presence || ENV["OPENOBSERVE_PASSWORD"]
+        @org = settings[:org].presence || ENV["OPENOBSERVE_ORG"] || DEFAULT_ORG
+        @stream = settings[:stream].presence || ENV["OPENOBSERVE_STREAM"] || DEFAULT_STREAM
+
+        if @endpoint.blank? || @username.blank? || @password.blank?
+          Lapsoss.configuration.logger&.warn "[Lapsoss::OpenobserveAdapter] Missing endpoint, username or password - adapter disabled"
+          @enabled = false
+          return
+        end
+
+        setup_endpoint
+      end
+
+      def capture(event)
+        deliver(event.scrubbed)
+      end
+
+      def capabilities
+        super.merge(
+          breadcrumbs: false,
+          code_context: true,
+          data_scrubbing: true
+        )
+      end
+
+      private
+
+      def setup_endpoint
+        uri = URI.parse(@endpoint)
+        @api_endpoint = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+        @api_path = "/api/#{@org}/#{@stream}/_json"
+      end
+
+      def build_payload(event)
+        # OpenObserve expects JSON array of log entries
+        [ build_log_entry(event) ]
+      end
+
+      def build_log_entry(event)
+        entry = {
+          _timestamp: timestamp_microseconds(event.timestamp),
+          level: map_level(event.level),
+          logger: "lapsoss",
+          environment: event.environment.presence || "production",
+          service: @settings[:service_name].presence || "rails"
+        }
+
+        case event.type
+        when :exception
+          entry.merge!(build_exception_entry(event))
+        when :message
+          entry[:message] = event.message
+        else
+          entry[:message] = event.message || "Unknown event"
+        end
+
+        # Add optional context
+        entry[:user] = event.user_context if event.user_context.present?
+        entry[:tags] = event.tags if event.tags.present?
+        entry[:extra] = event.extra if event.extra.present?
+        entry[:request] = event.request_context if event.request_context.present?
+        entry[:transaction] = event.transaction if event.transaction.present?
+        entry[:fingerprint] = event.fingerprint if event.fingerprint.present?
+
+        entry.compact_blank
+      end
+
+      def build_exception_entry(event)
+        entry = {
+          message: "#{event.exception_type}: #{event.exception_message}",
+          exception_type: event.exception_type,
+          exception_message: event.exception_message
+        }
+
+        if event.has_backtrace?
+          entry[:stacktrace] = format_stacktrace(event)
+          entry[:stacktrace_raw] = event.backtrace_frames.map do |frame|
+            "#{frame.absolute_path || frame.filename}:#{frame.line_number} in `#{frame.method_name}`"
+          end
+        end
+
+        entry
+      end
+
+      def format_stacktrace(event)
+        event.backtrace_frames.map do |frame|
+          frame_entry = {
+            filename: frame.filename,
+            abs_path: frame.absolute_path || frame.filename,
+            function: frame.method_name || frame.function,
+            lineno: frame.line_number,
+            in_app: frame.in_app
+          }
+
+          if frame.code_context.present?
+            frame_entry[:context_line] = frame.code_context[:context_line]
+            frame_entry[:pre_context] = frame.code_context[:pre_context]
+            frame_entry[:post_context] = frame.code_context[:post_context]
+          end
+
+          frame_entry.compact
+        end
+      end
+
+      def timestamp_microseconds(time)
+        # OpenObserve expects _timestamp in microseconds
+        (time.to_f * 1_000_000).to_i
+      end
+
+      def serialize_payload(payload)
+        json = ActiveSupport::JSON.encode(payload)
+
+        if json.bytesize >= compress_threshold
+          [ ActiveSupport::Gzip.compress(json), true ]
+        else
+          [ json, false ]
+        end
+      end
+
+      def compress_threshold
+        @settings[:compress_threshold] || 1024
+      end
+
+      def adapter_specific_headers
+        credentials = Base64.strict_encode64("#{@username}:#{@password}")
+        {
+          "Authorization" => "Basic #{credentials}"
+        }
+      end
+    end
+  end
+end

data/lib/lapsoss/adapters/otlp_adapter.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+
+module Lapsoss
+  module Adapters
+    # OTLP adapter - sends errors via OpenTelemetry Protocol
+    # Works with any OTLP-compatible backend: SigNoz, Jaeger, Tempo, Honeycomb, etc.
+    # Docs: https://opentelemetry.io/docs/specs/otlp/
+    class OtlpAdapter < Base
+      include Concerns::HttpDelivery
+      include Concerns::StacktraceBuilder
+      include Concerns::TraceContext
+      include Concerns::EnvelopeBuilder
+
+      # OTLP status codes
+      STATUS_CODE_UNSET = 0
+      STATUS_CODE_OK = 1
+      STATUS_CODE_ERROR = 2
+
+      # OTLP span kinds
+      SPAN_KIND_INTERNAL = 1
+
+      DEFAULT_ENDPOINT = "http://localhost:4318"
+
+      def initialize(name, settings = {})
+        super
+
+        @endpoint = settings[:endpoint].presence || ENV["OTLP_ENDPOINT"] || DEFAULT_ENDPOINT
+        @headers = settings[:headers] || {}
+        @service_name = settings[:service_name].presence || ENV["OTEL_SERVICE_NAME"] || "rails"
+        @environment = settings[:environment].presence || ENV["OTEL_ENVIRONMENT"] || "production"
+
+        # Support common auth patterns
+        if (api_key = settings[:api_key].presence || ENV["OTLP_API_KEY"])
+          @headers["Authorization"] = "Bearer #{api_key}"
+        end
+
+        if (signoz_key = settings[:signoz_api_key].presence || ENV["SIGNOZ_API_KEY"])
+          @headers["signoz-access-token"] = signoz_key
+        end
+
+        setup_endpoint
+      end
+
+      def capture(event)
+        deliver(event.scrubbed)
+      end
+
+      def capabilities
+        super.merge(
+          breadcrumbs: false,
+          code_context: true,
+          data_scrubbing: true
+        )
+      end
+
+      private
+
+      def setup_endpoint
+        uri = URI.parse(@endpoint)
+        @api_endpoint = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+        @api_path = "/v1/traces"
+      end
+
+      def build_payload(event)
+        {
+          resourceSpans: [ build_resource_spans(event) ]
+        }
+      end
+
+      def build_resource_spans(event)
+        {
+          resource: build_resource(event),
+          scopeSpans: [ build_scope_spans(event) ]
+        }
+      end
+
+      def build_resource(event)
+        attributes = [
+          { key: "service.name", value: { stringValue: @service_name } },
+          { key: "deployment.environment", value: { stringValue: event.environment.presence || @environment } },
+          { key: "telemetry.sdk.name", value: { stringValue: "lapsoss" } },
+          { key: "telemetry.sdk.version", value: { stringValue: Lapsoss::VERSION } },
+          { key: "telemetry.sdk.language", value: { stringValue: "ruby" } }
+        ]
+
+        # Add user context as resource attributes if available
+        if event.user_context.present?
+          event.user_context.each do |key, value|
+            attributes << { key: "user.#{key}", value: attribute_value(value) }
+          end
+        end
+
+        { attributes: attributes }
+      end
+
+      def build_scope_spans(event)
+        {
+          scope: {
+            name: "lapsoss",
+            version: Lapsoss::VERSION
+          },
+          spans: [ build_span(event) ]
+        }
+      end
+
+      def build_span(event)
+        now = timestamp_nanos(event.timestamp)
+        span_name = event.type == :exception ? event.exception_type : "message"
+
+        span = {
+          traceId: generate_trace_id,
+          spanId: generate_span_id,
+          name: span_name,
+          kind: SPAN_KIND_INTERNAL,
+          startTimeUnixNano: now.to_s,
+          endTimeUnixNano: now.to_s,
+          status: build_status(event),
+          attributes: build_span_attributes(event)
+        }
+
+        # Add exception event for exception types
+        if event.type == :exception
+          span[:events] = [ build_exception_event(event) ]
+        end
+
+        span
+      end
+
+      def build_status(event)
+        if event.type == :exception || event.level == :error || event.level == :fatal
+          { code: STATUS_CODE_ERROR, message: event.exception_message || event.message || "Error" }
+        else
+          { code: STATUS_CODE_OK }
+        end
+      end
+
+      def build_span_attributes(event)
+        attributes = []
+
+        # Add tags
+        event.tags&.each do |key, value|
+          attributes << { key: key.to_s, value: attribute_value(value) }
+        end
+
+        # Add extra data
+        event.extra&.each do |key, value|
+          attributes << { key: "extra.#{key}", value: attribute_value(value) }
+        end
+
+        # Add request context
+        if event.request_context.present?
+          event.request_context.each do |key, value|
+            attributes << { key: "http.#{key}", value: attribute_value(value) }
+          end
+        end
+
+        # Add transaction name
+        if event.transaction.present?
+          attributes << { key: "transaction.name", value: { stringValue: event.transaction } }
+        end
+
+        # Add fingerprint
+        if event.fingerprint.present?
+          attributes << { key: "error.fingerprint", value: { stringValue: event.fingerprint } }
+        end
+
+        # Add message for message events
+        if event.type == :message && event.message.present?
+          attributes << { key: "message", value: { stringValue: event.message } }
+        end
+
+        attributes
+      end
+
+      def build_exception_event(event)
+        attributes = [
+          { key: "exception.type", value: { stringValue: event.exception_type } },
+          { key: "exception.message", value: { stringValue: event.exception_message } }
+        ]
+
+        # Add stacktrace
+        if event.has_backtrace?
+          attributes << {
+            key: "exception.stacktrace",
+            value: { stringValue: build_stacktrace_string(event) }
+          }
+        end
+
+        {
+          name: "exception",
+          timeUnixNano: timestamp_nanos(event.timestamp).to_s,
+          attributes: attributes
+        }
+      end
+
+      # Convert Ruby value to OTLP attribute value
+      def attribute_value(value)
+        case value
+        when String
+          { stringValue: value }
+        when Integer
+          { intValue: value.to_s }
+        when Float
+          { doubleValue: value }
+        when TrueClass, FalseClass
+          { boolValue: value }
+        when Array
+          { arrayValue: { values: value.map { |v| attribute_value(v) } } }
+        else
+          { stringValue: value.to_s }
+        end
+      end
+
+      def serialize_payload(payload)
+        json = ActiveSupport::JSON.encode(payload)
+
+        if json.bytesize >= compress_threshold
+          [ ActiveSupport::Gzip.compress(json), true ]
+        else
+          [ json, false ]
+        end
+      end
+
+      def adapter_specific_headers
+        @headers.dup
+      end
+    end
+  end
+end

data/lib/lapsoss/adapters/rollbar_adapter.rb

@@ -11,11 +11,13 @@ module Lapsoss
       include Concerns::HttpDelivery
 
       self.level_mapping_type = :rollbar
-      self.api_endpoint = "https://api.rollbar.com"
-      self.api_path = "/api/1/item/"
+      DEFAULT_API_ENDPOINT = "https://api.rollbar.com"
+      DEFAULT_API_PATH = "/api/1/item/"
 
       def initialize(name, settings = {})
         super
+        @api_endpoint = DEFAULT_API_ENDPOINT
+        @api_path = DEFAULT_API_PATH
         @access_token = settings[:access_token].presence || ENV["ROLLBAR_ACCESS_TOKEN"]
 
         if @access_token.blank?

data/lib/lapsoss/adapters/sentry_adapter.rb

@@ -47,8 +47,8 @@ module Lapsoss
 
       def setup_endpoint
         uri = URI.parse(@settings[:dsn])
-        self.class.api_endpoint = "#{uri.scheme}://#{uri.host}:#{uri.port}"
-        self.class.api_path = build_api_path(uri)
+        @api_endpoint = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+        @api_path = build_api_path(uri)
       end
 
       def build_api_path(uri)

data/lib/lapsoss/adapters/telebugs_adapter.rb

@@ -53,8 +53,8 @@ module Lapsoss
         debug_log "[TELEBUGS ENDPOINT] Setting endpoint: #{endpoint}"
         debug_log "[TELEBUGS ENDPOINT] Setting API path: #{api_path}"
 
-        self.class.api_endpoint = endpoint
-        self.class.api_path = api_path
+        @api_endpoint = endpoint
+        @api_path = api_path
       end
 
       public
@@ -63,8 +63,8 @@ module Lapsoss
       def capture(event)
         debug_log "[TELEBUGS DEBUG] Capture called for event: #{event.type}"
         debug_log "[TELEBUGS DEBUG] DSN configured: #{@dsn.inspect}"
-        debug_log "[TELEBUGS DEBUG] Endpoint: #{self.class.api_endpoint}"
-        debug_log "[TELEBUGS DEBUG] API Path: #{self.class.api_path}"
+        debug_log "[TELEBUGS DEBUG] Endpoint: #{@api_endpoint}"
+        debug_log "[TELEBUGS DEBUG] API Path: #{@api_path}"
 
         result = super(event)
         debug_log "[TELEBUGS DEBUG] Event sent successfully, response: #{result.inspect}"

data/lib/lapsoss/client.rb

@@ -10,15 +10,16 @@ module Lapsoss
       # The Concurrent::FixedThreadPool had issues in Rails development mode
     end
 
-    def capture_exception(exception, **context)
+    def capture_exception(exception, level: :error, **context)
       return nil unless @configuration.enabled
 
+      extra_context = context.delete(:context)
       with_scope(context) do |scope|
         event = Event.build(
           type: :exception,
-          level: :error,
+          level: level,
           exception: exception,
-          context: scope_to_context(scope),
+          context: merge_context(scope_to_context(scope), extra_context),
           transaction: scope.transaction_name
         )
         capture_event(event)
@@ -28,12 +29,13 @@ module Lapsoss
     def capture_message(message, level: :info, **context)
       return nil unless @configuration.enabled
 
+      extra_context = context.delete(:context)
       with_scope(context) do |scope|
         event = Event.build(
           type: :message,
           level: level,
           message: message,
-          context: scope_to_context(scope),
+          context: merge_context(scope_to_context(scope), extra_context),
           transaction: scope.transaction_name
         )
         capture_event(event)
@@ -86,6 +88,11 @@ module Lapsoss
         return nil unless event
       end
 
+      if (filter = @configuration.exclusion_filter) && filter.should_exclude?(event)
+        @configuration.logger.debug("[LAPSOSS] Event excluded by configured exclusion_filter")
+        return nil
+      end
+
       event = run_before_send(event)
       return nil unless event
 
@@ -121,12 +128,23 @@ module Lapsoss
     end
 
     def scope_to_context(scope)
+      defaults = @configuration.default_context
       {
-        tags: scope.tags,
-        user: scope.user,
-        extra: scope.extra,
+        tags: (defaults[:tags] || {}).merge(scope.tags),
+        user: (defaults[:user] || {}).merge(scope.user),
+        extra: (defaults[:extra] || {}).merge(scope.extra),
         breadcrumbs: scope.breadcrumbs
-      }
+      }.tap do |ctx|
+        ctx[:environment] ||= @configuration.environment if @configuration.environment
+      end
+    end
+
+    def merge_context(scope_context, extra_context)
+      return scope_context unless extra_context
+
+      merged = scope_context.dup
+      merged[:context] = (scope_context[:context] || {}).merge(extra_context)
+      merged
     end
 
     def handle_capture_error(error)

data/lib/lapsoss/configuration.rb

@@ -13,7 +13,8 @@ module Lapsoss
                   :backtrace_context_lines, :backtrace_in_app_patterns, :backtrace_exclude_patterns,
                   :backtrace_strip_load_path, :backtrace_max_frames, :backtrace_enable_code_context,
                   :enable_pipeline, :pipeline_builder, :sampling_strategy,
-                  :skip_rails_cache_errors, :force_sync_http, :capture_request_context
+                  :skip_rails_cache_errors, :force_sync_http, :capture_request_context,
+                  :exclusion_filter
     attr_reader :fingerprint_callback, :environment, :before_send, :sample_rate, :error_handler, :transport_timeout,
                 :transport_max_retries, :transport_initial_backoff, :transport_max_backoff, :transport_backoff_multiplier, :transport_ssl_verify, :default_context, :adapter_configs
 
@@ -65,6 +66,8 @@ module Lapsoss
       @force_sync_http = false
       # Capture request context in middleware
       @capture_request_context = true
+      # Exclusion filter
+      @exclusion_filter = nil
     end
 
     # Register a named adapter configuration
@@ -114,6 +117,35 @@ module Lapsoss
       register_adapter(name, :logger, **settings)
     end
 
+    # Convenience method for OpenObserve
+    def use_openobserve(name: :openobserve, **settings)
+      register_adapter(name, :openobserve, **settings)
+    end
+
+    # Convenience method for OTLP (OpenTelemetry Protocol)
+    # Works with SigNoz, Jaeger, Tempo, Honeycomb, etc.
+    def use_otlp(name: :otlp, **settings)
+      register_adapter(name, :otlp, **settings)
+    end
+
+    # Convenience method for SigNoz (OTLP-compatible)
+    def use_signoz(name: :signoz, **settings)
+      settings[:endpoint] ||= "http://localhost:4318"
+      register_adapter(name, :otlp, **settings)
+    end
+
+    # Convenience method for Jaeger (OTLP-compatible)
+    def use_jaeger(name: :jaeger, **settings)
+      settings[:endpoint] ||= "http://localhost:4318"
+      register_adapter(name, :otlp, **settings)
+    end
+
+    # Convenience method for Grafana Tempo (OTLP-compatible)
+    def use_tempo(name: :tempo, **settings)
+      settings[:endpoint] ||= "http://localhost:4318"
+      register_adapter(name, :otlp, **settings)
+    end
+
     # Apply configuration by registering all adapters
     def apply!
       Registry.instance.clear!

data/lib/lapsoss/middleware/sample_filter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Middleware
+    # Drops events based on sampling strategy or rate.
+    class SampleFilter < Base
+      def initialize(app, sample_rate: 1.0, sample_callback: nil, sampler: nil)
+        super(app)
+        @sampler =
+          sampler ||
+          sample_callback ||
+          Sampling::UniformSampler.new(sample_rate)
+      end
+
+      def call(event, hint = {})
+        return nil unless sample?(event, hint)
+
+        @app.call(event, hint)
+      end
+
+      private
+
+      def sample?(event, hint)
+        if @sampler.respond_to?(:sample?)
+          @sampler.sample?(event, hint)
+        else
+          @sampler.call(event, hint)
+        end
+      end
+    end
+  end
+end

data/lib/lapsoss/middleware/user_context_enhancer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Middleware
+    # Adds user info to the event context using a callable provider.
+    class UserContextEnhancer < Base
+      def initialize(app, user_provider:, privacy_mode: false)
+        super(app)
+        @user_provider = user_provider
+        @privacy_mode = privacy_mode
+      end
+
+      def call(event, hint = {})
+        user_data = fetch_user(event, hint)
+        return @app.call(event, hint) unless user_data
+
+        merged_user = (event.context[:user] || {}).merge(user_data)
+        merged_user = sanitize_for_privacy(merged_user) if @privacy_mode
+
+        updated_context = event.context.merge(user: merged_user)
+        @app.call(event.with(context: updated_context), hint)
+      end
+
+      private
+
+      def fetch_user(event, hint)
+        return nil unless @user_provider
+
+        if @user_provider.respond_to?(:call)
+          @user_provider.call(event, hint)
+        elsif @user_provider.is_a?(Hash)
+          @user_provider
+        end
+      rescue StandardError
+        nil
+      end
+
+      def sanitize_for_privacy(user_hash)
+        allowed_keys = %i[id uuid user_id]
+        user_hash.slice(*allowed_keys)
+      end
+    end
+  end
+end

data/lib/lapsoss/router.rb

@@ -29,8 +29,9 @@ module Lapsoss
         )
 
         # Call error handler if configured
-        handler = Lapsoss.configuration.error_handler
-        handler&.call(adapter, event, error)
+        handled = error.instance_variable_defined?(:@lapsoss_error_handled) &&
+                  error.instance_variable_get(:@lapsoss_error_handled)
+        Lapsoss.call_error_handler(adapter: adapter, event: event, error: error) unless handled
       end
     end
   end

data/lib/lapsoss/scrubber.rb

@@ -10,7 +10,13 @@ module Lapsoss
       passw email secret token _key crypt salt certificate otp ssn cvv cvc
     ].freeze
 
+    MASK = "[FILTERED]"
+
     def initialize(config = {})
+      @scrub_all = !!config[:scrub_all]
+      @whitelist_fields = Array(config[:whitelist_fields]).map(&:to_s)
+      @randomize_scrub_length = !!config[:randomize_scrub_length]
+
       # Combine: Rails filter parameters + custom fields (if provided)
       base_params = if defined?(Rails) && Rails.respond_to?(:application) && Rails.application
                       Rails.application.config.filter_parameters.presence || DEFAULT_SCRUB_FIELDS
@@ -24,12 +30,94 @@ module Lapsoss
                         base_params
       end
 
-      @filter = ActiveSupport::ParameterFilter.new(filter_params)
+      @filter = ActiveSupport::ParameterFilter.new(filter_params, mask: MASK)
     end
 
     def scrub(data)
       return data if data.nil?
-      @filter.filter(data)
+
+      if @scrub_all
+        deep_scrub_all(data)
+      else
+        filtered = @filter.filter(data)
+        filtered = restore_whitelisted_values(data, filtered) if @whitelist_fields.any?
+        @randomize_scrub_length ? randomize_masks(filtered) : filtered
+      end
+    end
+
+    private
+
+    def deep_scrub_all(value)
+      case value
+      when Hash
+        value.each_with_object(value.class.new) do |(key, val), result|
+          if whitelisted?(key)
+            result[key] = val
+          else
+            result[key] = structure_preserving_mask(val)
+          end
+        end
+      when Array
+        value.map { |item| deep_scrub_all(item) }
+      else
+        mask_value(value)
+      end
+    end
+
+    def structure_preserving_mask(value)
+      case value
+      when Hash, Array
+        deep_scrub_all(value)
+      else
+        mask_value(value)
+      end
+    end
+
+    def mask_value(value)
+      @randomize_scrub_length ? random_mask(value) : MASK
+    end
+
+    def random_mask(value)
+      length = [ [ value.to_s.length, 3 ].max, 32 ].min
+      "*" * length
+    end
+
+    def whitelisted?(key)
+      @whitelist_fields.include?(key.to_s)
+    end
+
+    def restore_whitelisted_values(original, filtered)
+      case filtered
+      when Hash
+        filtered.each_with_object(filtered.class.new) do |(key, val), result|
+          if whitelisted?(key)
+            result[key] = original.is_a?(Hash) ? original[key] : original
+          else
+            next_original = original.is_a?(Hash) ? original[key] : nil
+            result[key] = restore_whitelisted_values(next_original, val)
+          end
+        end
+      when Array
+        filtered.each_with_index.map do |val, idx|
+          next_original = original.is_a?(Array) ? original[idx] : nil
+          restore_whitelisted_values(next_original, val)
+        end
+      else
+        filtered
+      end
+    end
+
+    def randomize_masks(value)
+      case value
+      when Hash
+        value.transform_values { |v| randomize_masks(v) }
+      when Array
+        value.map { |v| randomize_masks(v) }
+      when String
+        value == MASK ? random_mask(value) : value
+      else
+        value
+      end
     end
   end
 end

data/lib/lapsoss/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lapsoss
-  VERSION = "0.4.10"
+  VERSION = "0.4.11"
 end

data/lib/lapsoss.rb

@@ -83,6 +83,24 @@ module Lapsoss
       client.flush(timeout: timeout)
     end
 
+    def call_error_handler(adapter:, event:, error:)
+      handler = configuration.error_handler
+      return unless handler
+
+      case handler.arity
+      when 3
+        handler.call(adapter, event, error)
+      when 2
+        handler.call(event, error)
+      when 1, 0, -1
+        handler.call(error)
+      else
+        handler.call(adapter, event, error)
+      end
+    rescue => handler_error
+      configuration.logger&.error("[LAPSOSS] Error handler failed: #{handler_error.message}")
+    end
+
     delegate :shutdown, to: :client
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lapsoss
 version: !ruby/object:Gem::Version
-  version: 0.4.10
+  version: 0.4.11
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -221,8 +221,12 @@ files:
 - lib/lapsoss/adapters/concerns/envelope_builder.rb
 - lib/lapsoss/adapters/concerns/http_delivery.rb
 - lib/lapsoss/adapters/concerns/level_mapping.rb
+- lib/lapsoss/adapters/concerns/stacktrace_builder.rb
+- lib/lapsoss/adapters/concerns/trace_context.rb
 - lib/lapsoss/adapters/insight_hub_adapter.rb
 - lib/lapsoss/adapters/logger_adapter.rb
+- lib/lapsoss/adapters/openobserve_adapter.rb
+- lib/lapsoss/adapters/otlp_adapter.rb
 - lib/lapsoss/adapters/rollbar_adapter.rb
 - lib/lapsoss/adapters/sentry_adapter.rb
 - lib/lapsoss/adapters/telebugs_adapter.rb
@@ -247,6 +251,8 @@ files:
 - lib/lapsoss/middleware/metrics_collector.rb
 - lib/lapsoss/middleware/rate_limiter.rb
 - lib/lapsoss/middleware/release_tracker.rb
+- lib/lapsoss/middleware/sample_filter.rb
+- lib/lapsoss/middleware/user_context_enhancer.rb
 - lib/lapsoss/pipeline.rb
 - lib/lapsoss/pipeline_builder.rb
 - lib/lapsoss/rails_controller_context.rb