lapsoss 0.4.10 → 1.0.0

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)
@@ -78,6 +80,11 @@ module Lapsoss
     private
 
     def capture_event(event)
+      if Current.silenced
+        @configuration.logger.debug("[LAPSOSS] Event dropped: capture silenced via Lapsoss.silence")
+        return nil
+      end
+
       @configuration.logger.debug("[LAPSOSS] capture_event called, async: #{@configuration.async}, executor: #{@executor.inspect}")
 
       # Apply pipeline processing if enabled
@@ -86,6 +93,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 +133,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, :capture_rails_events, :rails_event_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
 
@@ -61,10 +62,15 @@ module Lapsoss
       @sampling_strategy = nil
       # Rails error filtering
       @skip_rails_cache_errors = true
+      # Rails.event structured events as breadcrumbs (Rails 8.1+)
+      @capture_rails_events = true
+      @rails_event_filter = nil
       # HTTP client settings
       @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 +120,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/current.rb

@@ -5,6 +5,7 @@ require "active_support/all"
 module Lapsoss
   class Current < ActiveSupport::CurrentAttributes
     attribute :scope, default: -> { Scope.new }
+    attribute :silenced, default: false
 
     def self.with_clean_scope
       previous_scope = scope

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/rails_event_subscriber.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  # Subscribes to Rails' structured event reporter (Rails.event, Rails 8.1+)
+  # and records emitted events as Lapsoss breadcrumbs, giving error reports an
+  # automatic activity trail without any monkey-patching.
+  class RailsEventSubscriber
+    def emit(event)
+      return unless Lapsoss.client
+
+      Lapsoss.add_breadcrumb(event[:name], type: :event, **breadcrumb_metadata(event))
+    end
+
+    private
+
+    def breadcrumb_metadata(event)
+      metadata = {}
+      payload = serialize_payload(event[:payload])
+      metadata[:payload] = payload if payload
+      metadata[:tags] = event[:tags] if event[:tags].present?
+      metadata[:context] = event[:context] if event[:context].present?
+
+      if (location = event[:source_location])
+        metadata[:source] = "#{location[:filepath]}:#{location[:lineno]}"
+      end
+
+      metadata
+    end
+
+    # Payloads are either hashes or arbitrary event objects, which Rails passes
+    # through as-is and expects subscribers to serialize.
+    def serialize_payload(payload)
+      case payload
+      when nil, Hash
+        payload
+      else
+        payload.respond_to?(:serialize) ? payload.serialize : payload.inspect
+      end
+    end
+  end
+end

data/lib/lapsoss/railtie.rb

@@ -39,6 +39,19 @@ module Lapsoss
       Rails.error.subscribe(Lapsoss::RailsErrorSubscriber.new)
     end
 
+    initializer "lapsoss.rails_event_subscriber" do
+      Rails.event.subscribe(Lapsoss::RailsEventSubscriber.new) do |event|
+        config = Lapsoss.configuration
+        if !config.capture_rails_events
+          false
+        elsif (filter = config.rails_event_filter)
+          !!filter.call(event)
+        else
+          true
+        end
+      end
+    end
+
     initializer "lapsoss.controller_transaction" do
       ActiveSupport.on_load(:action_controller) do
         require "lapsoss/rails_controller_transaction"

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