apm_bro 0.1.16 → 0.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7bf4fc110108b143a2f2e608090ae8c75a5882f8634ef1c01d0ddb949d41e54a
-  data.tar.gz: 7c5bd6915f805032ca63b73ab9325ce64b262d8489c2842b45c28a02e84b961d
+  metadata.gz: 235bb0964fa7bad2508335a33a743a3d7202757523660570b9a0aaa31ab36a41
+  data.tar.gz: b75c946a211a2da589e9a05534d70669ef296cc15be3d753d349e5ff6367eb5e
 SHA512:
-  metadata.gz: 601ed7213bb2dc1b551ba8d8e47944492bd67b727b0747aaad9c60b5ce13fb2b728b218a43eb0775e1479f5684ea1721dd0b9310bd25d2ccfcfcfad8cfc9e439
-  data.tar.gz: b8a2e25e5c0369d7bd58fe058ef7d524bdc42c7cc22739d30f9ad0956338370f63578aa10688869c817148451b46d7b9e1dab8835c4e7f33531cd9146a04ed88
+  metadata.gz: 96b1f310fe50eec5072e1ac93f96108a342ab60d85aef80635ead30044174469b39979d766d69b54b767ae259be712d40fb7fd05dafc21f701deef6923e721a0
+  data.tar.gz: 891c797268cfb6910bf3ddfd5e139586f1c1aa4002002edf2d63287c6548374d7798d079eb94de8fa4857cf7cecf995fcea2eefd224f591e243eec8f306e79c6

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

@@ -99,6 +99,56 @@ 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 ApmBro 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
+ApmBro.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
+APM_BRO_EXCLUSIVE_CONTROLLER_ACTIONS="UsersController#show,Admin::*#*"
+
+# Comma-separated list of job patterns
+APM_BRO_EXCLUSIVE_JOBS="PaymentProcessingJob,EmailDeliveryJob"
+```
+
 ## SQL Query Tracking
 
 ApmBro automatically tracks SQL queries executed during each request and job. Each request will include a `sql_queries` array containing:

data/lib/apm_bro/client.rb

@@ -59,9 +59,10 @@ module ApmBro
     end
 
     def make_http_request(event_name, payload, api_key)
+      production_url = ENV["USE_STAGING_ENDPOINT"].present? ? "https://deadbro.aberatii.com/apm/v1/metrics" : "https://www.deadbro.com/apm/v1/metrics"
       endpoint_url = (@configuration.respond_to?(:ruby_dev) && @configuration.ruby_dev) ?
           "http://localhost:3100/apm/v1/metrics" :
-          "https://www.deadbro.com/apm/v1/metrics"
+          production_url
 
       uri = URI.parse(endpoint_url)
       http = Net::HTTP.new(uri.host, uri.port)

data/lib/apm_bro/configuration.rb

@@ -4,7 +4,7 @@ module ApmBro
   class Configuration
     DEFAULT_ENDPOINT_PATH = "/v1/metrics"
 
-    attr_accessor :api_key, :endpoint_url, :open_timeout, :read_timeout, :enabled, :ruby_dev, :memory_tracking_enabled, :allocation_tracking_enabled, :circuit_breaker_enabled, :circuit_breaker_failure_threshold, :circuit_breaker_recovery_timeout, :circuit_breaker_retry_timeout, :sample_rate, :excluded_controllers, :excluded_jobs, :excluded_controller_actions, :deploy_id, :slow_query_threshold_ms, :explain_analyze_enabled
+    attr_accessor :api_key, :endpoint_url, :open_timeout, :read_timeout, :enabled, :ruby_dev, :memory_tracking_enabled, :allocation_tracking_enabled, :circuit_breaker_enabled, :circuit_breaker_failure_threshold, :circuit_breaker_recovery_timeout, :circuit_breaker_retry_timeout, :sample_rate, :excluded_controllers, :excluded_jobs, :excluded_controller_actions, :exclusive_controller_actions, :exclusive_jobs, :deploy_id, :slow_query_threshold_ms, :explain_analyze_enabled
 
     def initialize
       @api_key = nil
@@ -23,6 +23,8 @@ module ApmBro
       @excluded_controllers = []
       @excluded_jobs = []
       @excluded_controller_actions = []
+      @exclusive_controller_actions = []
+      @exclusive_jobs = []
       @deploy_id = resolve_deploy_id
       @slow_query_threshold_ms = 500 # Default: 500ms
       @explain_analyze_enabled = false # Enable EXPLAIN ANALYZE for slow queries by default
@@ -106,6 +108,12 @@ module ApmBro
       list.any? { |pat| match_name_or_pattern?(job_class_name, pat) }
     end
 
+    def exclusive_job?(job_class_name)
+      list = resolve_exclusive_jobs
+      return true if list.nil? || list.empty? # If not defined, allow all (default behavior)
+      list.any? { |pat| match_name_or_pattern?(job_class_name, pat) }
+    end
+
     def excluded_controller_action?(controller_name, action_name)
       list = resolve_excluded_controller_actions
       return false if list.nil? || list.empty?
@@ -113,6 +121,13 @@ module ApmBro
       list.any? { |pat| match_name_or_pattern?(target, pat) }
     end
 
+    def exclusive_controller_action?(controller_name, action_name)
+      list = resolve_exclusive_controller_actions
+      return true if list.nil? || list.empty? # If not defined, allow all (default behavior)
+      target = "#{controller_name}##{action_name}"
+      list.any? { |pat| match_name_or_pattern?(target, pat) }
+    end
+
     def resolve_excluded_controller_actions
       # Collect patterns from @excluded_controller_actions
       patterns = []
@@ -185,6 +200,58 @@ module ApmBro
       []
     end
 
+    def resolve_exclusive_controller_actions
+      # Collect patterns from @exclusive_controller_actions
+      patterns = []
+      if @exclusive_controller_actions && !@exclusive_controller_actions.empty?
+        patterns.concat(Array(@exclusive_controller_actions))
+      end
+
+      return patterns if !patterns.empty?
+
+      if defined?(Rails)
+        list = fetch_from_rails_settings(%w[apm_bro exclusive_controller_actions])
+        if list
+          rails_patterns = Array(list)
+          return rails_patterns if !rails_patterns.empty?
+        end
+      end
+
+      env = ENV["APM_BRO_EXCLUSIVE_CONTROLLER_ACTIONS"]
+      if env && !env.strip.empty?
+        env_patterns = env.split(",").map(&:strip)
+        return env_patterns if !env_patterns.empty?
+      end
+
+      []
+    end
+
+    def resolve_exclusive_jobs
+      # Collect patterns from @exclusive_jobs
+      patterns = []
+      if @exclusive_jobs && !@exclusive_jobs.empty?
+        patterns.concat(Array(@exclusive_jobs))
+      end
+
+      return patterns if !patterns.empty?
+
+      if defined?(Rails)
+        list = fetch_from_rails_settings(%w[apm_bro exclusive_jobs])
+        if list
+          rails_patterns = Array(list)
+          return rails_patterns if !rails_patterns.empty?
+        end
+      end
+
+      env = ENV["APM_BRO_EXCLUSIVE_JOBS"]
+      if env && !env.strip.empty?
+        env_patterns = env.split(",").map(&:strip)
+        return env_patterns if !env_patterns.empty?
+      end
+
+      []
+    end
+
     def should_sample?
       sample_rate = resolve_sample_rate
       return true if sample_rate >= 100

data/lib/apm_bro/http_instrumentation.rb

@@ -38,7 +38,7 @@ module ApmBro
 
               # Skip instrumentation for our own APM endpoint to prevent infinite loops,
               # but do NOT alter the original method's return value/control flow.
-              skip_instrumentation = uri && (uri.to_s.include?("localhost") || uri.to_s.include?("uptime.aberatii.com"))
+              skip_instrumentation = uri && (uri.to_s.include?("localhost") || uri.to_s.include?("aberatii.com"))
 
               unless skip_instrumentation
                 payload = {
@@ -85,7 +85,7 @@ module ApmBro
 
               # Skip instrumentation for our own APM endpoint to prevent infinite loops,
               # but do NOT alter the original method's return value/control flow.
-              skip_instrumentation = req_url && req_url.include?("localhost:3100/apm/v1/metrics")
+              skip_instrumentation = req_url && (req_url.include?("localhost:3100/apm/v1/metrics") || req_url.include?("deadbro.aberatii.com/apm/v1/metrics"))
 
               unless skip_instrumentation
                 payload = {

data/lib/apm_bro/job_subscriber.rb

@@ -19,6 +19,10 @@ module ApmBro
           if ApmBro.configuration.excluded_job?(job_class_name)
             next
           end
+          # If exclusive_jobs is defined and not empty, only track matching jobs
+          unless ApmBro.configuration.exclusive_job?(job_class_name)
+            next
+          end
         rescue
         end
 
@@ -82,6 +86,10 @@ module ApmBro
           if ApmBro.configuration.excluded_job?(job_class_name)
             next
           end
+          # If exclusive_jobs is defined and not empty, only track matching jobs
+          unless ApmBro.configuration.exclusive_job?(job_class_name)
+            next
+          end
         rescue
         end
 

data/lib/apm_bro/subscriber.rb

@@ -9,12 +9,17 @@ module ApmBro
     def self.subscribe!(client: Client.new)
       ActiveSupport::Notifications.subscribe(EVENT_NAME) do |name, started, finished, _unique_id, data|
         # Skip excluded controllers or controller#action pairs
+        # Also check exclusive_controller_actions - if defined, only track those
         begin
           controller_name = data[:controller].to_s
           action_name = data[:action].to_s
           if ApmBro.configuration.excluded_controller_action?(controller_name, action_name)
             next
           end
+          # If exclusive_controller_actions is defined and not empty, only track matching actions
+          unless ApmBro.configuration.exclusive_controller_action?(controller_name, action_name)
+            next
+          end
         rescue
         end
 

data/lib/apm_bro/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ApmBro
-  VERSION = "0.1.16"
+  VERSION = "0.1.18"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: apm_bro
 version: !ruby/object:Gem::Version
-  version: 0.1.16
+  version: 0.1.18
 platform: ruby
 authors:
 - Emanuel Comsa
@@ -18,6 +18,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- FEATURES.md
 - README.md
 - lib/apm_bro.rb
 - lib/apm_bro/cache_subscriber.rb