opentrace 0.3.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 415cb9523a3c54703221a0604c9a301eb47b9f71c99737fcc194ced1d28ea178
-  data.tar.gz: cb6d7f5a295c27bb68ff51a79b196297b18fe3ef568ac9e788c3d010828d2092
+  metadata.gz: 6e068caf2607eb830f1a48fbe159ac7f62d45111e26ebcb0928b9ff38bee5a3a
+  data.tar.gz: d2756da1df81af0b50af32dd769934fc88f57ea1647a8324f0511b9ba8586121
 SHA512:
-  metadata.gz: 5e1a1a6f4d72827d11d4d879c867afd98e96e8fead065232a1e64fd32c74c309c3db52fde64ab60f24b0a40884cac78177e5b368a998cf14b026c0ca85388277
-  data.tar.gz: 3d3c85e68ac60f2d25824a2ec687fec9f7e31f40ba25c6fb3ca3fa031c9f2abff677ffbde978a93de430538cb7adeea9e1f907ba4f8481ecf32270121dea5196
+  metadata.gz: a051a516258c16868c88429cef1ded592f7662f67090c8865695ae63c5a71777d83178a9660440d11991c19139c13f9ee8d039cc792291077866fc6c1fdc21cd
+  data.tar.gz: 148e7476274f8f68a881d605f5f151febf6b3e1e86f7bac2c39a5f6d441e1d9eb3dada4ae497762c91040a88b7f29bd6ce366f882059f00513479a72632918e2

data/README.md

@@ -19,7 +19,7 @@ A thin, safe Ruby client that forwards structured application logs to an [OpenTr
 - **Works with any server** -- Puma (threads), Unicorn (forks), Passenger, and Falcon (fibers)
 - **Fork safe** -- detects forked worker processes and re-initializes cleanly
 - **Fiber safe** -- uses `Fiber[]` storage for correct request isolation in fiber-based servers
-- **Rails integration** -- auto-instruments controllers, SQL queries, and ActiveJob via Railtie
+- **Rails integration** -- auto-instruments controllers, SQL queries, ActiveJob, views, cache, and more
 - **Rack middleware** -- propagates `request_id` via fiber-local storage
 - **Logger wrapper** -- drop-in replacement that forwards to OpenTrace while keeping your original logger
 - **Rails 7.1+ BroadcastLogger** -- native support via `broadcast_to`
@@ -27,9 +27,17 @@ A thin, safe Ruby client that forwards structured application logs to an [OpenTr
 - **Context support** -- attach global metadata to every log via Hash or Proc
 - **Level filtering** -- `min_level` config to control which severities are forwarded
 - **Auto-enrichment** -- every log includes `hostname`, `pid`, and `git_sha` automatically
-- **Exception helper** -- `OpenTrace.error` captures class, message, and cleaned backtrace
+- **Exception helper** -- `OpenTrace.error` captures class, message, cleaned backtrace, and error fingerprint
 - **Runtime controls** -- enable/disable logging at runtime without restarting
 - **Graceful shutdown** -- pending logs are flushed automatically on process exit
+- **N+1 query detection** -- warns when a request exceeds 20 SQL queries
+- **Per-request summary** -- one rich log per request with SQL, view, cache breakdown and timeline
+- **Error fingerprinting** -- stable fingerprint for grouping identical errors across requests
+- **Deprecation tracking** -- captures Rails deprecation warnings with callsite
+- **DB pool monitoring** -- background thread reports connection pool saturation (opt-in)
+- **Job queue depth** -- monitors Sidekiq, GoodJob, or SolidQueue queue sizes (opt-in)
+- **Memory delta tracking** -- snapshots process RSS before/after each request (opt-in)
+- **External HTTP tracking** -- captures outbound Net::HTTP calls with timing (opt-in)
 
 ## Installation
 
@@ -95,6 +103,24 @@ OpenTrace.configure do |c|
   # SQL logging (Rails only)
   c.sql_logging = true                   # default: true
   c.sql_duration_threshold_ms = 100.0    # only log queries slower than this (default: 0.0 = all)
+
+  # Path filtering
+  c.ignore_paths = ["/health", %r{\A/assets/}]  # skip noisy paths (default: [])
+
+  # Per-request summary (Rails only)
+  c.request_summary = true               # accumulate events into one rich log (default: true)
+  c.timeline = true                      # include event timeline in summary (default: true)
+  c.timeline_max_events = 200            # cap timeline entries (default: 200)
+
+  # Background monitors (opt-in)
+  c.pool_monitoring = false              # DB connection pool stats (default: false)
+  c.pool_monitoring_interval = 30        # seconds between checks (default: 30)
+  c.queue_monitoring = false             # job queue depth monitoring (default: false)
+  c.queue_monitoring_interval = 60       # seconds between checks (default: 60)
+
+  # Advanced opt-in features
+  c.memory_tracking = false              # RSS delta per request (default: false)
+  c.http_tracking = false                # external HTTP call tracking (default: false)
 end
 ```
 
@@ -134,7 +160,7 @@ Pass `trace_id` inside metadata and it will be promoted to a top-level field aut
 
 ### Exception Logging
 
-Use `OpenTrace.error` to log exceptions with automatic class, message, and backtrace extraction:
+Use `OpenTrace.error` to log exceptions with automatic class, message, backtrace, and fingerprint extraction:
 
 ```ruby
 begin
@@ -148,6 +174,7 @@ This captures:
 - `exception_class` -- the exception class name
 - `exception_message` -- truncated to 500 characters
 - `backtrace` -- cleaned (Rails backtrace cleaner or gem-filtered), limited to 15 frames
+- `error_fingerprint` -- 12-char hash for grouping identical errors (stable across line number changes)
 
 ### Logger Wrapper
 
@@ -220,6 +247,63 @@ Request IDs are stored using `Fiber[]` (fiber-local storage), which works correc
 
 All your existing `Rails.logger.info(...)` calls automatically get forwarded to OpenTrace.
 
+### Per-Request Summary
+
+When `request_summary` is enabled (the default), the gem accumulates all events during a request -- SQL queries, view renders, cache operations, HTTP calls -- into a single rich log entry emitted at request end. This avoids flooding the queue with hundreds of individual events.
+
+Example payload:
+
+```json
+{
+  "level": "INFO",
+  "message": "GET /dashboard 200 2847ms",
+  "metadata": {
+    "request_id": "req-abc123",
+    "controller": "DashboardController",
+    "action": "index",
+    "method": "GET",
+    "path": "/dashboard",
+    "status": 200,
+    "duration_ms": 2847.3,
+
+    "request_user_agent": "Mozilla/5.0...",
+    "request_accept": "text/html",
+
+    "sql_query_count": 34,
+    "sql_total_ms": 423.1,
+    "sql_slowest_ms": 312.0,
+    "sql_slowest_name": "Order Count",
+    "n_plus_one_warning": true,
+
+    "view_render_count": 48,
+    "view_total_ms": 890.2,
+    "view_slowest_ms": 245.0,
+    "view_slowest_template": "dashboard/_activity_feed.html.erb",
+
+    "cache_reads": 8,
+    "cache_hits": 5,
+    "cache_writes": 3,
+    "cache_hit_ratio": 0.63,
+
+    "time_breakdown": {
+      "sql_pct": 14.9,
+      "view_pct": 31.3,
+      "http_pct": 0.0,
+      "other_pct": 53.8
+    },
+
+    "timeline": [
+      { "t": "sql", "n": "User Load", "ms": 1.2, "at": 0.0 },
+      { "t": "cache", "a": "read", "hit": true, "ms": 0.1, "at": 6.0 },
+      { "t": "sql", "n": "Order Count", "ms": 312.0, "at": 10.0 },
+      { "t": "view", "n": "dashboard/index.html.erb", "ms": 890.2, "at": 350.0 }
+    ]
+  }
+}
+```
+
+The timeline shows a waterfall of events in chronological order. Timeline keys are kept short to minimize payload size: `t` = type, `n` = name, `ms` = duration, `at` = offset from request start, `s` = status, `a` = action.
+
 ### Controller Subscriber
 
 Subscribes to `process_action.action_controller` and captures:
@@ -238,12 +322,26 @@ Subscribes to `process_action.action_controller` and captures:
 | `exception_class` | Exception class (if raised) |
 | `exception_message` | Exception message (if raised) |
 | `backtrace` | Cleaned backtrace (if exception raised) |
+| `error_fingerprint` | 12-char fingerprint for error grouping |
+| `request_content_type` | Request Content-Type header |
+| `request_accept` | Request Accept header |
+| `request_user_agent` | Request User-Agent (truncated to 200 chars) |
+| `request_referer` | Request Referer header |
+| `sql_query_count` | Total SQL queries in this request |
+| `sql_total_ms` | Total SQL time in this request |
+| `n_plus_one_warning` | `true` when query count exceeds 20 |
+
+When request summary is enabled, the log also includes view render stats, cache stats, time breakdown, and timeline (see above).
 
 Log levels are set automatically:
 - **ERROR** -- exceptions or 5xx status
 - **WARN** -- 4xx status
 - **INFO** -- everything else
 
+### N+1 Query Detection
+
+Every request tracks the number of SQL queries via a Fiber-local counter. When a request exceeds 20 queries, the log entry includes `n_plus_one_warning: true`. This makes it easy to query OpenTrace for requests with potential N+1 issues.
+
 ### SQL Query Subscriber
 
 Subscribes to `sql.active_record` and logs every query with:
@@ -280,12 +378,54 @@ Subscribes to `perform.active_job` and logs every job execution with:
 | `executions` | Attempt number |
 | `duration_ms` | Execution duration |
 | `job_arguments` | Serialized arguments (truncated to 512 bytes) |
+| `queue_latency_ms` | Time spent waiting in queue before execution |
+| `enqueued_at` | When the job was enqueued |
 | `exception_class` | Exception class (if failed) |
 | `exception_message` | Exception message (if failed) |
 | `backtrace` | Cleaned backtrace (if failed) |
+| `error_fingerprint` | Fingerprint for error grouping (if failed) |
 
 Failed jobs are logged as `ERROR`, successful jobs as `INFO`.
 
+### Deprecation Warning Subscriber
+
+Subscribes to `deprecation.rails` and logs all Rails deprecation warnings as `WARN`:
+
+| Field | Description |
+|---|---|
+| `deprecation_message` | The deprecation message (truncated to 500 chars) |
+| `deprecation_callsite` | File and line where the deprecated API was called |
+| `request_id` | Current request ID (if in web context) |
+
+### View Render Tracking
+
+When request summary is enabled, subscribes to `render_template.action_view` and `render_partial.action_view`. View render events are accumulated in the RequestCollector and included in the per-request summary -- **no individual log entries are emitted** for views.
+
+The summary includes:
+- `view_render_count` -- total number of templates/partials rendered
+- `view_total_ms` -- total rendering time
+- `view_slowest_ms` / `view_slowest_template` -- the bottleneck template
+
+Template paths are automatically shortened (e.g., `/Users/deploy/app/views/orders/show.html.erb` becomes `orders/show.html.erb`).
+
+### Cache Operation Tracking
+
+When request summary is enabled, subscribes to `cache_read.active_support`, `cache_write.active_support`, and `cache_delete.active_support`. Like views, cache events are accumulated -- no individual logs.
+
+The summary includes:
+- `cache_reads` / `cache_hits` / `cache_writes`
+- `cache_hit_ratio` -- hit rate (0.0 to 1.0)
+
+### Error Fingerprinting
+
+Every error (in controller requests, job failures, and `OpenTrace.error` calls) includes an `error_fingerprint` -- a 12-character hash derived from the exception class and the first application frame in the backtrace. The fingerprint is:
+
+- **Stable across deploys** -- line number changes don't affect it
+- **Same error, same fingerprint** -- different error messages at the same location produce the same fingerprint
+- **Different error, different fingerprint** -- different exception classes or different code locations produce different fingerprints
+
+Use it to group and count errors in OpenTrace.
+
 ### TaggedLogging
 
 If your wrapped logger uses `ActiveSupport::TaggedLogging`, tags are preserved and injected into the metadata:
@@ -297,6 +437,90 @@ Rails.logger.tagged("RequestID-123", "UserID-42") do
 end
 ```
 
+## Background Monitors
+
+### DB Connection Pool Monitoring
+
+Opt-in background thread that periodically reports ActiveRecord connection pool stats:
+
+```ruby
+OpenTrace.configure do |c|
+  # ...
+  c.pool_monitoring = true
+  c.pool_monitoring_interval = 30  # seconds (default: 30)
+end
+```
+
+Reports `pool_size`, `connections_busy`, `connections_idle`, `threads_waiting`, and `checkout_timeout`. Logs at `WARN` when threads are waiting for a connection, `DEBUG` otherwise.
+
+### Job Queue Depth Monitoring
+
+Opt-in background thread that reports job queue sizes. Supports Sidekiq, GoodJob, and SolidQueue (auto-detected):
+
+```ruby
+OpenTrace.configure do |c|
+  # ...
+  c.queue_monitoring = true
+  c.queue_monitoring_interval = 60  # seconds (default: 60)
+end
+```
+
+Reports per-queue sizes and total enqueued count. Logs at `WARN` when total exceeds 1,000.
+
+## Advanced Opt-In Features
+
+These features have measurable overhead or implementation risks. **Disabled by default.** Enable them after testing in staging.
+
+### Memory Delta Tracking
+
+Snapshots process memory (RSS) before and after each request:
+
+```ruby
+OpenTrace.configure do |c|
+  # ...
+  c.memory_tracking = true
+end
+```
+
+Adds to the request summary:
+- `memory_before_mb` -- RSS before request
+- `memory_after_mb` -- RSS after request
+- `memory_delta_mb` -- difference (positive = memory grew)
+
+Uses `/proc/self/statm` on Linux (~10us) or `GC.stat` approximation on macOS (~5us). The delta is process-level, so concurrent requests will affect accuracy. Most accurate on single-threaded servers (Unicorn).
+
+### External HTTP Tracking
+
+Instruments outbound `Net::HTTP` calls to capture third-party API performance:
+
+```ruby
+OpenTrace.configure do |c|
+  # ...
+  c.http_tracking = true
+end
+```
+
+Adds to the request summary:
+- `http_external_count` -- number of outbound HTTP calls
+- `http_external_total_ms` -- total time in external calls
+- `http_slowest_ms` / `http_slowest_host` -- the bottleneck
+
+Each HTTP call appears in the timeline:
+
+```json
+{ "t": "http", "n": "POST api.stripe.com", "ms": 184.0, "s": 200, "at": 55.0 }
+```
+
+Failed calls include an error type:
+
+```json
+{ "t": "http", "n": "POST api.stripe.com", "ms": 5200.0, "s": 0, "err": "Net::ReadTimeout", "at": 55.0 }
+```
+
+A recursion guard prevents OpenTrace's own HTTP calls to the server from being tracked. The `time_breakdown` in the request summary includes `http_pct` alongside `sql_pct` and `view_pct`.
+
+**Note**: This works by prepending a module to `Net::HTTP`. Libraries that use `Net::HTTP` internally (Faraday, HTTParty, RestClient) are automatically captured.
+
 ## Runtime Controls
 
 ```ruby
@@ -349,6 +573,25 @@ Your App --log()--> [In-Memory Queue] --background thread--> POST /api/logs -->
 - The HTTP timeout defaults to 1 second
 - Pending logs are flushed on process exit via an `at_exit` hook
 
+### Request Summary Architecture
+
+When `request_summary` is enabled, events within a request are **accumulated** in a Fiber-local `RequestCollector` instead of being pushed to the queue individually:
+
+```
+Request Start
+  Middleware creates RequestCollector in Fiber[]
+    SQL events ──► collector.record_sql()      (no queue push)
+    View events ──► collector.record_view()    (no queue push)
+    Cache events ──► collector.record_cache()  (no queue push)
+    HTTP events ──► collector.record_http()    (no queue push)
+  Request End
+    Controller subscriber merges collector.summary() into one log
+    One queue push with everything
+  Middleware cleans up RequestCollector
+```
+
+This means a request with 30 SQL queries, 50 view renders, and 10 cache operations produces **one log entry** instead of 91.
+
 ## Log Payload Format
 
 Each log is sent as a JSON object to `POST /api/logs`:

data/lib/opentrace/client.rb

@@ -127,6 +127,9 @@ module OpenTrace
     end
 
     def send_batch(uri, batch)
+      # Disable HTTP tracking for our own calls to prevent infinite recursion
+      Fiber[:opentrace_http_tracking_disabled] = true
+
       # Apply per-payload truncation
       batch = batch.map { |p| fit_payload(p) }.compact
       return if batch.empty?
@@ -151,6 +154,8 @@ module OpenTrace
       http.request(request)
     rescue StandardError
       # Swallow all network errors silently
+    ensure
+      Fiber[:opentrace_http_tracking_disabled] = nil
     end
 
     def build_http(uri)

data/lib/opentrace/config.rb

@@ -9,7 +9,11 @@ module OpenTrace
                   :context, :min_level, :hostname, :pid, :git_sha,
                   :batch_size, :flush_interval,
                   :sql_logging, :sql_duration_threshold_ms,
-                  :ignore_paths
+                  :ignore_paths,
+                  :pool_monitoring, :pool_monitoring_interval,
+                  :queue_monitoring, :queue_monitoring_interval,
+                  :request_summary, :timeline, :timeline_max_events,
+                  :memory_tracking, :http_tracking
 
     def initialize
       @endpoint    = nil
@@ -28,6 +32,15 @@ module OpenTrace
       @sql_logging    = true
       @sql_duration_threshold_ms = 0.0
       @ignore_paths   = []
+      @pool_monitoring = false
+      @pool_monitoring_interval = 30
+      @queue_monitoring = false
+      @queue_monitoring_interval = 60
+      @request_summary = true
+      @timeline = true
+      @timeline_max_events = 200
+      @memory_tracking = false
+      @http_tracking = false
     end
 
     def valid?

data/lib/opentrace/http_tracker.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module OpenTrace
+  module HttpTracker
+    def request(req, body = nil, &block)
+      # Guard 1: skip if disabled
+      return super unless OpenTrace.enabled?
+
+      # Guard 2: skip if this IS an OpenTrace dispatch call (prevent infinite recursion)
+      return super if Fiber[:opentrace_http_tracking_disabled]
+
+      collector = Fiber[:opentrace_collector]
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      response = super
+
+      duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000
+      host = address
+      port_str = (port == 443 || port == 80) ? "" : ":#{port}"
+      scheme = use_ssl? ? "https" : "http"
+      url = "#{scheme}://#{host}#{port_str}#{req.path}"
+
+      if collector
+        collector.record_http(
+          method: req.method,
+          url: url,
+          host: host,
+          status: response.code.to_i,
+          duration_ms: duration_ms
+        )
+      end
+
+      response
+    rescue IOError, SystemCallError, OpenSSL::SSL::SSLError, Timeout::Error, Net::ProtocolError => e
+      # Record the failed HTTP call, then re-raise
+      duration_ms = start_time ? (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000 : 0
+
+      if collector
+        collector.record_http(
+          method: req&.method,
+          url: "#{address}#{req&.path}",
+          host: address,
+          status: 0,
+          duration_ms: duration_ms,
+          error: e.class.name
+        )
+      end
+
+      raise # ALWAYS re-raise — never swallow app errors
+    end
+  end
+end

data/lib/opentrace/middleware.rb

@@ -9,10 +9,51 @@ module OpenTrace
     def call(env)
       request_id = env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"]
       OpenTrace.current_request_id = request_id
+      Fiber[:opentrace_sql_count] = 0
+      Fiber[:opentrace_sql_total_ms] = 0.0
+
+      # Create RequestCollector for accumulate-and-summarize pattern
+      if OpenTrace.enabled? && OpenTrace.config.request_summary
+        require_relative "request_collector"
+        collector = OpenTrace::RequestCollector.new(
+          max_timeline: OpenTrace.config.timeline_max_events
+        )
+        Fiber[:opentrace_collector] = collector
+
+        # Memory snapshot before request (opt-in)
+        if OpenTrace.config.memory_tracking
+          collector.memory_before = current_rss_mb
+        end
+      end
 
       @app.call(env)
     ensure
+      # Memory snapshot after request (opt-in)
+      collector = Fiber[:opentrace_collector]
+      if collector && OpenTrace.config.memory_tracking && collector.memory_before
+        collector.memory_after = current_rss_mb
+      end
+
+      Fiber[:opentrace_collector] = nil
+      Fiber[:opentrace_sql_count] = nil
+      Fiber[:opentrace_sql_total_ms] = nil
       OpenTrace.current_request_id = nil
     end
+
+    private
+
+    def current_rss_mb
+      if RUBY_PLATFORM.include?("linux")
+        # Linux: read from /proc — no fork, ~10μs
+        File.read("/proc/self/statm").split[1].to_i * 4096.0 / 1024 / 1024
+      else
+        # macOS/other: use GC.stat as lightweight approximation
+        # Avoids forking a `ps` subprocess which costs 2-5ms
+        gc = GC.stat
+        gc[:heap_live_slots].to_f * 40 / 1024 / 1024 # rough estimate: ~40 bytes per slot
+      end
+    rescue StandardError
+      nil
+    end
   end
 end

data/lib/opentrace/pool_monitor.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module OpenTrace
+  class PoolMonitor
+    DEFAULT_INTERVAL = 30 # seconds
+
+    def initialize(interval: DEFAULT_INTERVAL)
+      @interval = interval
+      @thread = nil
+      @running = false
+    end
+
+    def start
+      return if @running
+      @running = true
+
+      @thread = Thread.new do
+        Thread.current.report_on_exception = false
+        loop do
+          sleep @interval
+          break unless @running
+          report_pool_stats
+        rescue Exception # rubocop:disable Lint/RescueException
+          # Swallow — never crash the host app
+        end
+      end
+    end
+
+    def stop
+      @running = false
+      @thread&.join(2)
+    end
+
+    private
+
+    def report_pool_stats
+      return unless OpenTrace.enabled?
+      return unless defined?(::ActiveRecord::Base)
+
+      pool = ActiveRecord::Base.connection_pool
+      stat = pool.stat
+
+      metadata = {
+        metric_type: "db_pool",
+        pool_size: stat[:size],
+        connections_busy: stat[:busy],
+        connections_dead: stat[:dead],
+        connections_idle: stat[:idle],
+        threads_waiting: stat[:waiting],
+        checkout_timeout: stat[:checkout_timeout]
+      }
+
+      level = stat[:waiting].to_i > 0 ? "WARN" : "DEBUG"
+      message = "DB pool: #{stat[:busy]}/#{stat[:size]} busy, #{stat[:waiting]} waiting"
+
+      OpenTrace.log(level, message, metadata)
+    end
+  end
+end

data/lib/opentrace/queue_monitor.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module OpenTrace
+  class QueueMonitor
+    DEFAULT_INTERVAL = 60 # seconds
+
+    def initialize(interval: DEFAULT_INTERVAL)
+      @interval = interval
+      @thread = nil
+      @running = false
+    end
+
+    def start
+      return if @running
+      @running = true
+
+      @thread = Thread.new do
+        Thread.current.report_on_exception = false
+        loop do
+          sleep @interval
+          break unless @running
+          report_queue_stats
+        rescue Exception # rubocop:disable Lint/RescueException
+          # Swallow
+        end
+      end
+    end
+
+    def stop
+      @running = false
+      @thread&.join(2)
+    end
+
+    private
+
+    def report_queue_stats
+      return unless OpenTrace.enabled?
+
+      queues = collect_queue_data
+      return if queues.nil? || queues.empty?
+
+      total_enqueued = queues.values.sum { |q| q[:size] }
+
+      metadata = {
+        metric_type: "queue_depth",
+        queues: queues,
+        total_enqueued: total_enqueued,
+        adapter: detect_adapter
+      }
+
+      level = total_enqueued > 1000 ? "WARN" : "INFO"
+      summary = queues.map { |name, data| "#{name}=#{data[:size]}" }.join(", ")
+      message = "Queue stats: #{summary}"
+
+      OpenTrace.log(level, message, metadata)
+    end
+
+    def detect_adapter
+      if defined?(::Sidekiq::Queue)
+        "sidekiq"
+      elsif defined?(::GoodJob::Job)
+        "good_job"
+      elsif defined?(::SolidQueue::ReadyExecution)
+        "solid_queue"
+      end
+    end
+
+    def collect_queue_data
+      case detect_adapter
+      when "sidekiq"     then sidekiq_stats
+      when "good_job"    then good_job_stats
+      when "solid_queue" then solid_queue_stats
+      end
+    rescue StandardError
+      nil
+    end
+
+    def sidekiq_stats
+      queues = {}
+      Sidekiq::Queue.all.each do |queue|
+        queues[queue.name] = {
+          size: queue.size,
+          latency_ms: (queue.latency * 1000).round(1)
+        }
+      end
+      queues
+    end
+
+    def good_job_stats
+      queues = {}
+      GoodJob::Job.where(finished_at: nil)
+                   .group(:queue_name)
+                   .count
+                   .each do |name, count|
+        queues[name] = { size: count }
+      end
+      queues
+    end
+
+    def solid_queue_stats
+      queues = {}
+      SolidQueue::ReadyExecution.group(:queue_name)
+                                 .count
+                                 .each do |name, count|
+        queues[name] = { size: count }
+      end
+      queues
+    end
+  end
+end

data/lib/opentrace/rails.rb

@@ -34,14 +34,59 @@ if defined?(::Rails::Railtie)
           # Swallow - never affect the host app
         end
 
-        # Subscribe to SQL query notifications
+        # Subscribe to SQL query notifications (also increments N+1 counter and feeds collector)
         if OpenTrace.config.sql_logging
           ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
             event = ActiveSupport::Notifications::Event.new(*args)
+
+            # Increment per-request SQL counter (Fiber-local, zero-cost)
+            if Fiber[:opentrace_sql_count]
+              Fiber[:opentrace_sql_count] += 1
+              Fiber[:opentrace_sql_total_ms] = (Fiber[:opentrace_sql_total_ms] || 0.0) + (event.duration || 0.0)
+            end
+
+            # Feed RequestCollector for timeline & summary
+            collector = Fiber[:opentrace_collector]
+            if collector
+              payload = event.payload
+              unless payload[:name] == "SCHEMA"
+                table = nil
+                if payload[:sql] =~ /\b(?:FROM|INTO|UPDATE|JOIN)\s+[`"]?(\w+)[`"]?/i
+                  table = $1
+                end
+                collector.record_sql(name: payload[:name], duration_ms: event.duration || 0.0, table: table)
+              end
+            end
+
             forward_sql_log(event)
           rescue StandardError
             # Swallow
           end
+        else
+          # Even when sql_logging is off, still count queries for N+1 detection and feed collector
+          ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+
+            if Fiber[:opentrace_sql_count]
+              Fiber[:opentrace_sql_count] += 1
+              Fiber[:opentrace_sql_total_ms] = (Fiber[:opentrace_sql_total_ms] || 0.0) + (event.duration || 0.0)
+            end
+
+            # Feed RequestCollector for timeline & summary
+            collector = Fiber[:opentrace_collector]
+            if collector
+              payload = event.payload
+              unless payload[:name] == "SCHEMA"
+                table = nil
+                if payload[:sql] =~ /\b(?:FROM|INTO|UPDATE|JOIN)\s+[`"]?(\w+)[`"]?/i
+                  table = $1
+                end
+                collector.record_sql(name: payload[:name], duration_ms: event.duration || 0.0, table: table)
+              end
+            end
+          rescue StandardError
+            # Swallow
+          end
         end
 
         # Subscribe to ActiveJob notifications
@@ -51,6 +96,73 @@ if defined?(::Rails::Railtie)
         rescue StandardError
           # Swallow
         end
+
+        # Subscribe to deprecation warnings
+        ActiveSupport::Notifications.subscribe("deprecation.rails") do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          forward_deprecation_log(event)
+        rescue StandardError
+          # Swallow
+        end
+
+        # View render tracking (only records when RequestCollector exists)
+        %w[render_template.action_view render_partial.action_view].each do |event_name|
+          ActiveSupport::Notifications.subscribe(event_name) do |*args|
+            collector = Fiber[:opentrace_collector]
+            next unless collector
+
+            event = ActiveSupport::Notifications::Event.new(*args)
+            template = event.payload[:identifier]
+            # Shorten: /Users/deploy/app/views/orders/show.html.erb → orders/show.html.erb
+            template = template.split("views/").last if template&.include?("views/")
+
+            collector.record_view(template: template, duration_ms: event.duration || 0.0)
+          rescue StandardError
+            # Swallow
+          end
+        end
+
+        # Cache operation tracking (only records when RequestCollector exists)
+        %w[cache_read.active_support cache_write.active_support cache_delete.active_support].each do |event_name|
+          ActiveSupport::Notifications.subscribe(event_name) do |*args|
+            collector = Fiber[:opentrace_collector]
+            next unless collector
+
+            event = ActiveSupport::Notifications::Event.new(*args)
+            action = event_name.split(".").first.sub("cache_", "").to_sym # :read, :write, :delete
+
+            collector.record_cache(
+              action: action,
+              hit: event.payload[:hit],
+              duration_ms: event.duration || 0.0
+            )
+          rescue StandardError
+            # Swallow
+          end
+        end
+
+        # External HTTP tracking (opt-in, prepends Net::HTTP)
+        if OpenTrace.config.http_tracking
+          require_relative "http_tracker"
+          Net::HTTP.prepend(OpenTrace::HttpTracker)
+        end
+
+        # Start background monitors (opt-in)
+        if OpenTrace.config.pool_monitoring
+          require_relative "pool_monitor"
+          @pool_monitor = OpenTrace::PoolMonitor.new(
+            interval: OpenTrace.config.pool_monitoring_interval
+          )
+          @pool_monitor.start
+        end
+
+        if OpenTrace.config.queue_monitoring
+          require_relative "queue_monitor"
+          @queue_monitor = OpenTrace::QueueMonitor.new(
+            interval: OpenTrace.config.queue_monitoring_interval
+          )
+          @queue_monitor.start
+        end
       end
 
       class << self
@@ -75,7 +187,7 @@ if defined?(::Rails::Railtie)
           user_id = extract_user_id(payload)
           metadata[:user_id] = user_id if user_id
 
-          # Exception auto-capture
+          # Exception auto-capture with fingerprinting
           if payload[:exception]
             metadata[:exception_class]   = payload[:exception][0]
             metadata[:exception_message] = truncate(payload[:exception][1], 500)
@@ -84,11 +196,42 @@ if defined?(::Rails::Railtie)
           if payload[:exception_object]&.backtrace
             cleaned = clean_backtrace(payload[:exception_object].backtrace)
             metadata[:backtrace] = cleaned.first(15)
+            metadata[:error_fingerprint] = OpenTrace.send(:compute_error_fingerprint,
+              payload[:exception][0], cleaned)
           end
 
           # Filtered request params
           extract_params(payload, metadata)
 
+          # Request headers
+          extract_request_headers(payload, metadata)
+
+          # Merge collector summary (Phase 2) or fall back to Fiber-local counters (Phase 1)
+          collector = Fiber[:opentrace_collector]
+          if collector
+            metadata.merge!(collector.summary)
+
+            # Compute time breakdown
+            total = event.duration || 0.0
+            if total > 0
+              sql_pct = [((collector.sql_total_ms / total) * 100).round(1), 100.0].min
+              view_pct = [((collector.view_total_ms / total) * 100).round(1), 100.0].min
+              http_pct = collector.http_count > 0 ? [((collector.http_total_ms / total) * 100).round(1), 100.0].min : 0.0
+              other_pct = [100 - sql_pct - view_pct - http_pct, 0].max.round(1)
+              metadata[:time_breakdown] = {
+                sql_pct: sql_pct,
+                view_pct: view_pct,
+                http_pct: http_pct,
+                other_pct: other_pct
+              }
+            end
+          elsif Fiber[:opentrace_sql_count]
+            # Fallback: Phase 1 N+1 counter from Fiber-locals
+            metadata[:sql_query_count] = Fiber[:opentrace_sql_count]
+            metadata[:sql_total_ms] = Fiber[:opentrace_sql_total_ms]&.round(1)
+            metadata[:n_plus_one_warning] = true if Fiber[:opentrace_sql_count] > 20
+          end
+
           level = if payload[:exception]
                     "ERROR"
                   elsif payload[:status].to_i >= 500
@@ -119,6 +262,19 @@ if defined?(::Rails::Railtie)
             duration_ms: event.duration&.round(1)
           }.compact
 
+          # Queue latency calculation
+          if job.respond_to?(:enqueued_at) && job.enqueued_at
+            enqueued_at = case job.enqueued_at
+                          when Time then job.enqueued_at
+                          when String then Time.parse(job.enqueued_at)
+                          end
+            if enqueued_at
+              queue_latency_s = Time.now.utc - enqueued_at.utc
+              metadata[:queue_latency_ms] = (queue_latency_s * 1000).round(1) if queue_latency_s > 0
+              metadata[:enqueued_at] = enqueued_at.utc.strftime("%Y-%m-%dT%H:%M:%S.%6NZ")
+            end
+          end
+
           # Capture arguments (truncated)
           if job.respond_to?(:arguments)
             args_json = JSON.generate(job.arguments)
@@ -129,12 +285,15 @@ if defined?(::Rails::Railtie)
                                        end
           end
 
-          # Capture exceptions from job failures
+          # Capture exceptions from job failures with fingerprinting
           if payload[:exception_object]
             metadata[:exception_class]   = payload[:exception_object].class.name
             metadata[:exception_message] = truncate(payload[:exception_object].message, 500)
             if payload[:exception_object].backtrace
-              metadata[:backtrace] = clean_backtrace(payload[:exception_object].backtrace).first(15)
+              cleaned = clean_backtrace(payload[:exception_object].backtrace)
+              metadata[:backtrace] = cleaned.first(15)
+              metadata[:error_fingerprint] = OpenTrace.send(:compute_error_fingerprint,
+                payload[:exception_object].class.name, cleaned)
             end
           end
 
@@ -183,6 +342,40 @@ if defined?(::Rails::Railtie)
           # Swallow
         end
 
+        def forward_deprecation_log(event)
+          return unless OpenTrace.enabled?
+
+          payload = event.payload
+          message = payload[:message].to_s
+          callsite = payload[:callstack]&.first&.to_s
+
+          metadata = {
+            deprecation_message: truncate(message, 500),
+            deprecation_callsite: callsite
+          }.compact
+
+          metadata[:request_id] = OpenTrace.current_request_id if OpenTrace.current_request_id
+
+          OpenTrace.log("WARN", "DEPRECATION: #{truncate(message, 200)}", metadata)
+        rescue StandardError
+          # Swallow
+        end
+
+        def extract_request_headers(payload, metadata)
+          return unless payload[:headers]&.respond_to?(:env)
+
+          env = payload[:headers].env
+          headers = {
+            request_content_type: env["CONTENT_TYPE"],
+            request_accept: env["HTTP_ACCEPT"],
+            request_user_agent: truncate(env["HTTP_USER_AGENT"], 200),
+            request_referer: env["HTTP_REFERER"]
+          }.compact
+          metadata.merge!(headers) unless headers.empty?
+        rescue StandardError
+          # Swallow
+        end
+
         def extract_user_id(payload)
           controller = payload[:controller_instance]
           return unless controller

data/lib/opentrace/request_collector.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module OpenTrace
+  class RequestCollector
+    MAX_TIMELINE_EVENTS = 200
+
+    attr_reader :sql_count, :sql_total_ms,
+                :view_count, :view_total_ms,
+                :cache_reads, :cache_hits, :cache_writes,
+                :http_count, :http_total_ms
+    attr_accessor :memory_before, :memory_after
+
+    def initialize(max_timeline: MAX_TIMELINE_EVENTS)
+      @max_timeline = max_timeline
+
+      @sql_count = 0
+      @sql_total_ms = 0.0
+      @sql_slowest_ms = 0.0
+      @sql_slowest_name = nil
+
+      @view_count = 0
+      @view_total_ms = 0.0
+      @view_slowest_ms = 0.0
+      @view_slowest_template = nil
+
+      @cache_reads = 0
+      @cache_hits = 0
+      @cache_writes = 0
+      @cache_deletes = 0
+
+      @http_count = 0
+      @http_total_ms = 0.0
+      @http_slowest_ms = 0.0
+      @http_slowest_host = nil
+
+      @memory_before = nil
+      @memory_after = nil
+
+      @timeline = []
+      @request_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def record_sql(name:, duration_ms:, table: nil)
+      @sql_count += 1
+      @sql_total_ms += duration_ms
+
+      if duration_ms > @sql_slowest_ms
+        @sql_slowest_ms = duration_ms
+        @sql_slowest_name = name
+      end
+
+      append_timeline({ t: :sql, n: name, ms: duration_ms.round(1), at: offset_ms })
+    end
+
+    def record_view(template:, duration_ms:)
+      @view_count += 1
+      @view_total_ms += duration_ms
+
+      if duration_ms > @view_slowest_ms
+        @view_slowest_ms = duration_ms
+        @view_slowest_template = template
+      end
+
+      append_timeline({ t: :view, n: template, ms: duration_ms.round(1), at: offset_ms })
+    end
+
+    def record_cache(action:, hit: nil, duration_ms: 0.0)
+      case action
+      when :read
+        @cache_reads += 1
+        @cache_hits += 1 if hit
+      when :write
+        @cache_writes += 1
+      when :delete
+        @cache_deletes += 1
+      end
+
+      append_timeline({ t: :cache, a: action, hit: hit, ms: duration_ms.round(2), at: offset_ms })
+    end
+
+    def record_http(method:, url:, host:, status:, duration_ms:, error: nil)
+      @http_count += 1
+      @http_total_ms += duration_ms
+
+      if duration_ms > @http_slowest_ms
+        @http_slowest_ms = duration_ms
+        @http_slowest_host = host
+      end
+
+      entry = { t: :http, n: "#{method} #{host}", ms: duration_ms.round(1), s: status, at: offset_ms }
+      entry[:err] = error if error
+      append_timeline(entry)
+    end
+
+    def summary
+      result = {
+        sql_query_count: @sql_count,
+        sql_total_ms: @sql_total_ms.round(1),
+        sql_slowest_ms: @sql_slowest_ms.round(1),
+        sql_slowest_name: @sql_slowest_name,
+        view_render_count: @view_count,
+        view_total_ms: @view_total_ms.round(1),
+        view_slowest_ms: @view_slowest_ms.round(1),
+        view_slowest_template: @view_slowest_template,
+        cache_reads: @cache_reads,
+        cache_hits: @cache_hits,
+        cache_writes: @cache_writes,
+        cache_hit_ratio: @cache_reads > 0 ? (@cache_hits.to_f / @cache_reads).round(2) : nil,
+        n_plus_one_warning: @sql_count > 20 ? true : nil,
+        timeline: @timeline.empty? ? nil : @timeline
+      }
+
+      # HTTP stats (only present if calls were made)
+      if @http_count > 0
+        result[:http_external_count] = @http_count
+        result[:http_external_total_ms] = @http_total_ms.round(1)
+        result[:http_slowest_ms] = @http_slowest_ms.round(1)
+        result[:http_slowest_host] = @http_slowest_host
+      end
+
+      # Memory stats (only present if memory_tracking is enabled)
+      if @memory_before && @memory_after
+        result[:memory_before_mb] = @memory_before
+        result[:memory_after_mb] = @memory_after
+        result[:memory_delta_mb] = (@memory_after - @memory_before).round(1)
+      end
+
+      result.compact
+    end
+
+    private
+
+    def offset_ms
+      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - @request_start) * 1000).round(1)
+    end
+
+    def append_timeline(entry)
+      @timeline << entry if @timeline.size < @max_timeline
+    end
+  end
+end

data/lib/opentrace/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenTrace
-  VERSION = "0.3.0"
+  VERSION = "0.6.0"
 end

data/lib/opentrace.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "socket"
+require "digest"
 require_relative "opentrace/version"
 require_relative "opentrace/config"
 require_relative "opentrace/client"
@@ -70,6 +71,7 @@ module OpenTrace
                     exception.backtrace.reject { |l| l.include?("/gems/") }
                   end
         meta[:backtrace] = cleaned.first(15)
+        meta[:error_fingerprint] = compute_error_fingerprint(exception.class.name, cleaned)
       end
 
       log("ERROR", exception.message.to_s, meta)
@@ -145,6 +147,16 @@ module OpenTrace
       {}
     end
 
+    def compute_error_fingerprint(exception_class, backtrace)
+      origin = if backtrace.is_a?(Array)
+                 backtrace.find { |l| l.include?("app/") || l.include?("lib/") } || backtrace.first
+               end
+      normalized_origin = origin&.gsub(/:\d+:/, ":") || "unknown"
+      Digest::MD5.hexdigest("#{exception_class}||#{normalized_origin}")[0, 12]
+    rescue StandardError
+      nil
+    end
+
     def resolve_context
       ctx = case config.context
             when Proc then config.context.call

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opentrace
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.6.0
 platform: ruby
 authors:
 - OpenTrace
@@ -36,10 +36,14 @@ files:
 - lib/opentrace.rb
 - lib/opentrace/client.rb
 - lib/opentrace/config.rb
+- lib/opentrace/http_tracker.rb
 - lib/opentrace/log_forwarder.rb
 - lib/opentrace/logger.rb
 - lib/opentrace/middleware.rb
+- lib/opentrace/pool_monitor.rb
+- lib/opentrace/queue_monitor.rb
 - lib/opentrace/rails.rb
+- lib/opentrace/request_collector.rb
 - lib/opentrace/version.rb
 homepage: https://github.com/adham90/opentrace-ruby
 licenses: