rails_error_dashboard 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 128bf5d8e84190cf45290fc1000c5a0bc45dd27aea13f7cc6447d5795ad5059f
-  data.tar.gz: 94e96577de22affd2fecbd2f7d723823840021b8fbcc3df10c1cf5092c150248
+  metadata.gz: 002c2e5d338c585425599802271a90c5bac425dc86867da1aa10a0c7a478d1e8
+  data.tar.gz: 077d7d7a7f957bee799cf39c96632532e3c74259e83310605c6068d57436aec3
 SHA512:
-  metadata.gz: 4743bd41df374b04291b6887e7b08e0889ec7093bd312ba361b93156be9fbeb6bf4a103a35e8ff65b33cf0d07161c771ababbad1bcdd1d77e930bb3265b80f63
-  data.tar.gz: 79dd710f629a9c3f6d3eab49405a13efb08b25f3f6212fe6b70d1f98839bffe5e36ba55524a77c99c3bcaf00ade39ac61e3dd2563179797e1ea5e1cfa03696e7
+  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/app/controllers/rails_error_dashboard/errors_controller.rb

@@ -518,6 +518,26 @@ module RailsErrorDashboard
       @pagy, @channels = pagy(:offset, all_channels, limit: params[:per_page] || 25)
     end
 
+    def llm_health_summary
+      unless RailsErrorDashboard.configuration.enable_llm_observability &&
+             RailsErrorDashboard.configuration.enable_breadcrumbs
+        @feature_disabled = true
+        @days = days_param(default: 30)
+        @models = []
+        @totals = Queries::LlmHealthSummary.blank_totals
+        @pagy = nil
+        return
+      end
+
+      days = days_param(default: 30)
+      @days = days
+      result = Queries::LlmHealthSummary.call(days, application_id: @current_application_id)
+      @totals = result[:totals]
+      all_models = result[:models]
+
+      @pagy, @models = pagy(:offset, all_models, limit: params[:per_page] || 25)
+    end
+
     def activestorage_health_summary
       unless RailsErrorDashboard.configuration.enable_activestorage_tracking &&
              RailsErrorDashboard.configuration.enable_breadcrumbs

data/app/views/layouts/rails_error_dashboard.html.erb

@@ -1002,6 +1002,9 @@ tr[data-red-row-href]:hover .sev-bar { opacity: 1 !important; }
           <% if RailsErrorDashboard.configuration.enable_activestorage_tracking && RailsErrorDashboard.configuration.enable_breadcrumbs %>
             <% health_items << { path: activestorage_health_summary_errors_path(nav_params), icon: 'bi-cloud-arrow-up', label: 'ActiveStorage' } %>
           <% end %>
+          <% if RailsErrorDashboard.configuration.enable_llm_observability && RailsErrorDashboard.configuration.enable_breadcrumbs %>
+            <% health_items << { path: llm_health_summary_errors_path(nav_params), icon: 'bi-cpu-fill', label: 'LLM' } %>
+          <% end %>
 
           <% if health_items.any? %>
             <div style="margin-bottom: var(--space-2);" id="navHealthSection">

data/app/views/rails_error_dashboard/errors/llm_health_summary.html.erb

@@ -0,0 +1,249 @@
+<% content_for :page_title, "LLM Health" %>
+
+<div>
+  <div class="d-flex justify-content-between align-items-center mb-4">
+    <h1 style="font-size: 20px; font-weight: 700; margin: 0;">
+      <i class="bi bi-cpu-fill me-2"></i>
+      LLM Health
+    </h1>
+
+    <% unless @feature_disabled %>
+      <div class="btn-group" role="group">
+        <%= link_to llm_health_summary_errors_path(days: 7), class: "btn btn-sm #{@days == 7 ? 'btn-primary' : 'btn-outline-primary'}" do %>
+          7 Days
+        <% end %>
+        <%= link_to llm_health_summary_errors_path(days: 30), class: "btn btn-sm #{@days == 30 ? 'btn-primary' : 'btn-outline-primary'}" do %>
+          30 Days
+        <% end %>
+        <%= link_to llm_health_summary_errors_path(days: 90), class: "btn btn-sm #{@days == 90 ? 'btn-primary' : 'btn-outline-primary'}" do %>
+          90 Days
+        <% end %>
+      </div>
+    <% end %>
+  </div>
+
+  <% if @feature_disabled %>
+    <div class="red-empty-state">
+      <i class="bi bi-cpu-fill display-1 text-muted mb-3"></i>
+      <div class="red-empty-state-title">LLM Observability Not Enabled</div>
+      <p class="text-muted">
+        To see per-model LLM stats here, enable LLM observability and breadcrumbs.
+      </p>
+      <div class="card mx-auto" style="max-width: 600px;">
+        <div class="card-body text-start">
+          <h6>Enable in <code>config/initializers/rails_error_dashboard.rb</code>:</h6>
+          <pre class="mb-0" style="background: var(--bg-subtle); padding: var(--space-3); border-radius: var(--radius-md); font-size: 12px;"><code>RailsErrorDashboard.configure do |config|
+  config.enable_breadcrumbs = true
+  config.enable_llm_observability = true
+end</code></pre>
+        </div>
+      </div>
+    </div>
+
+  <% elsif @totals[:total_calls] == 0 && @totals[:total_tool_calls] == 0 %>
+    <div class="red-empty-state">
+      <i class="bi bi-cpu-fill display-1 text-success mb-3"></i>
+      <div class="red-empty-state-title">No LLM Calls Detected</div>
+      <p class="text-muted">
+        No LLM API calls were captured in error breadcrumbs over the last <%= @days %> days.
+        Instrument LLM calls in one of three ways:
+      </p>
+
+      <div class="card mx-auto" style="max-width: 720px;">
+        <div class="card-body p-0">
+          <ul class="nav nav-tabs" role="tablist" id="llmPathTabs">
+            <li class="nav-item" role="presentation">
+              <button class="nav-link active" data-bs-toggle="tab" data-bs-target="#llmPathOtel" type="button" role="tab">
+                <i class="bi bi-diagram-3 me-1"></i> OpenTelemetry
+              </button>
+            </li>
+            <li class="nav-item" role="presentation">
+              <button class="nav-link" data-bs-toggle="tab" data-bs-target="#llmPathFaraday" type="button" role="tab">
+                <i class="bi bi-arrow-left-right me-1"></i> Faraday / RubyLLM
+              </button>
+            </li>
+            <li class="nav-item" role="presentation">
+              <button class="nav-link" data-bs-toggle="tab" data-bs-target="#llmPathManual" type="button" role="tab">
+                <i class="bi bi-pencil-square me-1"></i> Manual
+              </button>
+            </li>
+          </ul>
+
+          <div class="tab-content p-3 text-start">
+            <div class="tab-pane fade show active" id="llmPathOtel" role="tabpanel">
+              <p class="mb-2"><small>Already running an OTel collector? Drop in this gem and we'll subscribe automatically.</small></p>
+              <pre class="mb-2" style="background: var(--bg-subtle); padding: var(--space-3); border-radius: var(--radius-md); font-size: 12px;"><code># Gemfile
+gem "opentelemetry-instrumentation-ruby_llm"
+
+# Then nothing else — OTel spans flow into RED breadcrumbs.</code></pre>
+              <small class="text-muted">Requires <code>enable_llm_observability = true</code>.</small>
+            </div>
+
+            <div class="tab-pane fade" id="llmPathFaraday" role="tabpanel">
+              <p class="mb-2"><small>Using <code>ruby_llm</code>, <code>openai</code>, <code>anthropic</code>, or any Faraday-based SDK? Insert the middleware once.</small></p>
+              <pre class="mb-2" style="background: var(--bg-subtle); padding: var(--space-3); border-radius: var(--radius-md); font-size: 12px;"><code>Faraday.default_connection_options.builder.tap do |b|
+  b.use RailsErrorDashboard::Integrations::LlmMiddleware
+end</code></pre>
+              <small class="text-muted">RED auto-detects provider/model and tokens from the request/response.</small>
+            </div>
+
+            <div class="tab-pane fade" id="llmPathManual" role="tabpanel">
+              <p class="mb-2"><small>Direct <code>Net::HTTP</code>, gRPC, local inference, or anything else — instrument by hand.</small></p>
+              <pre class="mb-2" style="background: var(--bg-subtle); padding: var(--space-3); border-radius: var(--radius-md); font-size: 12px;"><code>ActiveSupport::Notifications.instrument(
+  "red.llm_call",
+  provider: "anthropic",
+  model: "claude-3-5-sonnet",
+  input_tokens: 1200,
+  output_tokens: 350
+) do
+  call_anthropic(...)
+end</code></pre>
+              <small class="text-muted">Cost is auto-estimated from tokens — payload can override with <code>cost_usd_estimate:</code>.</small>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+  <% else %>
+    <div class="row mb-4">
+      <div class="col-md-3">
+        <div class="card text-center">
+          <div class="card-body">
+            <div class="display-6 text-primary"><%= @totals[:total_calls] %></div>
+            <small class="text-muted">LLM Calls</small>
+          </div>
+        </div>
+      </div>
+      <div class="col-md-3">
+        <div class="card text-center">
+          <div class="card-body">
+            <div class="display-6 text-secondary"><%= @totals[:model_count] %></div>
+            <small class="text-muted">Models</small>
+          </div>
+        </div>
+      </div>
+      <div class="col-md-3">
+        <div class="card text-center">
+          <div class="card-body">
+            <% err_color = @totals[:error_rate] >= 10 ? "danger" : (@totals[:error_rate] >= 5 ? "warning" : "success") %>
+            <div class="display-6 text-<%= err_color %>"><%= @totals[:unique_error_count] %></div>
+            <small class="text-muted">Errors with LLM (<%= @totals[:error_rate] %>%)</small>
+          </div>
+        </div>
+      </div>
+      <div class="col-md-3">
+        <div class="card text-center">
+          <div class="card-body">
+            <div class="display-6 text-info">$<%= format("%.2f", @totals[:total_cost_usd]) %></div>
+            <small class="text-muted">Total Cost</small>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <div class="card mb-4">
+      <div class="card-header d-flex justify-content-between align-items-center">
+        <h5 class="mb-0">
+          <i class="bi bi-cpu-fill text-primary me-2"></i>
+          Performance by Model
+          <span class="badge bg-primary"><%= @totals[:model_count] %></span>
+        </h5>
+        <small class="text-muted"><%== @pagy.info_tag %></small>
+      </div>
+      <div class="card-body p-0">
+        <div class="table-responsive">
+          <table class="table table-hover mb-0">
+            <thead class="table-light">
+              <tr>
+                <th>Provider · Model</th>
+                <th width="90">Calls</th>
+                <th width="80">Tools</th>
+                <th width="130">Avg tokens</th>
+                <th width="110">Avg latency</th>
+                <th width="100">Error rate</th>
+                <th width="100">Cost</th>
+                <th>Top error</th>
+                <th width="140">Last seen</th>
+              </tr>
+            </thead>
+            <tbody>
+              <% @models.each do |entry| %>
+                <tr>
+                  <td>
+                    <small class="text-muted"><%= entry[:provider] %></small><br>
+                    <code><%= entry[:model] %></code>
+                  </td>
+                  <td><%= entry[:call_count] %></td>
+                  <td>
+                    <% if entry[:tool_call_count].positive? %>
+                      <span class="badge bg-info"><%= entry[:tool_call_count] %></span>
+                    <% else %>
+                      <span class="text-muted">—</span>
+                    <% end %>
+                  </td>
+                  <td>
+                    <% if entry[:avg_input_tokens] || entry[:avg_output_tokens] %>
+                      <small>
+                        in <strong><%= number_with_delimiter(entry[:avg_input_tokens] || 0) %></strong><br>
+                        out <strong><%= number_with_delimiter(entry[:avg_output_tokens] || 0) %></strong>
+                      </small>
+                    <% else %>
+                      <span class="text-muted">—</span>
+                    <% end %>
+                  </td>
+                  <td>
+                    <% if entry[:avg_duration_ms] %>
+                      <% lat_color = entry[:avg_duration_ms] > 5000 ? "text-danger" : entry[:avg_duration_ms] > 2000 ? "text-warning" : "text-muted" %>
+                      <span class="<%= lat_color %>"><%= number_with_delimiter(entry[:avg_duration_ms].round) %>ms</span>
+                    <% else %>
+                      <span class="text-muted">—</span>
+                    <% end %>
+                  </td>
+                  <td>
+                    <% sev_color = entry[:severity] == :danger ? "danger" : (entry[:severity] == :warning ? "warning" : "success") %>
+                    <span class="badge bg-<%= sev_color %>"><%= entry[:error_rate] %>%</span>
+                    <% if entry[:error_count].positive? %>
+                      <br><small class="text-muted"><%= entry[:error_count] %> failed</small>
+                    <% end %>
+                  </td>
+                  <td>
+                    <% if entry[:cost_usd_sum].positive? %>
+                      $<%= format("%.4f", entry[:cost_usd_sum]) %>
+                    <% else %>
+                      <span class="text-muted">—</span>
+                    <% end %>
+                  </td>
+                  <td>
+                    <% if entry[:top_error_class] %>
+                      <code style="font-size: 11px;"><%= entry[:top_error_class] %></code>
+                      <small class="text-muted">×<%= entry[:top_error_class_count] %></small>
+                    <% else %>
+                      <span class="text-muted">—</span>
+                    <% end %>
+                  </td>
+                  <td><%= local_time_ago(entry[:last_seen]) %></td>
+                </tr>
+              <% end %>
+            </tbody>
+          </table>
+        </div>
+      </div>
+      <div class="card-footer border-top d-flex justify-content-between align-items-center">
+        <div>
+          <small class="text-muted">
+            <i class="bi bi-lightbulb text-warning"></i> High error rates on a model often signal quota or rate-limit issues. Slow latency (&gt;5s) suggests provider degradation.
+          </small>
+          <small class="ms-3">
+            <a href="https://github.com/thoughtbot/opentelemetry-instrumentation-ruby_llm" target="_blank" rel="noopener" class="text-decoration-none">
+              <i class="bi bi-book"></i> Instrumentation Guide <i class="bi bi-box-arrow-up-right" style="font-size: 0.7em;"></i>
+            </a>
+          </small>
+        </div>
+        <div>
+          <%== @pagy.series_nav(:bootstrap) if @pagy.pages > 1 %>
+        </div>
+      </div>
+    </div>
+  <% end %>
+</div>

data/config/routes.rb

@@ -38,6 +38,7 @@ RailsErrorDashboard::Engine.routes.draw do
       get :rack_attack_summary
       get :actioncable_health_summary
       get :activestorage_health_summary
+      get :llm_health_summary
       get :releases
       get :user_impact
       get :diagnostic_dumps

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/queries/llm_health_summary.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Aggregate LLM call breadcrumbs across all errors, grouped by
+    # "provider · model". Scans error_logs breadcrumbs JSON, filters for "llm"
+    # and "llm_tool" category crumbs, and computes per-model stats: call count,
+    # tool count, avg tokens, avg latency, error rate, cost, top error class.
+    #
+    # Sorted by error rate desc, then unique-error count desc, then call volume
+    # desc — so the model causing the most errors floats to the top.
+    #
+    # Cost is read straight from the breadcrumb metadata (already estimated at
+    # capture time by LlmCallSubscriber via LlmCostEstimator). No re-estimation.
+    class LlmHealthSummary
+      DANGER_THRESHOLD = 10.0  # error rate %
+      WARNING_THRESHOLD = 5.0
+
+      def self.call(days = 30, application_id: nil)
+        new(days, application_id: application_id).call
+      end
+
+      # Public helper so controllers can render an empty-state shell without
+      # running the query (e.g., when the feature is disabled).
+      def self.blank_totals
+        {
+          total_calls: 0,
+          total_tool_calls: 0,
+          model_count: 0,
+          unique_error_count: 0,
+          error_rate: 0.0,
+          total_cost_usd: 0.0
+        }
+      end
+
+      def initialize(days = 30, application_id: nil)
+        @days = days
+        @application_id = application_id
+        @start_date = days.days.ago
+      end
+
+      def call
+        models = aggregated_models
+        {
+          models: models,
+          totals: totals_for(models)
+        }
+      end
+
+      private
+
+      def base_query
+        scope = ErrorLog.where("occurred_at >= ?", @start_date)
+                        .where.not(breadcrumbs: nil)
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
+      end
+
+      def aggregated_models
+        results = {}
+
+        base_query.select(:id, :breadcrumbs, :occurred_at).find_each(batch_size: 500) do |error_log|
+          crumbs = parse_breadcrumbs(error_log.breadcrumbs)
+          next if crumbs.empty?
+
+          llm_crumbs = crumbs.select { |c| c["c"] == "llm" || c["c"] == "llm_tool" }
+          next if llm_crumbs.empty?
+
+          llm_crumbs.each do |crumb|
+            meta = crumb["meta"] || {}
+            provider = meta["provider"].to_s.presence || "unknown"
+            model = meta["model"].to_s.presence || "unknown"
+            key = "#{provider}·#{model}"
+
+            results[key] ||= new_entry(provider, model)
+            entry = results[key]
+
+            if crumb["c"] == "llm_tool"
+              entry[:tool_call_count] += 1
+            else
+              entry[:call_count] += 1
+            end
+
+            status = meta["status"].to_s
+            entry[:error_count] += 1 if status == "error" || status == "timeout"
+
+            # BreadcrumbCollector#truncate_metadata stringifies every metadata
+            # value (input_tokens "42", cost_usd "0.0003", etc.), so we coerce
+            # back to numeric here using the same pattern as LlmSummary. nil and
+            # blank values skip the accumulator entirely so they don't pollute
+            # averages.
+            if (it = meta["input_tokens"]).present?
+              entry[:input_tokens_sum] += it.to_i
+              entry[:input_tokens_seen] += 1
+            end
+            if (ot = meta["output_tokens"]).present?
+              entry[:output_tokens_sum] += ot.to_i
+              entry[:output_tokens_seen] += 1
+            end
+            duration_raw = meta["duration_ms"] || crumb["d"]
+            if duration_raw.present?
+              d = duration_raw.to_f
+              if d > 0
+                entry[:duration_sum] += d
+                entry[:duration_seen] += 1
+              end
+            end
+            if (cost = meta["cost_usd"]).present?
+              entry[:cost_usd_sum] += cost.to_f
+            end
+
+            if (err_class = meta["error_class"]).is_a?(String) && !err_class.empty?
+              entry[:error_classes][err_class] = (entry[:error_classes][err_class] || 0) + 1
+            end
+
+            entry[:error_ids] << error_log.id
+            entry[:last_seen] = [ entry[:last_seen], error_log.occurred_at ].compact.max
+          end
+        end
+
+        finalize(results)
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] LlmHealthSummary query failed: #{e.class}: #{e.message}")
+        []
+      end
+
+      def new_entry(provider, model)
+        {
+          provider: provider,
+          model: model,
+          call_count: 0,
+          tool_call_count: 0,
+          error_count: 0,
+          input_tokens_sum: 0,
+          input_tokens_seen: 0,
+          output_tokens_sum: 0,
+          output_tokens_seen: 0,
+          duration_sum: 0.0,
+          duration_seen: 0,
+          cost_usd_sum: 0.0,
+          error_classes: {},
+          error_ids: [],
+          last_seen: nil
+        }
+      end
+
+      def finalize(results)
+        results.values.each do |r|
+          r[:error_ids] = r[:error_ids].uniq
+          r[:unique_error_count] = r[:error_ids].size
+
+          total_attempts = r[:call_count] + r[:tool_call_count]
+          r[:error_rate] = total_attempts.positive? ? (r[:error_count].to_f / total_attempts * 100).round(2) : 0.0
+          r[:severity] = severity_for(r[:error_rate])
+
+          r[:avg_input_tokens] = avg(r[:input_tokens_sum], r[:input_tokens_seen])
+          r[:avg_output_tokens] = avg(r[:output_tokens_sum], r[:output_tokens_seen])
+          r[:avg_duration_ms] = r[:duration_seen].positive? ? (r[:duration_sum] / r[:duration_seen]).round(2) : nil
+          r[:cost_usd_sum] = r[:cost_usd_sum].round(4)
+
+          top_class, top_count = r[:error_classes].max_by { |_, c| c }
+          r[:top_error_class] = top_class
+          r[:top_error_class_count] = top_count
+
+          # Drop accumulators — view doesn't need them
+          r.delete(:input_tokens_sum)
+          r.delete(:input_tokens_seen)
+          r.delete(:output_tokens_sum)
+          r.delete(:output_tokens_seen)
+          r.delete(:duration_sum)
+          r.delete(:duration_seen)
+          r.delete(:error_classes)
+        end
+
+        results.values.sort_by { |r| [ -r[:error_rate], -r[:unique_error_count], -r[:call_count] ] }
+      end
+
+      def avg(sum, count)
+        return nil if count.zero?
+        (sum.to_f / count).round
+      end
+
+      def severity_for(error_rate)
+        return :danger  if error_rate >= DANGER_THRESHOLD
+        return :warning if error_rate >= WARNING_THRESHOLD
+        :success
+      end
+
+      def totals_for(models)
+        return blank_totals if models.empty? || !models.is_a?(Array)
+
+        total_calls = models.sum { |m| m[:call_count] }
+        total_tool_calls = models.sum { |m| m[:tool_call_count] }
+        total_errors = models.sum { |m| m[:error_count] }
+        total_attempts = total_calls + total_tool_calls
+        unique_error_ids = models.flat_map { |m| m[:error_ids] }.uniq
+
+        {
+          total_calls: total_calls,
+          total_tool_calls: total_tool_calls,
+          model_count: models.size,
+          unique_error_count: unique_error_ids.size,
+          error_rate: total_attempts.positive? ? (total_errors.to_f / total_attempts * 100).round(2) : 0.0,
+          total_cost_usd: models.sum { |m| m[:cost_usd_sum] }.round(4)
+        }
+      end
+
+      def blank_totals
+        self.class.blank_totals
+      end
+
+      def parse_breadcrumbs(raw)
+        return [] if raw.blank?
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        []
+      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.1"
+  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"
@@ -131,6 +132,7 @@ require "rails_error_dashboard/queries/job_health_summary"
 require "rails_error_dashboard/queries/database_health_summary"
 require "rails_error_dashboard/queries/swallowed_exception_summary"
 require "rails_error_dashboard/queries/rack_attack_summary"
+require "rails_error_dashboard/queries/llm_health_summary"
 require "rails_error_dashboard/queries/release_timeline"
 require "rails_error_dashboard/error_reporter"
 require "rails_error_dashboard/middleware/error_catcher"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -312,6 +312,7 @@ files:
 - app/views/rails_error_dashboard/errors/diagnostic_dumps.html.erb
 - app/views/rails_error_dashboard/errors/index.html.erb
 - app/views/rails_error_dashboard/errors/job_health_summary.html.erb
+- app/views/rails_error_dashboard/errors/llm_health_summary.html.erb
 - app/views/rails_error_dashboard/errors/n_plus_one_summary.html.erb
 - app/views/rails_error_dashboard/errors/overview.html.erb
 - app/views/rails_error_dashboard/errors/platform_comparison.html.erb
@@ -397,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
@@ -421,6 +423,7 @@ files:
 - lib/rails_error_dashboard/queries/errors_list.rb
 - lib/rails_error_dashboard/queries/filter_options.rb
 - lib/rails_error_dashboard/queries/job_health_summary.rb
+- lib/rails_error_dashboard/queries/llm_health_summary.rb
 - lib/rails_error_dashboard/queries/mttr_stats.rb
 - lib/rails_error_dashboard/queries/n_plus_one_summary.rb
 - lib/rails_error_dashboard/queries/platform_comparison.rb
@@ -508,7 +511,7 @@ metadata:
   funding_uri: https://github.com/sponsors/AnjanJ
 post_install_message: |
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    RED (Rails Error Dashboard) v0.7.1
+    RED (Rails Error Dashboard) v0.8.0
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   First install:
@@ -544,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: []