rails_error_dashboard 0.7.2 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cef62933d759c659ba8fd14e78aa7afdda622ce40520dccaa7424dd45322ecb6
-  data.tar.gz: 54fbae420eb1908ed7cb3b967c23dacdbbfa077fb918afb15f60fd3cef25a226
+  metadata.gz: 532921b0ba2ccb40a532a66e5e3c7b1fcf17fc56e53cb5b0ed3772648644f0c0
+  data.tar.gz: 282169f161d90326aaebce5933521cd54c8bb373611e9002b447f114b6654204
 SHA512:
-  metadata.gz: f49280f38ce42192a5ac6544a31559550d50bb80c33bf8e8f8486ced684a7f729997cf46a1f4bcd933f4ca903acb9456a77ee33a56efbcd696cbf683765b866a
-  data.tar.gz: 1a69c452a43372ba7476d20502e98fc7f83d57fdc41839c1f30a61dc809a4d0484b0680c6d4526c6f517b23d1bc977fa500dea243eb5e258a0dfd86ef16a142c
+  metadata.gz: 63c2ba5ef4319eaff8450837fec526135e37865ea0d2c72c30b7010ff6e86c03e49f728172d032bec6ad626f8dba39d00841300839fee9b8a493caa912669559
+  data.tar.gz: c84238b00e2f6959fd1e4ac5a1c9ff2d696a0d28379a102e99d761585caf4c24a4f6446f4d303d69c933e5135b31e7c3ef1d0a6b7464376e88ad25b14068c75a

data/README.md

@@ -233,7 +233,7 @@ Payload contract matches the `LlmCallEvent` value object — see [`docs/LLM_OBSE
 </details>
 
 <details>
-<summary><strong>Issue Tracking — GitHub, GitLab, Codeberg</strong></summary>
+<summary><strong>Issue Tracking — GitHub, GitLab, Codeberg, Linear</strong></summary>
 
 One switch connects errors to your issue tracker. Platform becomes the source of truth — status, assignees, labels, and comments are mirrored live in the dashboard.
 
@@ -250,6 +250,17 @@ config.issue_tracker_token = ENV["RED_BOT_TOKEN"]
 # That's it — provider and repo auto-detected from git_repository_url
 ```
 
+Linear works too — it's not a git forge, so set the provider and team key explicitly:
+
+```ruby
+config.enable_issue_tracking = true
+config.issue_tracker_provider = :linear
+config.issue_tracker_repo = "ENG"  # Linear team key (issues land as ENG-123)
+config.issue_tracker_token = ENV["RED_BOT_TOKEN"]  # lin_api_... personal API key
+```
+
+Closing maps to the team's first `completed` workflow state, reopening to `unstarted`/`backlog`. Two-way sync uses Linear webhooks (`Linear-Signature` HMAC verification).
+
 [Complete documentation →](docs/guides/CONFIGURATION.md)
 </details>
 
@@ -475,6 +486,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 +576,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/webhooks_controller.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module RailsErrorDashboard
-  # Receives webhooks from GitHub/GitLab/Codeberg for two-way issue sync.
+  # Receives webhooks from GitHub/GitLab/Codeberg/Linear for two-way issue sync.
   #
   # When an issue is closed/reopened on the platform, the corresponding
   # error in the dashboard is resolved/reopened to match.
@@ -10,6 +10,7 @@ module RailsErrorDashboard
   # - GitHub:   X-Hub-Signature-256 (HMAC-SHA256)
   # - GitLab:   X-Gitlab-Token (shared secret)
   # - Codeberg: X-Gitea-Signature (HMAC-SHA256)
+  # - Linear:   Linear-Signature (HMAC-SHA256)
   class WebhooksController < ActionController::Base
     skip_before_action :verify_authenticity_token
 
@@ -29,6 +30,8 @@ module RailsErrorDashboard
         handle_gitlab(payload)
       when "codeberg"
         handle_codeberg(payload)
+      when "linear"
+        handle_linear(payload)
       else
         head :not_found
         return
@@ -69,6 +72,8 @@ module RailsErrorDashboard
         verify_gitlab_token(secret)
       when "codeberg"
         verify_codeberg_signature(body, secret)
+      when "linear"
+        verify_linear_signature(body, secret)
       else
         false
       end
@@ -99,6 +104,14 @@ module RailsErrorDashboard
       ActiveSupport::SecurityUtils.secure_compare(expected, signature)
     end
 
+    def verify_linear_signature(body, secret)
+      signature = request.headers["Linear-Signature"]
+      return false unless signature
+
+      expected = OpenSSL::HMAC.hexdigest("SHA256", secret, body)
+      ActiveSupport::SecurityUtils.secure_compare(expected, signature)
+    end
+
     def parse_payload
       JSON.parse(request.body.read)
     rescue JSON::ParserError
@@ -162,6 +175,27 @@ module RailsErrorDashboard
       end
     end
 
+    # Linear: Issue webhook fires with action create/update/remove. State changes
+    # arrive as updates with the old stateId in updatedFrom. Linear has no
+    # open/closed binary — completed/canceled state types map to resolved.
+    def handle_linear(payload)
+      return unless payload["type"] == "Issue" && payload["action"] == "update"
+      return unless payload["updatedFrom"]&.key?("stateId")
+
+      issue_number = payload.dig("data", "number")
+      return unless issue_number
+
+      error = find_error_by_issue(issue_number, "linear")
+      return unless error
+
+      state_type = payload.dig("data", "state", "type")
+      if state_type.in?(%w[completed canceled])
+        resolve_error(error, "Completed on Linear by #{payload.dig("actor", "name")}")
+      elsif state_type.in?(%w[triage backlog unstarted started])
+        reopen_error(error)
+      end
+    end
+
     def find_error_by_issue(issue_number, provider)
       ErrorLog.find_by(
         external_issue_number: issue_number,

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

@@ -18,6 +18,7 @@
                    when "github" then "bi-github"
                    when "gitlab" then "bi-gitlab"
                    when "codeberg" then "bi-git"
+                   when "linear" then "bi-kanban"
                    else "bi-link-45deg"
                    end %>
         <% issue = @platform_issue %>

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

@@ -484,7 +484,42 @@ RailsErrorDashboard.configure do |config|
   # config.llm_system_prompt = "Prefer concise answers with file-level next steps."
 
   # ============================================================================
-  # ISSUE TRACKING (GitHub / GitLab / Codeberg)
+  # 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 / Linear)
   # ============================================================================
   #
   # One switch enables everything: issue creation, auto-create on first
@@ -499,7 +534,7 @@ RailsErrorDashboard.configure do |config|
   #   - Priority → labels from platform (with colors)
   #   - Snooze and Mute remain (no platform equivalent)
   #
-  # Setup:
+  # Setup (GitHub/GitLab/Codeberg):
   #   1. Create a RED bot account on GitHub/GitLab/Codeberg
   #   2. Generate a token and set RED_BOT_TOKEN env var
   #   3. Set git_repository_url above (already used for source code linking)
@@ -508,6 +543,17 @@ RailsErrorDashboard.configure do |config|
   # config.enable_issue_tracking = true
   # config.issue_tracker_token = ENV["RED_BOT_TOKEN"]
   #
+  # Setup (Linear):
+  #   Linear is not a git forge, so it cannot be auto-detected from
+  #   git_repository_url — set provider and team key explicitly. Issues are
+  #   created in the team matching the key (e.g. "ENG" for ENG-123 issues).
+  #   Generate a personal API key under Settings > Security & access.
+  #
+  # config.enable_issue_tracking = true
+  # config.issue_tracker_provider = :linear
+  # config.issue_tracker_repo = "ENG"                              # Linear team key
+  # config.issue_tracker_token = ENV["RED_BOT_TOKEN"]              # lin_api_... key
+  #
   # Optional overrides:
   # config.issue_tracker_labels = ["bug"]                          # Labels added to new issues
   # config.issue_tracker_auto_create_severities = [:critical, :high]  # Auto-create threshold

data/lib/rails_error_dashboard/commands/create_issue.rb

@@ -2,7 +2,7 @@
 
 module RailsErrorDashboard
   module Commands
-    # Command: Create an issue on the configured issue tracker (GitHub/GitLab/Codeberg)
+    # Command: Create an issue on the configured issue tracker (GitHub/GitLab/Codeberg/Linear)
     #
     # Creates the issue via the provider API, then stores the issue URL, number,
     # and provider on the error record for linking.

data/lib/rails_error_dashboard/commands/link_existing_issue.rb

@@ -14,7 +14,9 @@ module RailsErrorDashboard
       PROVIDER_PATTERNS = {
         github: %r{github\.com/([^/]+/[^/]+)/issues/(\d+)}i,
         gitlab: %r{gitlab\.com/([^/]+/[^/]+)/-/issues/(\d+)}i,
-        codeberg: %r{codeberg\.org/([^/]+/[^/]+)/issues/(\d+)}i
+        codeberg: %r{codeberg\.org/([^/]+/[^/]+)/issues/(\d+)}i,
+        # https://linear.app/<workspace>/issue/ENG-123/<slug> — capture team key + number
+        linear: %r{linear\.app/[^/]+/issue/([A-Za-z][A-Za-z0-9]*)-(\d+)}i
       }.freeze
 
       def self.call(error_id, issue_url:)

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

@@ -92,8 +92,8 @@ module RailsErrorDashboard
     # issue_webhook_secret is set.
     attr_accessor :enable_issue_tracking         # Master switch (default: false) — enables all platform integration
     attr_accessor :issue_tracker_token            # String or lambda/proc for Rails credentials
-    attr_accessor :issue_tracker_provider         # :github, :gitlab, :codeberg (auto-detected from git_repository_url)
-    attr_accessor :issue_tracker_repo             # "owner/repo" (auto-extracted from git_repository_url)
+    attr_accessor :issue_tracker_provider         # :github, :gitlab, :codeberg (auto-detected from git_repository_url), or :linear (explicit only)
+    attr_accessor :issue_tracker_repo             # "owner/repo" (auto-extracted from git_repository_url), or Linear team key like "ENG"
     attr_accessor :issue_tracker_labels           # Array of label strings (default: ["bug"])
     attr_accessor :issue_tracker_api_url          # Custom API base URL for self-hosted instances
     attr_accessor :issue_tracker_auto_create_severities  # Auto-create for these severities (default: [:critical, :high])
@@ -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?
@@ -567,7 +604,8 @@ module RailsErrorDashboard
 
         if enable_issue_tracking && effective_issue_tracker_provider.nil?
           warnings << "enable_issue_tracking is true but provider could not be detected. " \
-                      "Set issue_tracker_provider or git_repository_url."
+                      "Set issue_tracker_provider (:github, :gitlab, :codeberg, :linear) or git_repository_url. " \
+                      "Note: :linear is never auto-detected — set it explicitly with issue_tracker_repo as the team key."
         end
       end
 
@@ -699,9 +737,11 @@ module RailsErrorDashboard
       default || blank
     end
 
-    # Resolve the effective issue tracker provider (auto-detect from git_repository_url)
+    # Resolve the effective issue tracker provider (auto-detect from git_repository_url).
+    # Linear is never auto-detected (it is not a git forge) — set issue_tracker_provider
+    # explicitly.
     #
-    # @return [Symbol, nil] :github, :gitlab, :codeberg, or nil
+    # @return [Symbol, nil] :github, :gitlab, :codeberg, :linear, or nil
     def effective_issue_tracker_provider
       return issue_tracker_provider&.to_sym if issue_tracker_provider.present?
       return nil if git_repository_url.blank?
@@ -714,11 +754,13 @@ module RailsErrorDashboard
       end
     end
 
-    # Resolve the effective issue tracker repository ("owner/repo")
+    # Resolve the effective issue tracker repository ("owner/repo", or Linear team key)
     #
-    # @return [String, nil] "owner/repo" or nil
+    # @return [String, nil] "owner/repo", Linear team key, or nil
     def effective_issue_tracker_repo
       return issue_tracker_repo if issue_tracker_repo.present?
+      # A git URL can never yield a Linear team key — require explicit config
+      return nil if effective_issue_tracker_provider == :linear
       return nil if git_repository_url.blank?
 
       # Extract owner/repo from URL: https://github.com/owner/repo(.git)
@@ -746,6 +788,7 @@ module RailsErrorDashboard
       when :github then "https://api.github.com"
       when :gitlab then "https://gitlab.com/api/v4"
       when :codeberg then "https://codeberg.org/api/v1"
+      when :linear then "https://api.linear.app/graphql"
       end
     end
 

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

@@ -8,8 +8,9 @@ module RailsErrorDashboard
   module Services
     # Base class and factory for issue tracker API clients.
     #
-    # Supports GitHub, GitLab, and Codeberg/Gitea/Forgejo via a unified interface.
-    # Each provider implements the same methods with provider-specific API calls.
+    # Supports GitHub, GitLab, Codeberg/Gitea/Forgejo, and Linear via a unified
+    # interface. Each provider implements the same methods with provider-specific
+    # API calls.
     #
     # @example
     #   client = IssueTrackerClient.for(:github, token: "ghp_xxx", repo: "user/repo")
@@ -23,9 +24,9 @@ module RailsErrorDashboard
 
       # Factory method — returns the correct client for the provider
       #
-      # @param provider [Symbol] :github, :gitlab, or :codeberg
+      # @param provider [Symbol] :github, :gitlab, :codeberg, or :linear
       # @param token [String] API authentication token
-      # @param repo [String] Repository identifier ("owner/repo")
+      # @param repo [String] Repository identifier ("owner/repo"), or Linear team key ("ENG")
       # @param api_url [String, nil] Custom API base URL (for self-hosted)
       # @return [IssueTrackerClient] Provider-specific client instance
       def self.for(provider, token:, repo:, api_url: nil)
@@ -36,8 +37,10 @@ module RailsErrorDashboard
           GitLabIssueClient.new(token: token, repo: repo, api_url: api_url)
         when :codeberg
           CodebergIssueClient.new(token: token, repo: repo, api_url: api_url)
+        when :linear
+          LinearIssueClient.new(token: token, repo: repo, api_url: api_url)
         else
-          raise ArgumentError, "Unknown issue tracker provider: #{provider}. Supported: :github, :gitlab, :codeberg"
+          raise ArgumentError, "Unknown issue tracker provider: #{provider}. Supported: :github, :gitlab, :codeberg, :linear"
         end
       end
 

data/lib/rails_error_dashboard/services/linear_issue_client.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Linear GraphQL API client for issue management.
+    #
+    # API Docs: https://developers.linear.app/docs/graphql/working-with-the-graphql-api
+    # Auth: Personal API key (Settings > Security & access > Personal API keys)
+    # Rate limit: 1,500 requests/hour per API key
+    #
+    # Unlike the git forges, Linear has no "owner/repo" — issues belong to a
+    # team. The `repo` argument holds the team key (e.g. "ENG"), and issues
+    # are addressed by their human identifier ("ENG-123"), reconstructed from
+    # the team key plus the team-scoped issue number we store.
+    #
+    # Linear also has no open/closed binary — issues move between typed
+    # workflow states. Closing maps to the team's first `completed`-type
+    # state, reopening to the first `unstarted` (or `backlog`) state.
+    class LinearIssueClient < IssueTrackerClient
+      REOPEN_STATE_TYPES = [ "unstarted", "backlog", "triage" ].freeze
+
+      def initialize(token:, repo:, api_url: nil)
+        super
+        @api_url = api_url || "https://api.linear.app/graphql"
+      end
+
+      def create_issue(title:, body:, labels: [])
+        return error_response(@last_error || "Linear team '#{@repo}' not found") unless team_id
+
+        input = { teamId: team_id, title: title, description: truncate_body(body) }
+        label_ids = resolve_label_ids(labels)
+        input[:labelIds] = label_ids if label_ids.any?
+
+        data = graphql(<<~GRAPHQL, input: input)
+          mutation($input: IssueCreateInput!) {
+            issueCreate(input: $input) { success issue { identifier number url } }
+          }
+        GRAPHQL
+
+        issue = data&.dig("issueCreate", "issue")
+        if issue
+          success_response(url: issue["url"], number: issue["number"])
+        else
+          error_response(@last_error || "Linear API error: issue creation failed")
+        end
+      end
+
+      def close_issue(number:)
+        update_issue_state(number, "completed")
+      end
+
+      def reopen_issue(number:)
+        update_issue_state(number, REOPEN_STATE_TYPES)
+      end
+
+      def add_comment(number:, body:)
+        issue_id = find_issue_id(number)
+        return error_response(@last_error || "Linear issue #{identifier_for(number)} not found") unless issue_id
+
+        data = graphql(<<~GRAPHQL, input: { issueId: issue_id, body: truncate_body(body) })
+          mutation($input: CommentCreateInput!) {
+            commentCreate(input: $input) { success comment { url } }
+          }
+        GRAPHQL
+
+        comment = data&.dig("commentCreate", "comment")
+        comment ? success_response(url: comment["url"]) : error_response(@last_error || "Linear API error: comment failed")
+      end
+
+      def fetch_comments(number:, per_page: 10)
+        data = graphql(<<~GRAPHQL, id: identifier_for(number), first: per_page)
+          query($id: String!, $first: Int!) {
+            issue(id: $id) {
+              comments(first: $first) {
+                nodes { body createdAt url user { name avatarUrl } }
+              }
+            }
+          }
+        GRAPHQL
+
+        nodes = data&.dig("issue", "comments", "nodes")
+        return error_response(@last_error || "Linear API error: could not fetch comments") unless nodes
+
+        comments = nodes.map { |c|
+          {
+            author: c.dig("user", "name"),
+            avatar_url: c.dig("user", "avatarUrl"),
+            body: c["body"],
+            created_at: c["createdAt"],
+            url: c["url"]
+          }
+        }
+        success_response(comments: comments)
+      end
+
+      def fetch_issue(number:)
+        data = graphql(<<~GRAPHQL, id: identifier_for(number))
+          query($id: String!) {
+            issue(id: $id) {
+              title
+              state { name type }
+              assignee { name avatarUrl }
+              labels { nodes { name color } }
+            }
+          }
+        GRAPHQL
+
+        issue = data&.dig("issue")
+        return error_response(@last_error || "Linear API error: could not fetch issue") unless issue
+
+        assignee = issue["assignee"]
+        success_response(
+          state: closed_state_type?(issue.dig("state", "type")) ? "closed" : "open",
+          title: issue["title"],
+          assignees: assignee ? [ { login: assignee["name"], avatar_url: assignee["avatarUrl"] } ] : [],
+          labels: (issue.dig("labels", "nodes") || []).map { |l|
+            { name: l["name"], color: l["color"]&.delete("#") }
+          }
+        )
+      end
+
+      private
+
+      # Linear issues are addressed by "TEAM-123" — team key + stored number
+      def identifier_for(number)
+        "#{@repo}-#{number}"
+      end
+
+      def closed_state_type?(state_type)
+        [ "completed", "canceled" ].include?(state_type)
+      end
+
+      def update_issue_state(number, state_types)
+        issue_id = find_issue_id(number)
+        return error_response(@last_error || "Linear issue #{identifier_for(number)} not found") unless issue_id
+
+        state_id = workflow_state_id(Array(state_types))
+        return error_response(@last_error || "No matching workflow state for #{Array(state_types).join('/')}") unless state_id
+
+        data = graphql(<<~GRAPHQL, id: issue_id, input: { stateId: state_id })
+          mutation($id: String!, $input: IssueUpdateInput!) {
+            issueUpdate(id: $id, input: $input) { success }
+          }
+        GRAPHQL
+
+        data&.dig("issueUpdate", "success") ? success_response({}) : error_response(@last_error || "Linear API error: state update failed")
+      end
+
+      def find_issue_id(number)
+        data = graphql("query($id: String!) { issue(id: $id) { id } }", id: identifier_for(number))
+        data&.dig("issue", "id")
+      end
+
+      def team_id
+        @team_id ||= begin
+          data = graphql(<<~GRAPHQL, key: @repo)
+            query($key: String!) {
+              teams(filter: { key: { eq: $key } }) { nodes { id } }
+            }
+          GRAPHQL
+          data&.dig("teams", "nodes", 0, "id")
+        end
+      end
+
+      # Pick the first workflow state whose type matches, in preference order
+      def workflow_state_id(preferred_types)
+        states = workflow_states
+        return nil unless states
+
+        preferred_types.each do |type|
+          match = states.find { |s| s["type"] == type }
+          return match["id"] if match
+        end
+        nil
+      end
+
+      def workflow_states
+        @workflow_states ||= begin
+          data = graphql(<<~GRAPHQL, key: @repo)
+            query($key: String!) {
+              workflowStates(filter: { team: { key: { eq: $key } } }) {
+                nodes { id name type position }
+              }
+            }
+          GRAPHQL
+          data&.dig("workflowStates", "nodes")&.sort_by { |s| s["position"].to_f }
+        end
+      end
+
+      # Best-effort: resolve label names to UUIDs, creating missing ones.
+      # Label failures must never block issue creation.
+      def resolve_label_ids(names)
+        names = Array(names).map(&:to_s).reject(&:empty?)
+        return [] if names.empty?
+
+        data = graphql(<<~GRAPHQL, names: names)
+          query($names: [String!]) {
+            issueLabels(filter: { name: { in: $names } }) { nodes { id name } }
+          }
+        GRAPHQL
+        existing = data&.dig("issueLabels", "nodes") || []
+        ids = existing.map { |l| l["id"] }
+
+        missing = names - existing.map { |l| l["name"] }
+        missing.each do |name|
+          created = graphql(<<~GRAPHQL, input: { name: name, teamId: team_id })
+            mutation($input: IssueLabelCreateInput!) {
+              issueLabelCreate(input: $input) { issueLabel { id } }
+            }
+          GRAPHQL
+          id = created&.dig("issueLabelCreate", "issueLabel", "id")
+          ids << id if id
+        end
+
+        ids
+      rescue
+        []
+      end
+
+      # Execute a GraphQL request. Returns the "data" hash, or nil on any
+      # error (with the message stashed in @last_error for the caller).
+      def graphql(query, variables = {})
+        @last_error = nil
+        response = http_post(@api_url, { query: query, variables: variables }, auth_headers)
+
+        if response[:status] != 200
+          message = response.dig(:body, "errors", 0, "message") || response[:error]
+          @last_error = "Linear API error (#{response[:status]}): #{message}"
+          return nil
+        end
+
+        errors = response.dig(:body, "errors")
+        if errors.present?
+          @last_error = "Linear API error: #{errors.first["message"]}"
+          return nil
+        end
+
+        response.dig(:body, "data")
+      end
+
+      def auth_headers
+        # Personal API keys are passed bare; OAuth tokens need a Bearer prefix
+        value = @token.to_s.start_with?("lin_api_") ? @token : "Bearer #{@token}"
+        { "Authorization" => value }
+      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.1"
 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"
@@ -67,6 +68,7 @@ require "rails_error_dashboard/services/issue_tracker_client"
 require "rails_error_dashboard/services/github_issue_client"
 require "rails_error_dashboard/services/gitlab_issue_client"
 require "rails_error_dashboard/services/codeberg_issue_client"
+require "rails_error_dashboard/services/linear_issue_client"
 require "rails_error_dashboard/services/database_health_inspector"
 require "rails_error_dashboard/services/cache_analyzer"
 require "rails_error_dashboard/services/llm_summary"

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.1
 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
@@ -462,6 +463,7 @@ files:
 - lib/rails_error_dashboard/services/gitlab_issue_client.rb
 - lib/rails_error_dashboard/services/issue_body_formatter.rb
 - lib/rails_error_dashboard/services/issue_tracker_client.rb
+- lib/rails_error_dashboard/services/linear_issue_client.rb
 - lib/rails_error_dashboard/services/llm_client.rb
 - lib/rails_error_dashboard/services/llm_cost_estimator.rb
 - lib/rails_error_dashboard/services/llm_summary.rb
@@ -510,7 +512,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.1
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   First install: