dead_bro 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2d751a73992758c9392fbf0a89445536ce1a97cd2aea29470e54c4da62075e6b
+  data.tar.gz: e868200d7940c736922ea80e0a5d98fd665a86f1258725e9db33098ccbe75927
+SHA512:
+  metadata.gz: 2ae9d9a17ca3975e68fdd762dd1f93eb173fca163ba01fdd6bea4813c0e7fca6566fee6943ee518b20f5f7b624cbc96b17dc0afcb45837cca703a94cfdde5e4b
+  data.tar.gz: 631e395e237463d6d76b0bc08868ee28712f90450a1c22935f21c05e1ff766c3b2b6f906249cbe6f29e8217c73a5bd196e746c6fab614e9f722f199f64e60eaa

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-08-28
+
+- Initial release

data/FEATURES.md

@@ -0,0 +1,338 @@
+# 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
+  - Explicit configuration
+  - Rails settings/credentials
+  - Environment variables (APM_BRO_DEPLOY_ID, GIT_REV)
+  - Heroku (HEROKU_SLUG_COMMIT)
+  - Process-stable UUID fallback
+- **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

@@ -0,0 +1,274 @@
+# DeadBro (Beta Version)
+
+Minimal APM for Rails apps. Automatically measures each controller action's total time, tracks SQL queries, monitors view rendering performance, tracks memory usage and detects leaks, monitors background jobs, and posts metrics to a remote endpoint with an API key read from your app's settings/credentials/env.
+
+To use the gem you need to have a free account with [DeadBro - Rails APM](https://www.deadbro.com)
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "dead_bro", git: "https://github.com/rubydevro/dead_bro.git"
+```
+
+## Usage
+
+By default, if Rails is present, DeadBro auto-subscribes to `process_action.action_controller` and posts metrics asynchronously.
+
+### Configuration settings
+
+You can set via an initializer:
+
+
+```ruby
+DeadBro.configure do |cfg|
+  cfg.api_key = ENV["dead_bro_API_KEY"]
+  cfg.enabled = true
+end
+```
+
+## Request Sampling
+
+DeadBro supports configurable request sampling to reduce the volume of metrics sent to your APM endpoint, which is useful for high-traffic applications.
+
+### Configuration
+
+Set the sample rate as a percentage (1-100):
+
+```ruby
+# Track 50% of requests
+DeadBro.configure do |config|
+  config.sample_rate = 50
+end
+
+# Track 10% of requests (useful for high-traffic apps)
+DeadBro.configure do |config|
+  config.sample_rate = 10
+end
+
+# Track all requests (default)
+DeadBro.configure do |config|
+  config.sample_rate = 100
+end
+```
+
+### How It Works
+
+- **Random Sampling**: Each request has a random chance of being tracked based on the sample rate
+- **Consistent Per-Request**: The sampling decision is made once per request and applies to all metrics for that request
+- **Debug Logging**: Skipped requests do not count towards the montly limit
+- **Error Tracking**: Errors are still tracked regardless of sampling
+
+### Use Cases
+
+- **High-Traffic Applications**: Reduce APM data volume and costs
+- **Development/Staging**: Sample fewer requests to reduce noise
+- **Performance Testing**: Track a subset of requests during load testing
+- **Cost Optimization**: Balance monitoring coverage with data costs
+
+
+## Excluding Controllers and Jobs
+
+You can exclude specific controllers and jobs from APM tracking.
+
+### Configuration
+
+
+```ruby
+DeadBro.configure do |config|
+  config.excluded_controllers = [
+    "HealthChecksController",
+    "Admin::*" # wildcard supported
+  ]
+
+  config.excluded_controller_actions = [
+    "UsersController#show",
+    "Admin::ReportsController#index",
+    "Admin::*#*" # wildcard supported for controller and action
+  ]
+
+  config.excluded_jobs = [
+    "ActiveStorage::AnalyzeJob",
+    "Admin::*"
+  ]
+end
+```
+
+Notes:
+- Wildcards `*` are supported for controller and action (e.g., `Admin::*#*`).
+- Matching is done against full names like `UsersController`, `Admin::ReportsController#index`, `MyJob`.
+
+## Exclusive Tracking (Whitelist Mode)
+
+You can configure DeadBro to **only** track specific controllers, actions, or jobs. This is useful when you want to focus monitoring on a subset of your application.
+
+### Configuration
+
+```ruby
+DeadBro.configure do |config|
+  # Only track these specific controller actions
+  config.exclusive_controller_actions = [
+    "UsersController#show",
+    "UsersController#index",
+    "Admin::ReportsController#*", # all actions in this controller
+    "Api::*#*" # all actions in all Api controllers
+  ]
+
+  # Only track these specific jobs
+  config.exclusive_jobs = [
+    "PaymentProcessingJob",
+    "EmailDeliveryJob",
+    "Admin::*" # all jobs in Admin namespace
+  ]
+end
+```
+
+### How It Works
+
+- **If `exclusive_controller_actions` or `exclusive_jobs` is empty/not defined**: All controllers/actions/jobs are tracked (default behavior)
+- **If `exclusive_controller_actions` or `exclusive_jobs` is defined with values**: Only matching controllers/actions/jobs are tracked
+- **Exclusion takes precedence**: If something is in both `excluded_*` and `exclusive_*`, it will be excluded (exclusion is checked first)
+
+### Use Cases
+
+- **Focus on Critical Paths**: Monitor only your most important endpoints
+- **Cost Optimization**: Track only specific high-value operations
+- **Debugging**: Temporarily focus on specific controllers/jobs during investigation
+- **Compliance**: Track only operations that require monitoring for compliance reasons
+
+### Environment Variables
+
+You can also configure exclusive tracking via environment variables:
+
+```bash
+# Comma-separated list of controller#action patterns
+dead_bro_EXCLUSIVE_CONTROLLER_ACTIONS="UsersController#show,Admin::*#*"
+
+# Comma-separated list of job patterns
+dead_bro_EXCLUSIVE_JOBS="PaymentProcessingJob,EmailDeliveryJob"
+```
+
+## SQL Query Tracking
+
+DeadBro automatically tracks SQL queries executed during each request and job. Each request will include a `sql_queries` array containing:
+- `sql` - The SQL query (always sanitized)
+- `name` - Query name (e.g., "User Load", "User Update")
+- `duration_ms` - Query execution time in milliseconds
+- `cached` - Whether the query was cached
+- `connection_id` - Database connection ID
+- `trace` - Call stack showing where the query was executed
+- `explain_plan` - Query execution plan (when EXPLAIN ANALYZE is enabled, see below)
+
+## Automatic EXPLAIN ANALYZE for Slow Queries
+
+DeadBro can automatically run `EXPLAIN ANALYZE` on slow SQL queries to help you understand query performance and identify optimization opportunities. This feature runs in the background and doesn't block your application requests.
+
+### How It Works
+
+- **Automatic Detection**: When a query exceeds the configured threshold, DeadBro automatically captures its execution plan
+- **Background Execution**: EXPLAIN ANALYZE runs in a separate thread using a dedicated database connection, so it never blocks your application
+- **Database Support**: Works with PostgreSQL, MySQL, SQLite, and other databases
+- **Smart Filtering**: Automatically skips transaction queries (BEGIN, COMMIT, ROLLBACK) and other queries that don't benefit from EXPLAIN
+
+### Configuration
+
+- **`explain_analyze_enabled`** (default: `false`) - Set to `true` to enable automatic EXPLAIN ANALYZE
+- **`slow_query_threshold_ms`** (default: `500`) - Queries taking longer than this threshold will have their execution plan captured
+
+### Example Configuration
+
+```ruby
+DeadBro.configure do |config|
+  config.api_key = ENV['dead_bro_API_KEY']
+  config.enabled = true
+  
+  # Enable EXPLAIN ANALYZE for queries slower than 500ms
+  config.explain_analyze_enabled = true
+  config.slow_query_threshold_ms = 500
+  
+  # Or use a higher threshold for production
+  # config.slow_query_threshold_ms = 1000  # Only explain queries > 1 second
+end
+```
+
+### What You Get
+
+When a slow query is detected, the `explain_plan` field in the SQL query data will contain:
+- **PostgreSQL**: Full EXPLAIN ANALYZE output with buffer usage statistics
+- **MySQL**: EXPLAIN ANALYZE output showing actual execution times
+- **SQLite**: EXPLAIN QUERY PLAN output
+- **Other databases**: Standard EXPLAIN output
+
+This execution plan helps you:
+- Identify missing indexes
+- Understand query execution order
+- Spot full table scans
+- Optimize JOIN operations
+- Analyze buffer and cache usage (PostgreSQL)
+
+## View Rendering Tracking
+
+DeadBro automatically tracks view rendering performance for each request. This includes:
+
+- **Individual view events**: Templates, partials, and collections rendered
+- **Performance metrics**: Rendering times for each view component
+- **Cache analysis**: Cache hit rates for partials and collections
+- **Slow view detection**: Identification of the slowest rendering views
+- **Frequency analysis**: Most frequently rendered views
+
+## Memory Tracking & Leak Detection
+
+DeadBro automatically tracks memory usage and detects memory leaks with minimal performance impact. This includes:
+
+### Performance-Optimized Memory Tracking
+
+By default, DeadBro uses **lightweight memory tracking** that has minimal performance impact:
+
+- **Memory Usage Monitoring**: Track memory consumption per request (using GC stats, not system calls)
+- **Memory Leak Detection**: Detect growing memory patterns over time
+- **GC Efficiency Analysis**: Monitor garbage collection effectiveness
+- **Zero Allocation Tracking**: No object allocation tracking by default (can be enabled)
+
+### Configuration Options
+
+```ruby
+# In your Rails configuration
+DeadBro.configure do |config|
+  config.memory_tracking_enabled = true        # Enable lightweight memory tracking (default: true)
+  config.allocation_tracking_enabled = false   # Enable detailed allocation tracking (default: false)
+  
+  # Sampling configuration
+  config.sample_rate = 100                     # Percentage of requests to track (1-100, default: 100)
+end
+```
+
+**Performance Impact:**
+- **Lightweight mode**: ~0.1ms overhead per request
+- **Allocation tracking**: ~2-5ms overhead per request (only enable when needed)
+
+## Job Tracking
+
+DeadBro automatically tracks ActiveJob background jobs when ActiveJob is available. Each job execution is tracked with:
+
+- `job_class` - The job class name (e.g., "UserMailer::WelcomeEmail")
+- `job_id` - Unique job identifier
+- `queue_name` - The queue the job was processed from
+- `arguments` - Sanitized job arguments (sensitive data filtered)
+- `duration_ms` - Job execution time in milliseconds
+- `status` - "completed" or "failed"
+- `sql_queries` - Array of SQL queries executed during the job
+- `exception_class` - Exception class name (for failed jobs)
+- `message` - Exception message (for failed jobs)
+- `backtrace` - Exception backtrace (for failed jobs)
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/rubydevro/dead_bro.