rails_error_dashboard 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cef62933d759c659ba8fd14e78aa7afdda622ce40520dccaa7424dd45322ecb6
-  data.tar.gz: 54fbae420eb1908ed7cb3b967c23dacdbbfa077fb918afb15f60fd3cef25a226
+  metadata.gz: 002c2e5d338c585425599802271a90c5bac425dc86867da1aa10a0c7a478d1e8
+  data.tar.gz: 077d7d7a7f957bee799cf39c96632532e3c74259e83310605c6068d57436aec3
 SHA512:
-  metadata.gz: f49280f38ce42192a5ac6544a31559550d50bb80c33bf8e8f8486ced684a7f729997cf46a1f4bcd933f4ca903acb9456a77ee33a56efbcd696cbf683765b866a
-  data.tar.gz: 1a69c452a43372ba7476d20502e98fc7f83d57fdc41839c1f30a61dc809a4d0484b0680c6d4526c6f517b23d1bc977fa500dea243eb5e258a0dfd86ef16a142c
+  metadata.gz: 8e6ef9f87aae8c200e997bf761184eb37c86d0637dfdd383fd6cc003f3c3b9fa30b7906fbaf6377670d932a60da5a9046202d4a48ab63264ce916c861ac20b91
+  data.tar.gz: 67858acc12ad29cb412b0c049b776b7193c9ce8d45febfa4bc23e079a1afd7ff64a2a85bd81516c999cc57861631ed3f89ea62bc36544370811e8cff858c8678

data/README.md

@@ -475,6 +475,32 @@ end
 [Plugin System guide →](docs/PLUGIN_SYSTEM.md)
 </details>
 
+<details>
+<summary><strong>OpenTelemetry Export — Emit Gem Operations as Spans</strong></summary>
+
+Send the gem's error-capture pipeline as OpenTelemetry spans to your existing Datadog, Honeycomb, or Jaeger collector. Each stage of the capture path — DB write, breadcrumb harvest, system health snapshot, and notification dispatch — becomes a named child span so you can audit gem overhead from your own observability dashboards.
+
+- Off by default — zero impact unless you opt in
+- No-op when the OTel API gem isn't loaded
+- Per-span-kind opt-in: enable only the stages you care about
+- Every span individually rescue-wrapped — never raises into host code
+- Boot-time warning if `enable_otel_export = true` but `opentelemetry-api` isn't in the Gemfile
+
+```ruby
+# Gemfile — only the API gem is required; the SDK is optional
+gem "opentelemetry-api"
+
+# config/initializers/rails_error_dashboard.rb
+config.enable_otel_export  = true
+config.otel_service_name   = "my-app"   # falls back to application_name
+config.otel_spans          = [:capture, :breadcrumbs, :health, :notifications]  # all (default)
+# config.otel_spans        = [:capture]                                          # parent span only
+```
+
+Span names follow the `rails_error_dashboard.<operation>` convention, e.g. `rails_error_dashboard.capture_error`. Both attributes are attached to every span: `rails_error_dashboard.version` and `rails_error_dashboard.service_name` — use them to filter the gem's traffic in your dashboards.
+
+</details>
+
 ---
 
 ## Quick Start
@@ -539,6 +565,8 @@ end
 
 **Multi-App Support** — Track errors from multiple Rails apps in a single shared database. Auto-detects app name, supports per-app filtering. [Multi-App guide →](docs/MULTI_APP_PERFORMANCE.md)
 
+**OpenTelemetry Export** — Emit error-capture operations as OTel spans to Datadog, Honeycomb, or Jaeger. Add `gem "opentelemetry-api"` and set `config.enable_otel_export = true`. See [OpenTelemetry Export](#opentelemetry-export--emit-gem-operations-as-spans) above for full options.
+
 ---
 
 ## Documentation

data/lib/generators/rails_error_dashboard/install/templates/initializer.rb

@@ -483,6 +483,41 @@ RailsErrorDashboard.configure do |config|
   # config.llm_max_output_tokens = 900
   # config.llm_system_prompt = "Prefer concise answers with file-level next steps."
 
+  # ============================================================================
+  # OPENTELEMETRY EXPORT (OUTBOUND)
+  # ============================================================================
+  #
+  # Emit gem operations as OpenTelemetry spans so the host's existing
+  # Datadog / Honeycomb / Jaeger / Grafana Tempo pipeline gets a trace
+  # of every error capture. Useful for:
+  #   - Auditing "when did this error get captured?" against deploy events
+  #   - Measuring how much time the gem spends in the capture path
+  #   - Proving the <5ms host-safety budget from operator dashboards
+  #
+  # Emits four spans per error capture:
+  #   rails_error_dashboard.capture_error           — parent, wraps everything
+  #   rails_error_dashboard.breadcrumb_collection   — buffer drain (~µs)
+  #   rails_error_dashboard.system_health_snapshot  — GC.stat etc. (<1ms)
+  #   rails_error_dashboard.notification_dispatch   — Slack/email enqueue
+  #
+  # Disabled by default. Requires the host app to already run OpenTelemetry
+  # (the gem does NOT add an opentelemetry-* runtime dependency). When OTel
+  # is absent, every span call is a zero-overhead no-op.
+  #
+  # config.enable_otel_export = true
+  # config.otel_service_name = "my-app"  # Falls back to application_name when nil
+  #
+  # Per-span opt-out: pass any subset to disable individual span kinds
+  # without code changes. Useful when e.g. notification dispatch is slow due
+  # to outbound HTTP and you don't want it polluting your trace dashboards.
+  #
+  # config.otel_spans = [:capture, :breadcrumbs, :health, :notifications]  # all (default)
+  # config.otel_spans = [:capture]                                          # parent only
+  # config.otel_spans = [:capture, :health]                                 # parent + health
+  #
+  # No PII or request bodies in span attributes — just metadata + timing.
+  # Safe to enable on production OTel pipelines.
+
   # ============================================================================
   # ISSUE TRACKING (GitHub / GitLab / Codeberg)
   # ============================================================================

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -17,6 +17,21 @@ module RailsErrorDashboard
         end
       end
 
+      # Build the base OTel span attributes available before any work happens.
+      # Kept as a module-level helper so both sync and async paths can call it.
+      # @return [Hash<String, Object>]
+      def self.build_capture_span_attributes(exception, was_async:)
+        msg = exception.message.to_s
+        {
+          "error.type" => exception.class.name,
+          "error.message" => msg.length > 200 ? "#{msg[0, 200]}…" : msg,
+          "rails_error_dashboard.environment" => (defined?(Rails) && Rails.env.to_s) || "unknown",
+          "rails_error_dashboard.was_async" => was_async
+        }
+      rescue StandardError
+        { "error.type" => "unknown", "rails_error_dashboard.was_async" => was_async }
+      end
+
       # Queue error logging as a background job
       def self.call_async(exception, context = {})
         # Serialize exception data for the job
@@ -68,7 +83,17 @@ module RailsErrorDashboard
         # Enqueue the async job using ActiveJob
         # The queue adapter (:sidekiq, :solid_queue, :async) is configured separately
         begin
-          AsyncErrorLoggingJob.perform_later(exception_data, context)
+          # OTel: emit a capture span around the enqueue itself. The real capture
+          # work runs in the job (which starts its own root span via .new(...).call).
+          # For the async path the span here measures *enqueue latency only* — used
+          # to detect queue-adapter backpressure or Redis slowness.
+          Integrations::Tracer.in_span(
+            "capture_error",
+            kind: :capture,
+            attributes: build_capture_span_attributes(exception, was_async: true)
+          ) do |_span|
+            AsyncErrorLoggingJob.perform_later(exception_data, context)
+          end
         rescue => e
           # Queue adapter failed (e.g., Redis down for Sidekiq). Fall back to
           # sync logging so the error is still captured. Without this rescue,
@@ -118,13 +143,31 @@ module RailsErrorDashboard
       end
 
       def call
+        # OTel: parent capture span. Wraps the entire sync capture path so
+        # operators can audit how long error capture takes from their existing
+        # tracing pipeline. Child spans (breadcrumbs, health, notifications)
+        # nest under this one automatically via OTel context propagation.
+        #
+        # The span lives INSIDE the rescue clause — if the span itself raises
+        # somehow, the outer rescue still catches it and returns nil. Defense
+        # in depth. When the block raises, the Tracer façade records the
+        # exception on the span and re-raises so the rescue can swallow it.
+        Integrations::Tracer.in_span(
+          "capture_error",
+          kind: :capture,
+          attributes: self.class.build_capture_span_attributes(@exception, was_async: false)
+        ) do |span|
         # Check if this exception should be logged (ignore list + sampling)
-        return nil unless Services::ExceptionFilter.should_log?(@exception)
+        if !Services::ExceptionFilter.should_log?(@exception)
+          span&.set_attribute("rails_error_dashboard.filtered", true)
+          next nil
+        end
 
         error_context = ValueObjects::ErrorContext.new(@context, @context[:source])
 
         # Find or create application (cached lookup)
         application = find_or_create_application
+        span&.set_attribute("rails_error_dashboard.application", application.name.to_s) if application.respond_to?(:name)
 
         # Build error attributes
         truncated_backtrace = Services::BacktraceProcessor.truncate(@exception.backtrace)
@@ -262,6 +305,14 @@ module RailsErrorDashboard
         # This ensures accurate occurrence tracking
         error_log = ErrorLog.find_or_increment_by_hash(error_hash, attributes.merge(error_hash: error_hash))
 
+        # OTel: now that the error_log exists, attach its id + dedup flag + severity
+        # to the parent capture span so operators can correlate to dashboard URLs.
+        if span && error_log
+          span.set_attribute("rails_error_dashboard.error_id", error_log.id) if error_log.id
+          span.set_attribute("rails_error_dashboard.deduplicated", error_log.occurrence_count.to_i > 1)
+          span.set_attribute("rails_error_dashboard.severity", error_log.severity.to_s) if error_log.respond_to?(:severity) && error_log.severity
+        end
+
         #  Track individual error occurrence for co-occurrence analysis (if table exists)
         if defined?(ErrorOccurrence) && ErrorOccurrence.table_exists?
           begin
@@ -298,6 +349,7 @@ module RailsErrorDashboard
         check_baseline_anomaly(error_log)
 
         error_log
+        end
       rescue => e
         # Don't let error logging cause more errors - fail silently
         # CRITICAL: Log but never propagate exception

data/lib/rails_error_dashboard/configuration.rb

@@ -189,6 +189,14 @@ module RailsErrorDashboard
     attr_accessor :llm_observability_content_capture    # Capture prompt/completion text (default: false — PII risk)
     attr_accessor :llm_pricing_overrides                # Hash of { "model-name" => { input: usd_per_1m, output: usd_per_1m } }
 
+    # OpenTelemetry outbound export — emit gem operations as OTel spans for
+    # Datadog/Honeycomb/Jaeger. Requires the host app to already run OTel.
+    # When OTel is absent OR enable_otel_export is false, all emit calls
+    # are no-ops with zero overhead.
+    attr_accessor :enable_otel_export                   # Master switch (default: false)
+    attr_accessor :otel_service_name                    # Falls back to application_name when nil
+    attr_accessor :otel_spans                           # Array of enabled span kinds — see Integrations::Tracer::ALL_SPAN_KINDS
+
     # Dashboard UI appearance
     attr_accessor :accent_color  # :crimson (default), :ruby, :ember, :violet
 
@@ -372,6 +380,13 @@ module RailsErrorDashboard
       @llm_observability_content_capture = false
       @llm_pricing_overrides = {}
 
+      # OTel outbound export defaults — OFF (opt-in). All four span kinds enabled
+      # by default once master switch flips on; users can pass a subset to opt out
+      # of e.g. notification spans without code changes.
+      @enable_otel_export = false
+      @otel_service_name = nil
+      @otel_spans = %i[capture breadcrumbs health notifications]
+
       # Internal logging defaults - SILENT by default
       @enable_internal_logging = false  # Opt-in for debugging
       @log_level = :silent  # Silent by default, use :debug, :info, :warn, :error, or :silent
@@ -553,6 +568,28 @@ module RailsErrorDashboard
         @enable_llm_observability = false
       end
 
+      # Validate OTel export config — coerce or warn rather than raise so a
+      # config typo never blocks the host app from booting.
+      if enable_otel_export
+        unless otel_spans.is_a?(Array)
+          warnings << "otel_spans must be an Array of symbols (e.g. [:capture, :breadcrumbs]). " \
+                      "Resetting to all-enabled."
+          @otel_spans = %i[capture breadcrumbs health notifications]
+        end
+
+        invalid = otel_spans - %i[capture breadcrumbs health notifications]
+        if invalid.any?
+          warnings << "otel_spans contains unknown kinds: #{invalid.inspect}. Allowed: " \
+                      "[:capture, :breadcrumbs, :health, :notifications]. Ignoring unknown values."
+          @otel_spans = otel_spans - invalid
+        end
+
+        if @otel_spans.empty?
+          warnings << "enable_otel_export = true but otel_spans is empty — no spans will be emitted. " \
+                      "Set otel_spans to enable at least one of [:capture, :breadcrumbs, :health, :notifications]."
+        end
+      end
+
       # Skip credential/service-dependent validations during Docker builds.
       # SECRET_KEY_BASE_DUMMY=1 means no credentials or external services available.
       build_env = ENV["SECRET_KEY_BASE_DUMMY"].present?

data/lib/rails_error_dashboard/engine.rb

@@ -107,6 +107,20 @@ module RailsErrorDashboard
       # capability, so this is safe to call unconditionally.
       RailsErrorDashboard::Integrations::LlmSpanProcessor.register!
 
+      # Outbound OTel export — warn at boot if the feature is enabled but
+      # the OTel API isn't loaded. The Tracer façade silently no-ops in that
+      # state, so without this warning users could enable the feature and
+      # see zero spans without knowing why. Don't auto-disable — the user
+      # may install OTel later in the boot sequence.
+      if RailsErrorDashboard.configuration.enable_otel_export &&
+         !RailsErrorDashboard::Integrations::Tracer.otel_api_loaded?
+        Rails.logger.warn(
+          "[RailsErrorDashboard] enable_otel_export = true but the OpenTelemetry API " \
+          "(opentelemetry-api gem) isn't loaded. Outbound spans will not emit. " \
+          "Add `gem \"opentelemetry-api\"` (or the full opentelemetry-sdk) to your Gemfile."
+        )
+      end
+
       # Subscribe to red.llm_call / red.llm_tool_call AS::Notifications — Tier 3
       # path for hosts using direct Net::HTTP / gRPC / local inference servers
       # that aren't covered by OTel or the Faraday middleware.

data/lib/rails_error_dashboard/integrations/tracer.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Integrations
+    # OpenTelemetry tracer façade for the outbound direction — emits spans
+    # from the gem's capture path so host operators can audit error tracking
+    # latency from their existing Datadog/Honeycomb/Jaeger pipeline.
+    #
+    # Symmetric counterpart to LlmSpanProcessor (which is INBOUND — pulls
+    # OTel spans INTO RED breadcrumbs). This module pushes OUTBOUND: gem
+    # operations OUT to the host's tracer provider.
+    #
+    # Designed to be called from hot paths unconditionally. When OTel is
+    # absent or the feature is off, `in_span` runs the block with a no-op
+    # span object — call sites do NOT branch on availability.
+    #
+    # HOST APP SAFETY (HOST_APP_SAFETY.md):
+    # - No-op when `enable_otel_export = false` OR OTel API not loaded
+    # - Per-span-kind opt-in/out via config.otel_spans
+    # - Tracer instance memoized per-process (rebuild on `reset!`)
+    # - Every public method hard-rescues — never raises into host code
+    # - Block return value is preserved even when tracer errors
+    # - Exceptions raised by the block re-raise after being recorded
+    #
+    # Configuration:
+    #   config.enable_otel_export = true     # master switch (default false)
+    #   config.otel_service_name = "my-app"  # falls back to application_name
+    #   config.otel_spans = [:capture, :breadcrumbs, :health, :notifications]
+    #
+    # Usage from capture-path code:
+    #
+    #   Tracer.in_span("capture_error", kind: :capture,
+    #                  attributes: { error_type: exception.class.name }) do |span|
+    #     # ... do the work ...
+    #     span&.set_attribute("rails_error_dashboard.error_id", error.id)
+    #   end
+    #
+    # The span object yielded may be the real OTel span or a NoopSpan.
+    # Always use safe-nav (`span&.`) or guard with `span.respond_to?(:...)`.
+    module Tracer
+      INSTRUMENTATION_NAME = "rails_error_dashboard"
+      ALL_SPAN_KINDS = %i[capture breadcrumbs health notifications].freeze
+
+      # No-op stand-in returned to the block when tracing is off or unavailable.
+      # Mimics the OTel Span interface (set_attribute, add_event, record_exception)
+      # so call sites don't branch.
+      class NoopSpan
+        def set_attribute(_key, _value); self; end
+        def add_event(_name, attributes: nil); self; end
+        def record_exception(_exception, attributes: nil); self; end
+        def status=(_status); end
+        def finish; self; end
+        def context; nil; end
+      end
+
+      NOOP_SPAN = NoopSpan.new.freeze
+
+      class << self
+        # Yields a span object to the block. Returns the block's return value.
+        # Records exceptions raised by the block as span events and re-raises.
+        #
+        # @param name [String] short span name (will be namespaced with INSTRUMENTATION_NAME)
+        # @param kind [Symbol] one of ALL_SPAN_KINDS — checked against config.otel_spans
+        # @param attributes [Hash<String,Object>] attached to the span at creation
+        # @yieldparam span [NoopSpan, ::OpenTelemetry::Trace::Span] real or no-op
+        # @return [Object] whatever the block returns
+        def in_span(name, kind: :capture, attributes: {})
+          return yield(NOOP_SPAN) unless emit?(kind)
+
+          tr = tracer
+          return yield(NOOP_SPAN) unless tr
+
+          full_name = "#{INSTRUMENTATION_NAME}.#{name}"
+          merged = base_attributes.merge(safe_stringify(attributes))
+
+          tr.in_span(full_name, attributes: merged) do |span|
+            begin
+              yield span
+            rescue StandardError => e
+              record_block_exception(span, e)
+              raise
+            end
+          end
+        rescue StandardError => e
+          # Tracer internals failed (e.g. OTel SDK threw on add_span). Fall back
+          # to running the block with a no-op so the host app never sees a crash
+          # caused by the tracer.
+          Logger.debug("[RailsErrorDashboard] Tracer.in_span(#{name.inspect}) failed: #{e.class}: #{e.message}")
+          yield NOOP_SPAN
+        end
+
+        # Returns true when the OTel API is loaded AND the master switch is on
+        # AND the given span kind is in the enabled set. Cheap — called on every
+        # in_span invocation, including in the hot path.
+        # @param kind [Symbol]
+        # @return [Boolean]
+        def emit?(kind)
+          config = RailsErrorDashboard.configuration
+          return false unless config.enable_otel_export
+          return false unless otel_api_loaded?
+
+          enabled_kinds = config.otel_spans
+          return false if enabled_kinds.nil? || enabled_kinds.empty?
+          enabled_kinds.include?(kind)
+        rescue StandardError
+          false
+        end
+
+        # Reset memoized tracer + availability — for spec isolation only.
+        def reset!
+          @tracer = nil
+          @otel_api_loaded = nil
+        end
+
+        # Returns true if the OTel API gem is loaded (NOT the SDK). The API alone
+        # is enough — it ships a ProxyTracerProvider that's a no-op when no SDK
+        # is configured, which is the behavior we want.
+        # @return [Boolean]
+        def otel_api_loaded?
+          return @otel_api_loaded unless @otel_api_loaded.nil?
+          @otel_api_loaded = !!(defined?(::OpenTelemetry) &&
+                                ::OpenTelemetry.respond_to?(:tracer_provider))
+        rescue StandardError
+          @otel_api_loaded = false
+        end
+
+        private
+
+        # Memoized tracer instance. Returns nil on any failure so the caller
+        # falls back to no-op behavior.
+        # @return [::OpenTelemetry::Trace::Tracer, nil]
+        def tracer
+          return @tracer if @tracer
+          return nil unless otel_api_loaded?
+
+          @tracer = ::OpenTelemetry.tracer_provider.tracer(
+            INSTRUMENTATION_NAME,
+            RailsErrorDashboard::VERSION
+          )
+        rescue StandardError => e
+          Logger.debug("[RailsErrorDashboard] Tracer initialization failed: #{e.class}: #{e.message}")
+          nil
+        end
+
+        # Attributes attached to every span — service-name and gem version
+        # let operators filter the gem's traffic out of their dashboards.
+        def base_attributes
+          config = RailsErrorDashboard.configuration
+          {
+            "rails_error_dashboard.version" => RailsErrorDashboard::VERSION,
+            "rails_error_dashboard.service_name" => config.otel_service_name ||
+                                                    config.application_name ||
+                                                    "unknown"
+          }
+        rescue StandardError
+          {}
+        end
+
+        # OTel attribute values must be strings, bools, numerics, or arrays of those.
+        # Coerce hash values to strings as a safety net — host code passing arbitrary
+        # objects (e.g. a Symbol or an Exception) won't crash the SDK.
+        def safe_stringify(attrs)
+          return {} unless attrs.is_a?(Hash)
+          attrs.each_with_object({}) do |(k, v), acc|
+            key = k.to_s
+            acc[key] = case v
+            when String, Numeric, TrueClass, FalseClass then v
+            when Array
+              v.map { |x| x.is_a?(String) || x.is_a?(Numeric) || x == true || x == false ? x : x.to_s }
+            when nil then nil
+            else v.to_s
+            end
+          end.compact
+        rescue StandardError
+          {}
+        end
+
+        # OTel semconv for exceptions:
+        #   span.record_exception(exception)  -- adds an "exception" event
+        #   span.status = OpenTelemetry::Trace::Status.error("message")
+        def record_block_exception(span, exception)
+          return unless span.respond_to?(:record_exception)
+          span.record_exception(exception)
+
+          if defined?(::OpenTelemetry::Trace::Status) &&
+             ::OpenTelemetry::Trace::Status.respond_to?(:error)
+            span.status = ::OpenTelemetry::Trace::Status.error(exception.message.to_s[0, 200])
+          end
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/breadcrumb_collector.rb

@@ -120,12 +120,33 @@ module RailsErrorDashboard
       # Harvest breadcrumbs from the current buffer and clear it
       # @return [Array<Hash>] Array of breadcrumb hashes (empty if none)
       def self.harvest
-        buffer = Thread.current[THREAD_KEY]
-        return [] unless buffer
+        # OTel: emit a child span around the harvest so operators see the
+        # buffer-drain step in the capture trace. Cheap to compute (single
+        # Array#size + JSON byte estimate) and contained to LogError invocations
+        # via the parent rails_error_dashboard.capture_error span.
+        RailsErrorDashboard::Integrations::Tracer.in_span(
+          "breadcrumb_collection",
+          kind: :breadcrumbs
+        ) do |span|
+          buffer = Thread.current[THREAD_KEY]
+          if buffer.nil?
+            span&.set_attribute("breadcrumb_count", 0)
+            next []
+          end
 
-        result = buffer.to_a
-        buffer.clear
-        result
+          result = buffer.to_a
+          buffer.clear
+
+          # Only pay for attribute computation when a real span is recording.
+          # NoopSpan is the singleton returned when OTel is off — skip the work
+          # entirely so the harvest path stays free in the common case.
+          if span && !span.equal?(RailsErrorDashboard::Integrations::Tracer::NOOP_SPAN)
+            span.set_attribute("breadcrumb_count", result.size)
+            span.set_attribute("bytes_serialized_estimate", estimate_byte_size(result))
+          end
+
+          result
+        end
       rescue => e
         RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] BreadcrumbCollector.harvest failed: #{e.message}")
         []
@@ -222,6 +243,25 @@ module RailsErrorDashboard
         {}
       end
       private_class_method :truncate_metadata
+
+      # Rough byte-size estimate without paying the full JSON serialization
+      # cost. Sums the (already-truncated) message lengths and metadata string
+      # values. Used as the bytes_serialized_estimate attribute on the OTel
+      # breadcrumb_collection span.
+      def self.estimate_byte_size(breadcrumbs)
+        return 0 unless breadcrumbs.is_a?(Array)
+        breadcrumbs.sum do |c|
+          next 0 unless c.is_a?(Hash)
+          # ~12 bytes constant overhead per crumb (timestamp + category key)
+          base = 12 + (c[:m] || c["m"]).to_s.bytesize
+          meta = c[:meta] || c["meta"]
+          base += meta.values.sum { |v| v.to_s.bytesize } if meta.is_a?(Hash)
+          base
+        end
+      rescue StandardError
+        0
+      end
+      private_class_method :estimate_byte_size
     end
   end
 end

data/lib/rails_error_dashboard/services/error_notification_dispatcher.rb

@@ -12,26 +12,48 @@ module RailsErrorDashboard
     class ErrorNotificationDispatcher
       # @param error_log [ErrorLog] The error to notify about
       def self.call(error_log)
-        config = RailsErrorDashboard.configuration
+        # OTel: emit a child span around the dispatch so operators can see
+        # which channels fired for a given error and how long the enqueue
+        # itself took. Actual delivery happens in the background jobs (Slack
+        # HTTP, SMTP, etc.) — those would need their own instrumentation to
+        # measure delivery latency.
+        RailsErrorDashboard::Integrations::Tracer.in_span(
+          "notification_dispatch",
+          kind: :notifications,
+          attributes: { "rails_error_dashboard.error_id" => error_log.id.to_i }
+        ) do |span|
+          config = RailsErrorDashboard.configuration
+          fired = []
 
-        if config.enable_slack_notifications && config.slack_webhook_url.present?
-          SlackErrorNotificationJob.perform_later(error_log.id)
-        end
+          if config.enable_slack_notifications && config.slack_webhook_url.present?
+            SlackErrorNotificationJob.perform_later(error_log.id)
+            fired << "slack"
+          end
 
-        if config.enable_email_notifications && config.notification_email_recipients.present?
-          EmailErrorNotificationJob.perform_later(error_log.id)
-        end
+          if config.enable_email_notifications && config.notification_email_recipients.present?
+            EmailErrorNotificationJob.perform_later(error_log.id)
+            fired << "email"
+          end
 
-        if config.enable_discord_notifications && config.discord_webhook_url.present?
-          DiscordErrorNotificationJob.perform_later(error_log.id)
-        end
+          if config.enable_discord_notifications && config.discord_webhook_url.present?
+            DiscordErrorNotificationJob.perform_later(error_log.id)
+            fired << "discord"
+          end
 
-        if config.enable_pagerduty_notifications && config.pagerduty_integration_key.present?
-          PagerdutyErrorNotificationJob.perform_later(error_log.id)
-        end
+          if config.enable_pagerduty_notifications && config.pagerduty_integration_key.present?
+            PagerdutyErrorNotificationJob.perform_later(error_log.id)
+            fired << "pagerduty"
+          end
+
+          if config.enable_webhook_notifications && config.webhook_urls.present?
+            WebhookErrorNotificationJob.perform_later(error_log.id)
+            fired << "webhook"
+          end
 
-        if config.enable_webhook_notifications && config.webhook_urls.present?
-          WebhookErrorNotificationJob.perform_later(error_log.id)
+          if span && !span.equal?(RailsErrorDashboard::Integrations::Tracer::NOOP_SPAN)
+            span.set_attribute("channels", fired)
+            span.set_attribute("channel_count", fired.size)
+          end
         end
       end
     end

data/lib/rails_error_dashboard/services/system_health_snapshot.rb

@@ -24,7 +24,16 @@ module RailsErrorDashboard
       # Capture current system health metrics
       # @return [Hash] Health snapshot (always safe, never raises)
       def self.capture
-        new.capture
+        # OTel: emit a child span around the snapshot so operators can verify
+        # the <1ms health-budget claim from their own tracing dashboard. The
+        # snapshot itself is read-only (GC.stat, pool.stat, procfs reads) so
+        # the span carries no useful attributes beyond timing.
+        RailsErrorDashboard::Integrations::Tracer.in_span(
+          "system_health_snapshot",
+          kind: :health
+        ) do |_span|
+          new.capture
+        end
       rescue => e
         RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] SystemHealthSnapshot.capture failed: #{e.message}")
         { captured_at: Time.current.iso8601 }

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.7.2"
+  VERSION = "0.8.0"
 end

data/lib/rails_error_dashboard.rb

@@ -21,6 +21,7 @@ begin; require "turbo-rails"; rescue LoadError; end
 require "rails_error_dashboard/value_objects/error_context"
 require "rails_error_dashboard/value_objects/llm_call_event"
 require "rails_error_dashboard/integrations/o_tel"
+require "rails_error_dashboard/integrations/tracer"
 require "rails_error_dashboard/integrations/llm_span_processor"
 require "rails_error_dashboard/integrations/llm_middleware"
 require "rails_error_dashboard/helpers/user_model_detector"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -398,6 +398,7 @@ files:
 - lib/rails_error_dashboard/integrations/llm_middleware.rb
 - lib/rails_error_dashboard/integrations/llm_span_processor.rb
 - lib/rails_error_dashboard/integrations/o_tel.rb
+- lib/rails_error_dashboard/integrations/tracer.rb
 - lib/rails_error_dashboard/logger.rb
 - lib/rails_error_dashboard/manual_error_reporter.rb
 - lib/rails_error_dashboard/middleware/error_catcher.rb
@@ -510,7 +511,7 @@ metadata:
   funding_uri: https://github.com/sponsors/AnjanJ
 post_install_message: |
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    RED (Rails Error Dashboard) v0.7.2
+    RED (Rails Error Dashboard) v0.8.0
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   First install:
@@ -546,7 +547,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Self-hosted error tracking and exception monitoring for Rails. Free, forever.
 test_files: []