dead_bro 0.2.31 → 0.2.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6c0f13b23ff342d0ea4365872e2f380a949a8aaf3fd69d98606336854d14c9c
-  data.tar.gz: a9b8a2fae51c26e7cd9b2f1d676c6742a5a5b4829f0c182417af7eabdf2581c6
+  metadata.gz: f1569a9a3be524d19ba616313570f01cb251647a76384347993655a8ffbaef9e
+  data.tar.gz: 3a091b0d844b12cfb9b61cf7b0d2eec04514bb5ef988fba7203d45b4ab237e67
 SHA512:
-  metadata.gz: e70b0d0b091dfacf1db61ea287a47bb1944153968bc3f225c943baf6a195c099dfd88199e59a942230284f3cfc94dcbf207d942e03630ac14850f818c1dc0928
-  data.tar.gz: 1e5f8605da3bf8c418d4c16025be5a24b7f89af1ca47d7bb6c767f790205c498e3023543b739b1568156547c21b8cfaf2bf327c573d8177aad88049e395352f2
+  metadata.gz: ebc44f95253369e7c8ab6f3873ed9143e0d72382c477bae39ca09491c22c93b236b2bc1dcc07599dd755797564f4a0f25f34104cf1f95246ea8d91fa9b4c1935
+  data.tar.gz: 6dd40034800398ceac4e82895d427e484ee7fd1b321a22882c1138c0e73514bfb4675a14437abd88cb6f4e5327c01ad85f2c7e75269956c4dd9d4e240a946714

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [0.2.32] - 2026-09-22
+
+### Fixed
+- **Errored requests now ship the SQL/cache/memory/etc data captured before the exception, not just the exception itself.** Previously, as soon as a request raised (e.g. an `ActiveRecord::LockWaitTimeout` mid-transaction), the subscriber discarded every already-captured `sql_queries`, `cache_events`, `ar_instantiation_count`, `memory_events`, `gc_stats`, etc. entry and sent only exception metadata — so error pages showed a backtrace with zero query context even when the gem had captured it. The error payload now carries the same detail fields a successful request would.
+- **Background job failures were reported to the dashboard as successful completions, not dropped.** There is no `exception.active_job` event anywhere in Rails/ActiveJob — the handler that subscribed to it never fired. `perform.active_job` (the real event) fires whether or not the job raised, but its handler built `status: "completed"` unconditionally and never inspected `data[:exception_object]`, so a failing job wasn't invisible — it was recorded as if it had succeeded. This silently skewed job success-rate and duration numbers for every account on a version prior to this one; there's nothing to backfill, since no exception data was ever sent for those occurrences. The handler now branches on `data[:exception_object]`: a failing job reports `status: "failed"` with `error`, `fingerprint`, and `cause_chain`, and ships regardless of sampling.
+  - **Known limitation:** this only covers a job whose exception escapes `perform_now` uncaught. A job using `retry_on`, `discard_on`, or a custom `rescue_from` has the exception handled *inside* `perform_now`, before `perform.active_job`'s payload is ever built — so a retried or discarded job still reports `status: "completed"` for every handled attempt. Only the final attempt of a `retry_on` job that exhausts its retries with no block given re-raises far enough to be visible. Covering retried/discarded attempts would need separate instrumentation on `enqueue_retry.active_job` / `retry_stopped.active_job` / `discard.active_job` — not done here.
+- **A request opening 5 or more transactions/savepoints could trip a false N+1 flag.** Every Rails adapter checked (MySQL/PostgreSQL/SQLite3, 7.1–8.1) logs transaction-control statements under the single name `"TRANSACTION"`, which the old skip list (`data[:name] == "BEGIN" || ...`) never matched — so `BEGIN`/`COMMIT`/etc. weren't ignored, they were tracked as ordinary queries: sanitized, counted toward N+1 detection, and folded into one aggregate per normalized statement. Five or more transactions in one request hit `N_PLUS_ONE_THRESHOLD` and flagged that aggregate `n_plus_one: true`, which the backend trusts directly for the aggregate payload format. Fixed as a consequence of the `TXN_CONTROL_NAMES` match below, not a separate change.
+
+### Added
+- Transaction-control statements (`BEGIN`/`COMMIT`/`ROLLBACK`/`SAVEPOINT`/`RELEASE`) are now captured as lightweight breadcrumbs (`transaction_events`, with offsets) instead of being tracked as ordinary queries — so a transaction that rolled back before an error shows up explicitly in the request trace, instead of as an anonymous, sanitized `sql_queries` entry.
+
+## [0.2.31] - 2026-08-30
+
 ### Added
 - Monitor thread now sends a synchronous heartbeat on startup before the first collection tick. This ensures remote settings — including `monitor_enabled` — are applied from the very first reporting cycle, so Sidekiq workers and other non-web processes that have not yet sent any metrics still receive the correct configuration immediately on boot rather than waiting up to 60 seconds for the first scheduled tick.
 

data/FEATURES.md

@@ -0,0 +1,333 @@
+# ApmBro Feature List
+
+A comprehensive feature list for comparing ApmBro with other APM (Application Performance Monitoring) tools.
+
+## Core Architecture
+
+- **Rails Integration**: Automatic subscription to Rails events via ActiveSupport::Notifications
+- **Zero-Configuration Setup**: Works out of the box with minimal configuration
+- **Asynchronous Metrics Posting**: Non-blocking HTTP requests using background threads
+- **Thread-Local Storage**: Per-request metric collection using thread-local variables
+- **Circuit Breaker Pattern**: Built-in circuit breaker to prevent cascading failures when APM endpoint is down
+- **Deploy Tracking**: Automatic deploy ID resolution from multiple sources (Rails settings, ENV vars, Heroku, Git)
+
+## Request Tracking
+
+### Controller Action Monitoring
+- **Automatic Tracking**: Tracks all controller actions automatically
+- **Request Duration**: Measures total request processing time
+- **HTTP Method & Path**: Captures HTTP method and request path
+- **Status Codes**: Tracks HTTP response status codes
+- **View Runtime**: Separate tracking of view rendering time
+- **Database Runtime**: Separate tracking of database query time
+- **Request Parameters**: Captures request parameters (with sensitive data filtering)
+- **User Agent**: Tracks user agent strings
+- **User ID Extraction**: Extracts authenticated user ID (supports Warden)
+- **Environment Context**: Tracks Rails environment (development, staging, production)
+
+### Request Sampling
+- **Configurable Sample Rate**: Percentage-based sampling (1-100%)
+- **Random Sampling**: Each request has random chance of being tracked
+- **Consistent Per-Request**: Sampling decision applies to all metrics for a request
+- **Error Override**: Errors are always tracked regardless of sampling
+- **Cost Optimization**: Reduces data volume and costs for high-traffic applications
+
+### Exclusion Rules
+- **Controller Exclusion**: Exclude entire controllers from tracking
+- **Action Exclusion**: Exclude specific controller#action combinations
+- **Wildcard Support**: Pattern matching with `*` wildcards (e.g., `Admin::*`, `Admin::*#*`)
+- **Job Exclusion**: Exclude specific background jobs from tracking
+- **Flexible Configuration**: Configure via initializer, Rails settings, or environment variables
+
+## SQL Query Tracking
+
+### Query Details
+- **Full SQL Tracking**: Captures all SQL queries executed during requests and jobs
+- **Query Sanitization**: Automatically sanitizes SQL to remove sensitive data
+- **Query Name**: Tracks query names (e.g., "User Load", "User Update")
+- **Duration Measurement**: Precise query execution time in milliseconds
+- **Cache Detection**: Identifies cached queries
+- **Connection ID**: Tracks database connection ID
+- **Call Stack Traces**: Full backtrace showing where queries were executed
+- **Object Allocations**: Optional tracking of object allocations per query
+
+### Query Performance Analysis
+- **Slow Query Detection**: Configurable threshold for identifying slow queries
+- **EXPLAIN ANALYZE**: Automatic execution plan capture for slow queries
+- **Background Execution**: EXPLAIN ANALYZE runs in separate thread (non-blocking)
+- **Multi-Database Support**: Works with PostgreSQL, MySQL, SQLite, and others
+- **Smart Filtering**: Automatically skips transaction queries (BEGIN, COMMIT, ROLLBACK)
+- **Execution Plan Details**: 
+  - PostgreSQL: Full EXPLAIN ANALYZE with buffer usage statistics
+  - MySQL: EXPLAIN ANALYZE with actual execution times
+  - SQLite: EXPLAIN QUERY PLAN output
+- **Query Optimization Insights**: Helps identify missing indexes, full table scans, JOIN issues
+
+## View Rendering Tracking
+
+### View Performance
+- **Template Rendering**: Tracks main template rendering
+- **Partial Rendering**: Tracks partial template rendering with cache key information
+- **Collection Rendering**: Tracks collection rendering (partials in loops)
+- **Rendering Duration**: Precise timing for each view component
+- **Virtual Path Tracking**: Tracks view virtual paths
+- **Layout Information**: Captures layout usage
+
+### View Analysis
+- **Slow View Detection**: Identifies the slowest rendering views
+- **Frequency Analysis**: Tracks most frequently rendered views
+- **Cache Hit Rate**: Calculates cache hit rates for partials
+- **Collection Cache Analysis**: Tracks cache hit rates for collection rendering
+- **Performance Metrics**: 
+  - Total views rendered per request
+  - Total view rendering duration
+  - Average view rendering duration
+  - Breakdown by view type (template, partial, collection)
+
+## Memory Tracking & Leak Detection
+
+### Lightweight Memory Tracking (Default)
+- **Memory Usage Monitoring**: Tracks memory consumption per request using GC stats
+- **Memory Growth Tracking**: Measures memory growth during request processing
+- **GC Statistics**: Tracks garbage collection count and heap pages
+- **Minimal Performance Impact**: ~0.1ms overhead per request
+- **Memory Before/After**: Captures memory state at request start and end
+
+### Detailed Allocation Tracking (Optional)
+- **Object Allocation Tracking**: Detailed tracking of object allocations (disabled by default)
+- **Allocation Sampling**: Configurable sampling rate for allocations
+- **Large Object Detection**: Identifies objects larger than 1MB threshold
+- **Memory Snapshots**: Periodic memory snapshots during request processing
+- **Object Count Tracking**: Tracks object counts before and after requests
+- **Performance Impact**: ~2-5ms overhead per request (only when enabled)
+
+### Memory Leak Detection
+- **Pattern Detection**: Detects growing memory patterns over time
+- **GC Efficiency Analysis**: Monitors garbage collection effectiveness
+- **Heap Page Tracking**: Tracks heap page growth
+- **Request Correlation**: Correlates memory growth with specific controllers/actions
+
+## Background Job Tracking
+
+### Job Execution Monitoring
+- **ActiveJob Integration**: Automatic tracking when ActiveJob is available
+- **Job Class Tracking**: Tracks job class names
+- **Job ID**: Captures unique job identifiers
+- **Queue Name**: Tracks which queue processed the job
+- **Job Arguments**: Captures job arguments (with sensitive data filtering)
+- **Duration Measurement**: Precise job execution time in milliseconds
+- **Status Tracking**: Tracks job status (completed or failed)
+
+### Job Error Tracking
+- **Exception Capture**: Captures exceptions from failed jobs
+- **Exception Class**: Tracks exception class names
+- **Exception Messages**: Captures exception messages (truncated to 1000 chars)
+- **Backtraces**: Full exception backtraces (first 50 lines)
+- **SQL Query Context**: Includes SQL queries executed during failed jobs
+- **Memory Context**: Includes memory usage during job execution
+
+### Job SQL Tracking
+- **SQL Query Tracking**: Tracks all SQL queries executed during job processing
+- **Query Details**: Same detailed SQL tracking as request tracking
+- **Query Context**: Full context of database operations in background jobs
+
+## Cache Tracking
+
+### Cache Operations
+- **Read Operations**: Tracks cache read operations
+- **Write Operations**: Tracks cache write operations
+- **Delete Operations**: Tracks cache delete operations
+- **Existence Checks**: Tracks cache existence checks
+- **Fetch Operations**: Tracks cache fetch with hit/miss detection
+- **Multi-Read Operations**: Tracks cache read_multi operations
+- **Multi-Write Operations**: Tracks cache write_multi operations
+- **Cache Generation**: Tracks cache generation events
+
+### Cache Analysis
+- **Cache Hit Detection**: Identifies cache hits vs misses
+- **Cache Key Tracking**: Tracks cache keys (truncated to 200 chars)
+- **Store Information**: Identifies which cache store was used
+- **Namespace Tracking**: Tracks cache namespaces
+- **Duration Measurement**: Precise timing for each cache operation
+- **Hit Rate Calculation**: Calculates cache hit rates per request
+
+## Redis Tracking
+
+### Redis Command Tracking
+- **Command Monitoring**: Tracks all Redis commands executed
+- **Command Name**: Captures Redis command names (GET, SET, etc.)
+- **Key Tracking**: Tracks Redis keys (truncated to 200 chars)
+- **Argument Count**: Tracks number of arguments per command
+- **Database Selection**: Tracks which Redis database is used
+- **Duration Measurement**: Precise timing for each Redis command
+- **Error Tracking**: Captures Redis command errors
+
+### Advanced Redis Features
+- **Pipeline Support**: Tracks Redis pipeline operations with command counts
+- **Multi/Transaction Support**: Tracks Redis MULTI/EXEC transactions
+- **ActiveSupport Integration**: Subscribes to ActiveSupport::Notifications for Redis events
+- **Client Instrumentation**: Direct instrumentation of Redis::Client for comprehensive coverage
+
+## Error Tracking
+
+### Exception Handling
+- **Automatic Exception Capture**: Captures exceptions from controller actions
+- **Exception Class**: Tracks exception class names
+- **Exception Messages**: Captures exception messages (truncated to 1000 chars)
+- **Full Backtraces**: Captures complete exception backtraces (first 50 lines)
+- **Request Context**: Includes full request context with exceptions
+- **Error Flagging**: Errors are marked and always tracked (even with sampling)
+
+### Error Context
+- **Controller/Action**: Identifies where the error occurred
+- **Request Parameters**: Includes request parameters at time of error
+- **User Information**: Includes user ID if available
+- **SQL Queries**: Includes SQL queries executed before error
+- **Memory State**: Includes memory usage at time of error
+- **Log Messages**: Includes application logs captured during request
+
+## HTTP Instrumentation
+
+### Outgoing HTTP Tracking
+- **HTTP Request Tracking**: Tracks outgoing HTTP requests (via middleware)
+- **Request Context**: Captures HTTP request details
+- **Response Context**: Captures HTTP response details
+- **Duration Measurement**: Tracks HTTP request duration
+
+## Configuration & Flexibility
+
+### Configuration Options
+- **API Key Management**: Multiple sources (config, Rails credentials, ENV)
+- **Endpoint Configuration**: Configurable endpoint URL
+- **Timeout Settings**: Configurable open and read timeouts
+- **Enable/Disable Toggle**: Can be enabled/disabled via configuration
+- **Environment Detection**: Automatic Rails environment detection
+
+### Circuit Breaker Configuration
+- **Failure Threshold**: Configurable failure threshold (default: 3)
+- **Recovery Timeout**: Configurable recovery timeout (default: 60 seconds)
+- **Retry Timeout**: Configurable retry timeout (default: 300 seconds)
+- **Enable/Disable**: Can enable/disable circuit breaker
+
+### Memory Tracking Configuration
+- **Memory Tracking Toggle**: Enable/disable memory tracking
+- **Allocation Tracking Toggle**: Enable/disable detailed allocation tracking
+- **Sampling Configuration**: Configurable request sampling rate
+
+### Query Analysis Configuration
+- **Slow Query Threshold**: Configurable threshold in milliseconds (default: 500ms)
+- **EXPLAIN ANALYZE Toggle**: Enable/disable automatic EXPLAIN ANALYZE
+
+## Data Safety & Privacy
+
+### Data Sanitization
+- **SQL Sanitization**: Automatically sanitizes SQL queries
+- **Parameter Filtering**: Filters sensitive parameters (password, token, secret, key)
+- **Argument Truncation**: Limits and truncates job arguments
+- **Key Truncation**: Truncates cache and Redis keys to 200 characters
+- **Value Truncation**: Recursively truncates nested values to prevent huge payloads
+- **String Limits**: Limits string values (e.g., user agent to 200 chars, messages to 1000 chars)
+
+### Data Limits
+- **Array Limits**: Limits array sizes (e.g., first 10 job arguments, first 5 array elements)
+- **Hash Limits**: Limits hash key counts (e.g., first 20 hash keys, first 30 params)
+- **Backtrace Limits**: Limits backtraces to first 50 lines
+- **Allocation Limits**: Limits allocations tracked per request (max 1000)
+
+## Performance & Reliability
+
+### Performance Optimizations
+- **Asynchronous Posting**: Non-blocking HTTP requests
+- **Lightweight Default Mode**: Minimal overhead in default configuration
+- **Sampling Support**: Reduces data volume for high-traffic applications
+- **Thread-Local Storage**: Efficient per-request data collection
+- **Background EXPLAIN**: EXPLAIN ANALYZE runs in background thread
+
+### Reliability Features
+- **Circuit Breaker**: Prevents cascading failures
+- **Error Handling**: Comprehensive error handling to prevent instrumentation failures
+- **Graceful Degradation**: Continues working even if some features fail
+- **Timeout Protection**: Configurable timeouts prevent hanging requests
+
+## Integration & Compatibility
+
+### Framework Support
+- **Rails Integration**: Full Rails integration via Railtie
+- **ActiveSupport Notifications**: Uses ActiveSupport::Notifications for event subscription
+- **ActiveRecord Integration**: Tracks ActiveRecord SQL queries
+- **ActiveJob Integration**: Tracks ActiveJob background jobs
+- **ActionView Integration**: Tracks ActionView rendering
+
+### Database Support
+- **PostgreSQL**: Full support with EXPLAIN ANALYZE
+- **MySQL**: Full support with EXPLAIN ANALYZE
+- **SQLite**: Full support with EXPLAIN QUERY PLAN
+- **Other Databases**: Basic support with standard EXPLAIN
+
+### Cache Store Support
+- **All Cache Stores**: Works with any Rails cache store
+- **Multi-Store Support**: Tracks cache operations across different stores
+
+### Redis Support
+- **Redis Gem**: Works with redis gem
+- **Client Instrumentation**: Direct instrumentation of Redis::Client
+- **Pipeline Support**: Tracks Redis pipelines
+- **Transaction Support**: Tracks Redis MULTI/EXEC transactions
+
+## Logging & Debugging
+
+### Application Logging
+- **Log Capture**: Captures application logs during request processing
+- **Log Context**: Includes logs in metric payloads
+- **Debug Logging**: Optional debug logging for skipped requests
+
+## Deployment & Environment
+
+### Deploy Tracking
+- **Deploy ID Resolution**: Multiple sources for deploy identification (`Configuration#deploy_id=` wins when set, then ENV in `Configuration::DEPLOY_REVISION_ENV_KEYS` order—including `DEAD_BRO_DEPLOY_ID`, git/CI vars, `DD_VERSION`, etc.), otherwise a **per-process UUID** (fine for single dyno/process; unusable alone for fleets like ECS replicas)
+- **Revision Tracking**: Includes deploy/revision ID in all metric payloads
+
+### Environment Support
+- **Rails Environment**: Automatic Rails environment detection
+- **Rack Environment**: Fallback to RACK_ENV or RAILS_ENV
+- **Environment Context**: Includes environment in all metric payloads
+
+## Data Collection & Transmission
+
+### Metric Payload Structure
+- **Structured Data**: Well-structured JSON payloads
+- **Event Names**: Descriptive event names for different metric types
+- **Timestamp Tracking**: ISO8601 timestamps for all metrics
+- **Metadata**: Rich metadata including environment, host, deploy ID
+
+### HTTP Client
+- **HTTPS Support**: Secure HTTPS communication
+- **Bearer Token Auth**: API key authentication via Bearer tokens
+- **JSON Encoding**: JSON-encoded payloads
+- **Custom Headers**: Proper Content-Type and Authorization headers
+
+## Comparison-Ready Features
+
+### Unique Differentiators
+1. **Automatic EXPLAIN ANALYZE**: Background execution plan capture for slow queries
+2. **Lightweight Memory Tracking**: Low-overhead memory monitoring by default
+3. **Comprehensive Cache Tracking**: Detailed cache operation tracking
+4. **Redis Instrumentation**: Full Redis command tracking including pipelines
+5. **View Rendering Analysis**: Detailed view performance analysis with cache hit rates
+6. **Flexible Exclusion Rules**: Wildcard support for controller/job exclusion
+7. **Request Sampling**: Configurable percentage-based sampling
+8. **Circuit Breaker**: Built-in resilience for APM endpoint failures
+9. **Multi-Source Configuration**: Flexible configuration from multiple sources
+10. **Deploy Tracking**: Automatic deploy ID resolution from multiple sources
+
+### Standard APM Features
+- Request/response tracking
+- SQL query tracking
+- Error tracking
+- Background job tracking
+- Memory tracking
+- Performance metrics
+- Exception handling
+- User context
+- Environment tracking
+

data/README.md

@@ -94,11 +94,11 @@ DeadBro can automatically capture the query plan (`EXPLAIN`) of slow SELECT quer
 
 ### Configuration
 
-- **`explain_analyze_enabled`** (default: `false`) — this is the one setting that must be turned on in Ruby; the dashboard toggle can only turn capture *off*, never on, as an extra safety rail:
+- **`explain_enabled`** (default: `false`) — this is the one setting that must be turned on in Ruby; the dashboard toggle can only turn capture *off*, never on, as an extra safety rail:
 
   ```ruby
   DeadBro.configure do |config|
-    config.explain_analyze_enabled = true
+    config.explain_enabled = true
   end
   ```
 

data/lib/dead_bro/configuration.rb

@@ -12,8 +12,12 @@ module DeadBro
     # Local-only opt-in for EXPLAIN plan capture on slow queries. The gem runs
     # DB statements (plan-only EXPLAIN) when this is on, so it must be enabled
     # in the app's own config — remote settings can only turn it OFF, never on
-    # (see apply_remote_settings). Effective state: #explain_analyze_active?
-    attr_accessor :explain_analyze_enabled
+    # (see apply_remote_settings). Effective state: #explain_active?
+    attr_accessor :explain_enabled
+
+    # Compatibility for initializers written before the EXPLAIN option was renamed.
+    alias_method :explain_analyze_enabled, :explain_enabled
+    alias_method :explain_analyze_enabled=, :explain_enabled=
 
     # Remote-managed settings (overwritten by backend JSON `settings` on successful API responses)
     attr_accessor :memory_tracking_enabled, :allocation_tracking_enabled, :allocation_sample_rate,
@@ -66,7 +70,7 @@ module DeadBro
 
     REMOTE_SETTING_KEYS = %w[
       enabled sample_rate memory_tracking_enabled allocation_tracking_enabled allocation_sample_rate
-      explain_analyze_enabled slow_query_threshold_ms max_sql_queries_to_send max_logs_to_send
+      explain_enabled slow_query_threshold_ms max_sql_queries_to_send max_logs_to_send
       watch_enabled excluded_controllers excluded_jobs exclusive_controllers exclusive_jobs
       monitor_enabled enable_db_stats enable_process_stats enable_system_stats
       sample_rates_by_type
@@ -94,11 +98,11 @@ module DeadBro
       # sampling, allocation-source tracing) runs on this % of requests so the
       # ~2-5ms overhead can be capped without turning the feature fully off.
       @allocation_sample_rate = 100
-      @explain_analyze_enabled = false
+      @explain_enabled = false
       # Remote kill switch for EXPLAIN capture. Defaults to true so a local
       # opt-in works against older backends that never send the key; any
-      # response that sends explain_analyze_enabled: false turns capture off.
-      @remote_explain_analyze_enabled = true
+      # response that sends explain_enabled: false turns capture off.
+      @remote_explain_enabled = true
       @slow_query_threshold_ms = 500
       @max_sql_queries_to_send = 500
       @max_logs_to_send = 100
@@ -166,6 +170,12 @@ module DeadBro
     def apply_remote_settings(hash)
       return unless hash.is_a?(Hash)
 
+      # Accept older servers; the canonical key wins when both are present.
+      hash = hash.transform_keys(&:to_s)
+      if hash.key?("explain_analyze_enabled") && !hash.key?("explain_enabled")
+        hash["explain_enabled"] = hash["explain_analyze_enabled"]
+      end
+
       @settings_mutex.synchronize do
         hash.each do |key, value|
           k = key.to_s
@@ -174,11 +184,11 @@ module DeadBro
           case k
           when "sample_rate", "allocation_sample_rate", "slow_query_threshold_ms", "max_sql_queries_to_send", "max_logs_to_send"
             send(:"#{k}=", value.to_i)
-          when "explain_analyze_enabled"
+          when "explain_enabled"
             # EXPLAIN runs statements against the customer DB, so the backend
             # must never be able to switch it on — only off. The local opt-in
-            # (explain_analyze_enabled) stays untouched; see #explain_analyze_active?
-            @remote_explain_analyze_enabled = !!value
+            # (explain_enabled) stays untouched; see #explain_active?
+            @remote_explain_enabled = !!value
           when "enabled", "memory_tracking_enabled", "allocation_tracking_enabled", "watch_enabled",
                "monitor_enabled", "enable_db_stats", "enable_process_stats", "enable_system_stats"
             send(:"#{k}=", !!value)
@@ -193,10 +203,12 @@ module DeadBro
 
     # EXPLAIN capture requires BOTH the local opt-in and the remote flag —
     # locally off means off no matter what the backend sends.
-    def explain_analyze_active?
-      !!(@explain_analyze_enabled && @remote_explain_analyze_enabled)
+    def explain_active?
+      !!(@explain_enabled && @remote_explain_enabled)
     end
 
+    alias_method :explain_analyze_active?, :explain_active?
+
     def heartbeat_due?
       return false if api_key.nil?
       last_heartbeat_attempt_at.nil? || (Time.now.utc - last_heartbeat_attempt_at) >= HEARTBEAT_INTERVAL

data/lib/dead_bro/job_subscriber.rb

@@ -9,7 +9,6 @@ end
 module DeadBro
   class JobSubscriber
     JOB_EVENT_NAME = "perform.active_job"
-    JOB_EXCEPTION_EVENT_NAME = "exception.active_job"
 
     def self.subscribe!(client: Client.new)
       # Snap GC state before the job runs so stop_request_tracking gets a valid diff
@@ -19,7 +18,28 @@ module DeadBro
       rescue
       end
 
-      # Track job execution
+      # Track job execution — success AND failure both land here. ActiveJob wraps
+      # perform with `instrument(:perform) { super }` (see
+      # ActiveJob::Instrumentation#instrument), and AS::Notifications.instrument
+      # still runs its "finish" listeners (with :exception / :exception_object set
+      # in the payload) when the block raises, then re-raises. There is no separate
+      # "exception.active_job" event anywhere in Rails/ActiveJob — a prior version
+      # of this file subscribed to one, so it never fired; the job wasn't dropped,
+      # it fired *this* event and built status: "completed" unconditionally,
+      # silently reporting every failing job as a success. Branching on
+      # data[:exception_object] here is the only place a job failure can actually
+      # be detected.
+      #
+      # Known gap: this only sees an exception that escapes perform_now uncaught.
+      # ActiveJob::Base#perform_now (Execution) rescues internally and hands off to
+      # rescue_with_handler — which is exactly what retry_on/discard_on/rescue_from
+      # are built on (ActiveJob::Exceptions) — before Instrumentation's `super`
+      # even returns. A handled retry or discard returns normally with no
+      # exception attached, so perform.active_job still reports status:
+      # "completed" for every handled attempt; only a retry_on job's final,
+      # unhandled raise (attempts exhausted, no block given) is visible here.
+      # Covering handled attempts would need separate instrumentation on
+      # enqueue_retry.active_job / retry_stopped.active_job / discard.active_job.
       ActiveSupport::Notifications.subscribe(JOB_EVENT_NAME) do |name, started, finished, _unique_id, data|
         begin
           if DeadBro.configuration.skip_tracking?
@@ -40,12 +60,14 @@ module DeadBro
         rescue
         end
 
+        exception = data[:exception_object]
+        has_error = !exception.nil?
+
         # Skip out via sampling before we build any payload — jobs can be chatty
         # enough that even the "cheap" stop/analyze work matters under load.
-        # Completions have no exception attached; the exception subscriber below
-        # always sends errors with force: true.
+        # Errors always ship regardless of sampling, matching Subscriber's web path.
         job_type_key = "#{job_class_name}#perform"
-        unless DeadBro.configuration.should_sample?(job_type_key)
+        unless has_error || DeadBro.configuration.should_sample?(job_type_key)
           drain_job_tracking
           next
         end
@@ -71,6 +93,7 @@ module DeadBro
 
         # Get SQL queries executed during this job
         sql_queries = DeadBro::SqlSubscriber.stop_request_tracking
+        transaction_events = DeadBro::SqlSubscriber.last_transaction_events
         dependency_events = job_dependency_payload
         db_connection_stats = defined?(DeadBro::DbConnectionSubscriber) ? DeadBro::DbConnectionSubscriber.stop_request_tracking : {}
         gc_pressure = defined?(DeadBro::GcTracker) ? DeadBro::GcTracker.stop_request_tracking : {}
@@ -117,8 +140,9 @@ module DeadBro
           db_connection_checkouts: db_connection_stats[:checkouts],
           gc_pressure: gc_pressure,
           ar_instantiation_count: ar_instantiation_count,
-          status: "completed",
+          status: has_error ? "failed" : "completed",
           sql_queries: sql_queries,
+          transaction_events: transaction_events,
           rails_env: DeadBro.env,
           host: DeadBro.safe_hostname,
           process_kind: DeadBro.process_kind,
@@ -130,115 +154,19 @@ module DeadBro
           logs: DeadBro.logger.logs
         }.merge(dependency_events)
 
-        # force: true — the sampling decision above already accounted for any
-        # per-job-type override; client#post_metric must not re-roll it globally.
-        client.post_metric(event_name: name, payload: payload, force: true)
-      end
-
-      # Track job exceptions
-      ActiveSupport::Notifications.subscribe(JOB_EXCEPTION_EVENT_NAME) do |name, started, finished, _unique_id, data|
-        begin
-          if DeadBro.configuration.skip_tracking?
-            drain_job_tracking
-            next
-          end
-
-          job_class_name = data[:job].class.name
-          if DeadBro.configuration.excluded_job?(job_class_name)
-            next
-          end
-          # If exclusive_jobs is defined and not empty, only track matching jobs
-          unless DeadBro.configuration.exclusive_job?(job_class_name)
-            next
-          end
-        rescue
-        end
-
-        duration_ms = ((finished - started) * 1000.0).round(2)
-        exception = data[:exception_object]
-        queue_duration_ms = job_queue_duration_ms(data[:job], started)
-
-        # Ensure tracking was started (fallback if perform_start.active_job didn't fire)
-        unless DeadBro::SqlSubscriber.tracking_active?
-          DeadBro.logger.clear
-          Thread.current[DeadBro::TRACKING_START_TIME_KEY] = Time.now
-          DeadBro::SqlSubscriber.start_request_tracking
-          start_job_dependency_tracking
-          DeadBro::DbConnectionSubscriber.start_request_tracking if defined?(DeadBro::DbConnectionSubscriber)
-          DeadBro::WatchTracker.start_request_tracking if defined?(DeadBro::WatchTracker)
-          if DeadBro.configuration.allocation_tracking_enabled && defined?(DeadBro::MemoryTrackingSubscriber)
-            DeadBro::MemoryTrackingSubscriber.start_request_tracking
-          else
-            DeadBro::LightweightMemoryTracker.start_request_tracking if defined?(DeadBro::LightweightMemoryTracker)
-          end
-        end
-
-        # Get SQL queries executed during this job
-        sql_queries = DeadBro::SqlSubscriber.stop_request_tracking
-        dependency_events = job_dependency_payload
-        db_connection_stats = defined?(DeadBro::DbConnectionSubscriber) ? DeadBro::DbConnectionSubscriber.stop_request_tracking : {}
-        gc_pressure = defined?(DeadBro::GcTracker) ? DeadBro::GcTracker.stop_request_tracking : {}
-        ar_instantiation_count = defined?(DeadBro::ArObjectTracker) ? DeadBro::ArObjectTracker.stop_request_tracking : nil
-        watch_events = defined?(DeadBro::WatchTracker) ? DeadBro::WatchTracker.stop_request_tracking : []
-
-        # Stop memory tracking and get collected memory data
-        if DeadBro.configuration.allocation_tracking_enabled && defined?(DeadBro::MemoryTrackingSubscriber)
-          detailed_memory = DeadBro::MemoryTrackingSubscriber.stop_request_tracking
-          memory_performance = DeadBro::MemoryTrackingSubscriber.analyze_memory_performance(detailed_memory)
-          # Keep memory_events compact and user-friendly (no large raw arrays)
-          memory_events = {
-            memory_before: detailed_memory[:memory_before],
-            memory_after: detailed_memory[:memory_after],
-            duration_seconds: detailed_memory[:duration_seconds],
-            allocations_count: (detailed_memory[:allocations] || []).length,
-            memory_snapshots_count: (detailed_memory[:memory_snapshots] || []).length,
-            large_objects_count: (detailed_memory[:large_objects] || []).length
-          }
-        else
-          lightweight_memory = DeadBro::LightweightMemoryTracker.stop_request_tracking
-          # Separate raw readings from derived performance metrics to avoid duplicating data
-          memory_events = {
-            memory_before: lightweight_memory[:memory_before],
-            memory_after: lightweight_memory[:memory_after]
-          }
-          memory_performance = {
-            memory_growth_mb: lightweight_memory[:memory_growth_mb],
-            gc_count_increase: lightweight_memory[:gc_count_increase],
-            heap_pages_increase: lightweight_memory[:heap_pages_increase],
-            duration_seconds: lightweight_memory[:duration_seconds]
-          }
+        if has_error
+          payload[:exception_class] = exception.class.name
+          payload[:message] = exception.message.to_s[0, 1000]
+          payload[:backtrace] = Array(exception.backtrace).first(50)
+          payload[:fingerprint] = DeadBro::Subscriber.compute_error_fingerprint(exception)
+          payload[:cause_chain] = DeadBro::Subscriber.build_cause_chain(exception)
+          payload[:error] = true
         end
 
-        payload = {
-          job_class: data[:job].class.name,
-          job_id: data[:job].job_id,
-          queue_name: data[:job].queue_name,
-          arguments: safe_arguments(data[:job].arguments),
-          started_at: started.utc.iso8601(3),
-          duration_ms: duration_ms,
-          queue_duration_ms: queue_duration_ms,
-          db_connection_wait_ms: db_connection_stats[:wait_ms],
-          db_connection_checkouts: db_connection_stats[:checkouts],
-          gc_pressure: gc_pressure,
-          ar_instantiation_count: ar_instantiation_count,
-          status: "failed",
-          sql_queries: sql_queries,
-          exception_class: exception&.class&.name,
-          message: exception&.message&.to_s&.[](0, 1000),
-          backtrace: Array(exception&.backtrace).first(50),
-          rails_env: DeadBro.env,
-          host: DeadBro.safe_hostname,
-          process_kind: DeadBro.process_kind,
-          memory_usage: memory_usage_mb,
-          gc_stats: gc_stats,
-          memory_events: memory_events,
-          memory_performance: memory_performance,
-          watch_events: watch_events,
-          logs: DeadBro.logger.logs
-        }.merge(dependency_events)
-
-        event_name = exception&.class&.name || "ActiveJob::Exception"
-        client.post_metric(event_name: event_name, payload: payload, force: true)
+        # force: true — errors always ship, bypassing sampling by design; for
+        # completions the sampling decision above already accounted for any
+        # per-job-type override, so client#post_metric must not re-roll it globally.
+        client.post_metric(event_name: name, payload: payload, force: true)
       end
     rescue
       # Never raise from instrumentation install
@@ -248,6 +176,7 @@ module DeadBro
     # build a payload (excluded job / sampled out). Matches Subscriber.drain_request_tracking.
     def self.drain_job_tracking
       # wait_for_explains: false — result is discarded, don't block on pending plans.
+      # stop_request_tracking also pops the transaction-events stack (see its comment).
       DeadBro::SqlSubscriber.stop_request_tracking(wait_for_explains: false) if defined?(DeadBro::SqlSubscriber)
       Thread.current[:dead_bro_http_events] = nil
       DeadBro::CacheSubscriber.stop_request_tracking if defined?(DeadBro::CacheSubscriber)

data/lib/dead_bro/sql_subscriber.rb

@@ -16,7 +16,11 @@ module DeadBro
     THREAD_LOCAL_EXPLAIN_PENDING_KEY = :dead_bro_explain_pending
     THREAD_LOCAL_CALL_COUNTS_KEY     = :dead_bro_sql_call_counts
     THREAD_LOCAL_AGGREGATES_KEY      = :dead_bro_sql_aggregates
+    THREAD_LOCAL_TXN_EVENTS_KEY      = :dead_bro_sql_txn_events
     MAX_TRACKED_QUERIES = 1000
+    # Transaction control breadcrumbs (BEGIN/COMMIT/ROLLBACK/...) are cheap and rare
+    # compared to queries, but a pathological retry loop could still spam them.
+    MAX_TRACKED_TXN_EVENTS = 200
 
     # Number of identical queries within one request that triggers N+1 detection.
     N_PLUS_ONE_THRESHOLD = 5
@@ -37,6 +41,43 @@ module DeadBro
     SANITIZE_SKIP_SENSITIVE_WHEN_NO_KEYWORDS = /password|token|secret|key|ssn|credit_card/i
     SANITIZE_SKIP_WHERE_WHEN_NO_KEYWORD = /WHERE/i
 
+    # Rails' own adapters (MySQL, PostgreSQL, SQLite3, at least 7.1 through 8.1 —
+    # the versions checked directly in this repo) log every transaction-control
+    # statement under the single generic name "TRANSACTION"
+    # (`internal_execute("BEGIN", "TRANSACTION", ...)`, `internal_execute("COMMIT",
+    # "TRANSACTION", ...)`, etc. — see AbstractMysqlAdapter/PostgreSQL::DatabaseStatements/
+    # SQLite3::DatabaseStatements). "BEGIN"/"COMMIT"/"ROLLBACK"/"SAVEPOINT"/"RELEASE"
+    # as literal `name` values are kept here only as a defensive fallback for
+    # adapters/older Rails versions that might still emit them directly — the actual
+    # operation for a "TRANSACTION"-named event is derived from the SQL text itself
+    # (see transaction_operation_for below), since the name alone can't distinguish
+    # BEGIN from COMMIT from a SAVEPOINT.
+    TXN_CONTROL_NAMES = %w[BEGIN COMMIT ROLLBACK SAVEPOINT RELEASE TRANSACTION].freeze
+
+    TXN_OPERATION_FROM_SQL = [
+      [/\A\s*ROLLBACK\s+TO\s+SAVEPOINT/i, "ROLLBACK TO SAVEPOINT"],
+      [/\A\s*RELEASE\s+SAVEPOINT/i, "RELEASE SAVEPOINT"],
+      [/\A\s*SAVEPOINT/i, "SAVEPOINT"],
+      [/\A\s*BEGIN/i, "BEGIN"],
+      [/\A\s*COMMIT/i, "COMMIT"],
+      [/\A\s*ROLLBACK/i, "ROLLBACK"]
+    ].freeze
+
+    # data[:name] is only ever "TRANSACTION" in current Rails — this derives the
+    # actual verb (BEGIN/COMMIT/ROLLBACK/SAVEPOINT/RELEASE SAVEPOINT/ROLLBACK TO
+    # SAVEPOINT) from the SQL text so breadcrumbs are still meaningful. A literal
+    # non-"TRANSACTION" name (older Rails/adapter) is passed through unchanged.
+    def self.transaction_operation_for(name, sql)
+      return name unless name == "TRANSACTION"
+      sql_str = sql.to_s
+      TXN_OPERATION_FROM_SQL.each do |re, op|
+        return op if sql_str.match?(re)
+      end
+      name
+    rescue
+      name
+    end
+
     # True when there is at least one active tracking context (e.g. for nested jobs).
     def self.tracking_active?
       stack = Thread.current[THREAD_LOCAL_KEY]
@@ -50,6 +91,13 @@ module DeadBro
       stack.last
     end
 
+    # Current transaction-events array (top of stack); nil if no active tracking.
+    def self.current_txn_events_array
+      stack = Thread.current[THREAD_LOCAL_TXN_EVENTS_KEY]
+      return nil unless stack.is_a?(Array) && stack.any?
+      stack.last
+    end
+
     # Sum of SQL counts and durations recorded so far in the active tracking
     # context. Used by WatchTracker to attribute SQL to a DeadBro.watch block.
     def self.current_sql_metrics
@@ -96,6 +144,27 @@ module DeadBro
       sql.to_s.downcase
     end
 
+    # Records a lightweight breadcrumb for a transaction-control statement
+    # (BEGIN/COMMIT/ROLLBACK/SAVEPOINT/RELEASE) — enough to show, e.g., that the
+    # queries preceding an error ran inside a transaction that was rolled back,
+    # without the cost of treating it like a tracked query (no backtrace/EXPLAIN).
+    def self.record_transaction_event(name, started, finished)
+      current = current_txn_events_array
+      return unless current
+      return if current.length >= MAX_TRACKED_TXN_EVENTS
+
+      tracking_start = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
+      start_offset_ms = tracking_start ? ((started - tracking_start) * 1000.0).round(2) : nil
+
+      current << {
+        event: name,
+        duration_ms: ((finished - started) * 1000.0).round(2),
+        start_offset_ms: start_offset_ms
+      }
+    rescue
+      nil
+    end
+
     def self.subscribe!
       # Subscribe with a start/finish listener to measure allocations per query
       if ActiveSupport::Notifications.notifier.respond_to?(:subscribe)
@@ -106,7 +175,13 @@ module DeadBro
       end
 
       ActiveSupport::Notifications.subscribe(SQL_EVENT_NAME) do |name, started, finished, _unique_id, data|
-        next if data[:name] == "SCHEMA" || data[:name] == "CACHE" || data[:name] == "BEGIN" || data[:name] == "COMMIT" || data[:name] == "ROLLBACK" || data[:name] == "SAVEPOINT" || data[:name] == "RELEASE"
+        next if data[:name] == "SCHEMA" || data[:name] == "CACHE"
+
+        if TXN_CONTROL_NAMES.include?(data[:name])
+          record_transaction_event(transaction_operation_for(data[:name], data[:sql]), started, finished)
+          next
+        end
+
         # Only track queries that are part of the current request (top of stack for nested jobs)
         current = current_queries_array
         next unless current
@@ -208,6 +283,7 @@ module DeadBro
       Thread.current[THREAD_LOCAL_EXPLAIN_PENDING_KEY] = []
       (Thread.current[THREAD_LOCAL_CALL_COUNTS_KEY] ||= []) << {}
       (Thread.current[THREAD_LOCAL_AGGREGATES_KEY]  ||= []) << {}
+      (Thread.current[THREAD_LOCAL_TXN_EVENTS_KEY]  ||= []) << []
     end
 
     # wait_for_explains: false on drain paths (excluded / sampled-out requests)
@@ -223,6 +299,21 @@ module DeadBro
       cc_stack     = Thread.current[THREAD_LOCAL_CALL_COUNTS_KEY]
       cc_stack.pop if cc_stack.is_a?(Array) && cc_stack.any?
 
+      # Transaction-control breadcrumbs are popped here, as part of this method's
+      # existing lifecycle, rather than through a separate stop_transaction_tracking
+      # call. start_request_tracking has many callers across this gem (and its own
+      # specs) that only know about query tracking; requiring every one of them to
+      # also remember a second, separately-paired stop call is exactly how a frame
+      # gets pushed and never popped — leaking across every later request/job on
+      # the same thread. Piggybacking on stop_request_tracking, which is already
+      # reliably paired with every start_request_tracking call, means there is
+      # nothing new for any caller to remember. A caller that wants the events
+      # reads last_transaction_events immediately afterward.
+      txn_stack = Thread.current[THREAD_LOCAL_TXN_EVENTS_KEY]
+      Thread.current[:dead_bro_last_transaction_events] =
+        (txn_stack.is_a?(Array) && txn_stack.any?) ? txn_stack.pop : []
+      Thread.current[THREAD_LOCAL_TXN_EVENTS_KEY] = nil if txn_stack.nil? || txn_stack.empty?
+
       # Fold any completed EXPLAIN plans from raw queries into their aggregate entry
       raw_queries.each do |q|
         next unless q[:explain_plan]
@@ -244,6 +335,17 @@ module DeadBro
       aggregates_h.values.sort_by { |a| -a[:total_duration_ms] }
     end
 
+    # The transaction-control breadcrumbs captured during the tracking window that
+    # this thread's most recent stop_request_tracking call just ended. Consumes
+    # (clears) the thread-local on read, not just on write: otherwise it would sit
+    # pinned in Thread.current between requests (a Puma/Sidekiq thread is reused),
+    # and — worse — any caller that reads it without an immediately-preceding
+    # stop_request_tracking would silently get the *previous* request's
+    # breadcrumbs instead of an empty result.
+    def self.last_transaction_events
+      Thread.current[:dead_bro_last_transaction_events].tap { Thread.current[:dead_bro_last_transaction_events] = nil } || []
+    end
+
     # Upper bound on pending EXPLAIN threads per request. Each thread checks
     # out an AR pool connection, so this must stay well below common pool
     # sizes (Rails default is 5) to avoid starving the app under a storm.
@@ -304,7 +406,7 @@ module DeadBro
     EXPLAIN_DML_KEYWORD_RE = /\b(INSERT|UPDATE|DELETE|MERGE)\b/i.freeze
 
     def self.should_explain_query?(duration_ms, sql)
-      return false unless DeadBro.configuration.explain_analyze_active?
+      return false unless DeadBro.configuration.explain_active?
       return false if duration_ms < DeadBro.configuration.slow_query_threshold_ms
       return false unless sql.is_a?(String)
 

data/lib/dead_bro/sql_tracking_middleware.rb

@@ -94,6 +94,7 @@ module DeadBro
       if defined?(DeadBro::SqlSubscriber)
         Thread.current[:dead_bro_sql_queries]
         Thread.current[:dead_bro_sql_queries] = nil
+        Thread.current[DeadBro::SqlSubscriber::THREAD_LOCAL_TXN_EVENTS_KEY] = nil
       end
 
       if defined?(DeadBro::CacheSubscriber)

data/lib/dead_bro/subscriber.rb

@@ -58,6 +58,7 @@ module DeadBro
 
         # Stop SQL tracking and get collected queries (this was started by the request)
         sql_queries = DeadBro::SqlSubscriber.stop_request_tracking
+        transaction_events = DeadBro::SqlSubscriber.last_transaction_events
 
         # Stop cache, redis, and elasticsearch tracking
         cache_events = defined?(DeadBro::CacheSubscriber) ? DeadBro::CacheSubscriber.stop_request_tracking : []
@@ -147,6 +148,42 @@ module DeadBro
           })
         end
 
+        # Everything captured during the request regardless of outcome — shared between
+        # the error and success payloads below so an errored request (e.g. a lock wait
+        # timeout raised mid-transaction) still ships the SQL/cache/memory/etc data that
+        # led up to it, not just the exception. This used to be built only for the
+        # success path, so every errored request shipped with sql_count: 0 and no trace
+        # even though the gem had already captured it.
+        detail_fields = {
+          view_runtime_ms: data[:view_runtime],
+          db_runtime_ms: data[:db_runtime],
+          memory_usage: memory_usage_mb,
+          gc_stats: gc_stats,
+          sql_count: sql_count(data),
+          sql_queries: sql_queries,
+          transaction_events: transaction_events,
+          http_outgoing: Thread.current[:dead_bro_http_events] || [],
+          cache_events: cache_events,
+          redis_events: redis_events,
+          elasticsearch_events: elasticsearch_events,
+          cache_hits: cache_hits(data),
+          cache_misses: cache_misses(data),
+          view_events: view_events,
+          view_performance: view_performance,
+          memory_events: memory_events,
+          memory_performance: memory_performance,
+          allocation_phases: allocation_phases,
+          rack_duration_ms: rack_duration_ms,
+          queue_duration_ms: Thread.current[:dead_bro_queue_duration_ms],
+          db_connection_wait_ms: db_connection_stats[:wait_ms],
+          db_connection_checkouts: db_connection_stats[:checkouts],
+          gc_pressure: gc_pressure,
+          ar_instantiation_count: ar_instantiation_count,
+          cpu_time_ms: cpu_time_ms,
+          watch_events: watch_events,
+          logs: DeadBro.logger.logs
+        }
+
         # Report exceptions attached to this action (e.g. controller/view errors)
         if data[:exception] || data[:exception_object]
           begin
@@ -154,7 +191,7 @@ module DeadBro
             exception_obj = data[:exception_object]
             backtrace = Array(exception_obj&.backtrace).first(50)
 
-            error_payload = {
+            error_payload = detail_fields.merge(
               controller: data[:controller],
               action: data[:action],
               format: data[:format],
@@ -174,9 +211,8 @@ module DeadBro
               backtrace: backtrace,
               fingerprint: compute_error_fingerprint(exception_obj),
               cause_chain: build_cause_chain(exception_obj),
-              error: true,
-              logs: DeadBro.logger.logs
-            }
+              error: true
+            )
 
             event_name = (exception_class || exception_obj&.class&.name || "exception").to_s
             client.post_metric(event_name: event_name, payload: error_payload, force: true)
@@ -186,7 +222,7 @@ module DeadBro
           end
         end
 
-        payload = {
+        payload = detail_fields.merge(
           controller: data[:controller],
           action: data[:action],
           format: data[:format],
@@ -195,40 +231,14 @@ module DeadBro
           status: data[:status],
           started_at: started.utc.iso8601(3),
           duration_ms: duration_ms,
-          view_runtime_ms: data[:view_runtime],
-          db_runtime_ms: data[:db_runtime],
           host: DeadBro.safe_hostname,
           request_host: safe_request_host(data),
           rails_env: DeadBro.env,
           process_kind: DeadBro.process_kind,
           params: safe_params(data),
           user_agent: safe_user_agent(data),
-          user_id: extract_user_id(data),
-          memory_usage: memory_usage_mb,
-          gc_stats: gc_stats,
-          sql_count: sql_count(data),
-          sql_queries: sql_queries,
-          http_outgoing: Thread.current[:dead_bro_http_events] || [],
-          cache_events: cache_events,
-          redis_events: redis_events,
-          elasticsearch_events: elasticsearch_events,
-          cache_hits: cache_hits(data),
-          cache_misses: cache_misses(data),
-          view_events: view_events,
-          view_performance: view_performance,
-          memory_events: memory_events,
-          memory_performance: memory_performance,
-          allocation_phases: allocation_phases,
-          rack_duration_ms: rack_duration_ms,
-          queue_duration_ms: Thread.current[:dead_bro_queue_duration_ms],
-          db_connection_wait_ms: db_connection_stats[:wait_ms],
-          db_connection_checkouts: db_connection_stats[:checkouts],
-          gc_pressure: gc_pressure,
-          ar_instantiation_count: ar_instantiation_count,
-          cpu_time_ms: cpu_time_ms,
-          watch_events: watch_events,
-          logs: DeadBro.logger.logs
-        }
+          user_id: extract_user_id(data)
+        )
         # force: true — the sampling decision (global or per-request-type) was
         # already made above; client#post_metric must not re-roll it with the
         # global-only rate, which would silently override a per-type sample rate.
@@ -242,6 +252,7 @@ module DeadBro
     def self.drain_request_tracking
       # wait_for_explains: false — the result is discarded, so don't block this
       # thread waiting on pending EXPLAIN plans.
+      # stop_request_tracking also pops the transaction-events stack (see its comment).
       DeadBro::SqlSubscriber.stop_request_tracking(wait_for_explains: false) if defined?(DeadBro::SqlSubscriber)
       DeadBro::CacheSubscriber.stop_request_tracking if defined?(DeadBro::CacheSubscriber)
       DeadBro::RedisSubscriber.stop_request_tracking if defined?(DeadBro::RedisSubscriber)

data/lib/dead_bro/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeadBro
-  VERSION = "0.2.31"
+  VERSION = "0.2.33"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dead_bro
 version: !ruby/object:Gem::Version
-  version: 0.2.31
+  version: 0.2.33
 platform: ruby
 authors:
 - Emanuel Comsa
@@ -18,6 +18,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- FEATURES.md
 - README.md
 - lib/dead_bro.rb
 - lib/dead_bro/allocation_source_sampler.rb
@@ -80,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Minimal APM for Rails apps.
 test_files: []