dead_bro 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d8e1d14cc8e5511d143de228afefcb1a7557b8ce0308b7302ba40f4bc78bc90
-  data.tar.gz: 1d215f5ff69110be5c10e965bcf2ac2f08f1f6cb9a2be72b602f143c3e3ac5e5
+  metadata.gz: 8badc23e17a92bca8e8057c8c49c6ba7a1535975a7da9f61a43fd0e2b80f56b5
+  data.tar.gz: 32ed00be83e65d97b89e3467129f95986d0417ec27839066a83b7706182a28ba
 SHA512:
-  metadata.gz: 9cab5ed48ea05f086512683b1d8d9fdb05030328f4fb4cb908884f074bc23b361ba7914774106bb5f1eba511435cdb506b123b2c4d2ece41634b539e925576a9
-  data.tar.gz: '0695e7e7bc6f5835fde69586aa2bc03c134ca9a2515a4bda4e55a0c78242f776315e07018834a2ce66c9a828849c05d807c38e183f99ab77e00ac4d239144943'
+  metadata.gz: becf47113fbfb03c8f851f54e3e518588e8ebc963f762d68b699b3a01dad7bab381c6d07c323abeb1d1414f20a24d949bf4cc245821ea96c4ee38e8e155f82ad
+  data.tar.gz: 1071fe9473be03be215822ab0bc9349ba1569a03f6d01fca372911f390c584227ebcd4c42272da8dd66198b560c5f09de83c42b6238dd8710241889c9e2cdb55

data/README.md

@@ -1,8 +1,10 @@
 # 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.
+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 DeadBro.
 
-To use the gem you need to have a free account with [DeadBro - Rails APM](https://www.deadbro.com)
+**Current versions:** almost everything (sampling, exclusions, SQL EXPLAIN, memory toggles, control-plane collectors, enable/disable, and more) is configured in the [DeadBro](https://www.deadbro.com) web app. The API returns those settings on successful requests and the gem applies them in memory—no need to mirror them in Ruby unless you want optional code-based overrides.
+
+To use the gem you need a free account with [DeadBro - Rails APM](https://www.deadbro.com).
 
 ## Installation
 
@@ -16,21 +18,33 @@ gem "dead_bro", git: "https://github.com/rubydevro/dead_bro.git"
 
 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:
+### Required: API key in your app
 
+Add an initializer (for example `config/initializers/dead_bro.rb`) and set your API key from the environment, [Rails credentials](https://guides.rubyonrails.org/security.html#custom-credentials), or another secret store:
 
 ```ruby
 DeadBro.configure do |config|
   config.api_key = ENV["DEAD_BRO_API_KEY"]
-  config.enabled = true
 end
 ```
 
+That is enough to start shipping metrics. Create or copy the key from your DeadBro account, then wire it into `DEAD_BRO_API_KEY` (or assign `config.api_key` directly).
+
+### Dashboard configuration
+
+Use the DeadBro UI to turn features on or off, set sample rates, define controller/job inclusions and exclusions, tune slow-query EXPLAIN, enable queue and system metrics, and adjust related limits. After you deploy the initializer above, those choices take effect when the gem receives them from the API (typically on the next successful metric or heartbeat response).
+
+### Optional local flags
+
+You can still set `config.enabled` in Ruby if you need to force the integration off in a given environment before any remote settings arrive; otherwise the dashboard can control `enabled` like other remote settings.
+
+## Optional: configuration in Ruby
+
+The sections below describe the same knobs you can manage in the DeadBro app. Use them only when you want values in source control, per-environment initializer logic, or other overrides outside the UI.
+
 ## 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.
+DeadBro supports configurable request sampling to reduce the volume of metrics sent to your APM endpoint, which is useful for high-traffic applications. Prefer setting this in the DeadBro app; use Ruby if you need a local override.
 
 ### Configuration
 
@@ -70,22 +84,20 @@ end
 
 ## Excluding Controllers and Jobs
 
-You can exclude specific controllers and jobs from APM tracking.
+You can exclude specific controllers and jobs from APM tracking (dashboard first; Ruby optional).
 
 ### Configuration
 
 
 ```ruby
 DeadBro.configure do |config|
+  # Controller-only or controller#action patterns in one list (wildcards supported)
   config.excluded_controllers = [
     "HealthChecksController",
-    "Admin::*" # wildcard supported
-  ]
-
-  config.excluded_controller_actions = [
+    "Admin::*",
     "UsersController#show",
     "Admin::ReportsController#index",
-    "Admin::*#*" # wildcard supported for controller and action
+    "Admin::*#*"
   ]
 
   config.excluded_jobs = [
@@ -96,39 +108,38 @@ end
 ```
 
 Notes:
-- Wildcards `*` are supported for controller and action (e.g., `Admin::*#*`).
-- Matching is done against full names like `UsersController`, `Admin::ReportsController#index`, `MyJob`.
+- Wildcards `*` are supported (e.g., `Admin::*`, `Admin::*#*`).
+- Matching uses 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.
+You can configure DeadBro to **only** track specific controllers, actions, or jobs. Prefer the dashboard; use Ruby for overrides.
 
 ### Configuration
 
 ```ruby
 DeadBro.configure do |config|
-  # Only track these specific controller actions
-  config.exclusive_controller_actions = [
+  # Only track these controllers/actions (patterns can include #action or wildcards)
+  config.exclusive_controllers = [
     "UsersController#show",
     "UsersController#index",
-    "Admin::ReportsController#*", # all actions in this controller
-    "Api::*#*" # all actions in all Api controllers
+    "Admin::ReportsController#*",
+    "Api::*#*"
   ]
 
-  # Only track these specific jobs
   config.exclusive_jobs = [
     "PaymentProcessingJob",
     "EmailDeliveryJob",
-    "Admin::*" # all jobs in Admin namespace
+    "Admin::*"
   ]
 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)
+- **If `exclusive_controllers` or `exclusive_jobs` is empty/not defined**: All controllers/actions/jobs are tracked (default behavior)
+- **If `exclusive_controllers` or `exclusive_jobs` is defined with values**: Only matching controllers/actions/jobs are tracked
+- **Exclusion takes precedence**: If something matches both `excluded_*` and `exclusive_*`, it is excluded (exclusion is checked first)
 
 ### Use Cases
 
@@ -137,18 +148,6 @@ end
 - **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:
@@ -173,6 +172,8 @@ DeadBro can automatically run `EXPLAIN ANALYZE` on slow SQL queries to help you
 
 ### Configuration
 
+These options are usually set in the DeadBro UI. In Ruby:
+
 - **`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
 
@@ -180,13 +181,10 @@ DeadBro can automatically run `EXPLAIN ANALYZE` on slow SQL queries to help you
 
 ```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
@@ -232,8 +230,9 @@ By default, DeadBro uses **lightweight memory tracking** that has minimal perfor
 
 ### Configuration Options
 
+Usually managed in the dashboard; Ruby example:
+
 ```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)
@@ -279,7 +278,7 @@ Everything is **best effort** and designed to be **safe and low overhead**:
 
 ### Configuration
 
-You can enable or disable individual collectors and tune basic options via the standard `DeadBro.configure` block:
+Enable or disable collectors in the DeadBro app, or use `DeadBro.configure` for code-based overrides:
 
 ```ruby
 DeadBro.configure do |config|

data/lib/dead_bro/circuit_breaker.rb

@@ -25,15 +25,17 @@ module DeadBro
       @failure_count = 0
       @last_failure_time = nil
       @last_success_time = nil
+      @mutex = Mutex.new
     end
 
     def call(&block)
-      case @state
+      state = @mutex.synchronize { @state }
+      case state
       when CLOSED
         execute_with_monitoring(&block)
       when OPEN
         if should_attempt_reset?
-          @state = HALF_OPEN
+          @mutex.synchronize { @state = HALF_OPEN }
           execute_with_monitoring(&block)
         else
           :circuit_open
@@ -43,75 +45,93 @@ module DeadBro
       end
     end
 
-    attr_reader :state
+    def state
+      @mutex.synchronize { @state }
+    end
 
-    attr_reader :failure_count
+    def failure_count
+      @mutex.synchronize { @failure_count }
+    end
 
-    attr_reader :last_failure_time
+    def last_failure_time
+      @mutex.synchronize { @last_failure_time }
+    end
 
-    attr_reader :last_success_time
+    def last_success_time
+      @mutex.synchronize { @last_success_time }
+    end
 
     def reset!
-      @state = CLOSED
-      @failure_count = 0
-      @last_failure_time = nil
+      @mutex.synchronize do
+        @state = CLOSED
+        @failure_count = 0
+        @last_failure_time = nil
+      end
     end
 
     def open!
-      @state = OPEN
-      @last_failure_time = Time.now
+      @mutex.synchronize do
+        @state = OPEN
+        @last_failure_time = Time.now
+      end
     end
 
     def transition_to_half_open!
-      @state = HALF_OPEN
+      @mutex.synchronize { @state = HALF_OPEN }
     end
 
     def should_attempt_reset?
-      return false unless @last_failure_time
+      @mutex.synchronize do
+        return false unless @last_failure_time
+        (Time.now - @last_failure_time) >= @recovery_timeout
+      end
+    end
+
+    # Public entry points for callers that already know the outcome (e.g. the
+    # HTTP dispatcher thread). Preferred over `call(&block)` when the caller
+    # is doing its own error handling.
+    def record_success
+      @mutex.synchronize do
+        @failure_count = 0
+        @last_success_time = Time.now
+        @state = CLOSED
+      end
+    end
 
-      # Try to reset after recovery timeout
-      elapsed = Time.now - @last_failure_time
-      elapsed >= @recovery_timeout
+    def record_failure
+      @mutex.synchronize do
+        @failure_count += 1
+        @last_failure_time = Time.now
+        if @state == HALF_OPEN || @failure_count >= @failure_threshold
+          @state = OPEN
+        end
+      end
     end
 
     private
 
+    # Historical names kept as private aliases so existing specs and any
+    # internal callers that reach in via `send(:on_success)` still work.
+    alias_method :on_success, :record_success
+    alias_method :on_failure, :record_failure
+
     def execute_with_monitoring(&block)
       result = block.call
 
       if success?(result)
-        on_success
+        record_success
         result
       else
-        on_failure
+        record_failure
         result
       end
     rescue => e
-      on_failure
+      record_failure
       raise e
     end
 
     def success?(result)
-      # Consider 2xx status codes as success
       result.is_a?(Net::HTTPSuccess)
     end
-
-    def on_success
-      @failure_count = 0
-      @last_success_time = Time.now
-      @state = CLOSED
-    end
-
-    def on_failure
-      @failure_count += 1
-      @last_failure_time = Time.now
-
-      # If we're in half-open state and get a failure, go back to open
-      if @state == HALF_OPEN
-        @state = OPEN
-      elsif @failure_count >= @failure_threshold
-        @state = OPEN
-      end
-    end
   end
 end

data/lib/dead_bro/client.rb

@@ -12,30 +12,21 @@ module DeadBro
       @circuit_breaker = create_circuit_breaker
     end
 
-    def post_metric(event_name:, payload:)
+    def post_metric(event_name:, payload:, force: false)
       return if @configuration.api_key.nil?
       return unless @configuration.enabled
+      return if !force && !@configuration.should_sample?
+      return if circuit_open?
 
-      # Check sampling rate - skip if not selected for sampling
-      return unless @configuration.should_sample?
-
-      # Check circuit breaker before making request
-      if @circuit_breaker && @configuration.circuit_breaker_enabled
-        if @circuit_breaker.state == :open
-          # Check if we should attempt a reset to half-open state
-          if @circuit_breaker.should_attempt_reset?
-            @circuit_breaker.transition_to_half_open!
-          else
-            return
-          end
-        end
-      end
-
-      # Truncate large arrays to avoid 413 Request Entity Too Large
       payload = truncate_payload_for_request(payload)
+      body = {event: event_name, payload: payload, sent_at: Time.now.utc.iso8601, revision: @configuration.resolve_deploy_id}
 
-      # Make the HTTP request (async)
-      make_http_request(event_name, payload, @configuration.api_key)
+      dispatch_request(
+        url: metrics_endpoint_url,
+        body: body,
+        event_name: event_name,
+        apply_settings: true
+      )
 
       nil
     end
@@ -44,7 +35,15 @@ module DeadBro
       return if @configuration.api_key.nil?
 
       @configuration.last_heartbeat_attempt_at = Time.now.utc
-      make_http_request("heartbeat", {}, @configuration.api_key)
+      body = {event: "heartbeat", payload: {}, sent_at: Time.now.utc.iso8601, revision: @configuration.resolve_deploy_id}
+
+      dispatch_request(
+        url: metrics_endpoint_url,
+        body: body,
+        event_name: "heartbeat",
+        apply_settings: true
+      )
+
       nil
     end
 
@@ -52,27 +51,108 @@ module DeadBro
       return if @configuration.api_key.nil?
       return unless @configuration.enabled
       return unless @configuration.job_queue_monitoring_enabled
+      return if circuit_open?
+
+      body = {payload: payload, sent_at: Time.now.utc.iso8601, revision: @configuration.resolve_deploy_id}
+
+      dispatch_request(
+        url: monitor_endpoint_url,
+        body: body,
+        event_name: nil,
+        apply_settings: false
+      )
+
+      nil
+    end
+
+    private
+
+    # Returns true (and short-circuits) when the circuit is open and not ready
+    # to probe. Transitions to HALF_OPEN when the recovery timeout has elapsed.
+    def circuit_open?
+      return false unless @circuit_breaker && @configuration.circuit_breaker_enabled
+      return false unless @circuit_breaker.state == :open
+
+      if @circuit_breaker.should_attempt_reset?
+        @circuit_breaker.transition_to_half_open!
+        false
+      else
+        true
+      end
+    end
+
+    def metrics_endpoint_url
+      if @configuration.ruby_dev
+        "http://localhost:3100/apm/v1/metrics"
+      elsif ENV["USE_STAGING_ENDPOINT"] && !ENV["USE_STAGING_ENDPOINT"].empty?
+        "https://deadbro.aberatii.com/apm/v1/metrics"
+      else
+        "https://www.deadbro.com/apm/v1/metrics"
+      end
+    end
 
-      # Check circuit breaker before making request
-      if @circuit_breaker && @configuration.circuit_breaker_enabled
-        if @circuit_breaker.state == :open
-          # Check if we should attempt a reset to half-open state
-          if @circuit_breaker.should_attempt_reset?
-            @circuit_breaker.transition_to_half_open!
+    def monitor_endpoint_url
+      if @configuration.ruby_dev
+        "http://localhost:3100/apm/v1/monitor"
+      elsif ENV["USE_STAGING_ENDPOINT"] && !ENV["USE_STAGING_ENDPOINT"].empty?
+        "https://deadbro.aberatii.com/apm/v1/monitor"
+      else
+        "https://www.deadbro.com/apm/v1/monitor"
+      end
+    end
+
+    def dispatch_request(url:, body:, event_name:, apply_settings: false)
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.open_timeout = @configuration.open_timeout
+      http.read_timeout = @configuration.read_timeout
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request["Content-Type"] = "application/json"
+      request["Authorization"] = "Bearer #{@configuration.api_key}"
+      if @configuration.settings_received_at
+        request["X-Settings-Received-At"] = @configuration.settings_received_at.utc.iso8601
+      end
+      request.body = JSON.dump(body)
+
+      DeadBro::Dispatcher.instance.dispatch do
+        perform_request(http, request, event_name: event_name, apply_settings: apply_settings)
+      end
+    end
+
+    def perform_request(http, request, event_name:, apply_settings: false)
+      response = http.request(request)
+
+      if response
+        if @circuit_breaker && @configuration.circuit_breaker_enabled
+          if response.is_a?(Net::HTTPSuccess)
+            @circuit_breaker.record_success
           else
-            return
+            @circuit_breaker.record_failure
           end
         end
-      end
 
-      # Make the HTTP request (async) to jobs endpoint
-      make_monitor_request(payload, @configuration.api_key)
+        if apply_settings
+          apply_settings_from_response(response)
+
+          if response.is_a?(Net::HTTPSuccess) && event_name == "heartbeat"
+            @configuration.last_heartbeat_at = Time.now.utc
+          end
+        end
+      elsif @circuit_breaker && @configuration.circuit_breaker_enabled
+        @circuit_breaker.record_failure
+      end
 
+      response
+    rescue Timeout::Error
+      @circuit_breaker&.record_failure if @configuration.circuit_breaker_enabled
+      nil
+    rescue
+      @circuit_breaker&.record_failure if @configuration.circuit_breaker_enabled
       nil
     end
 
-    private
-
     def apply_settings_from_response(response)
       return unless response.is_a?(Net::HTTPSuccess)
 
@@ -87,7 +167,6 @@ module DeadBro
       # Malformed response — ignore, settings stay as-is
     end
 
-    # Limit payload size to avoid 413 from nginx/reverse proxies. Returns a new hash.
     def truncate_payload_for_request(payload)
       return payload unless payload.is_a?(Hash)
 
@@ -119,116 +198,6 @@ module DeadBro
       )
     end
 
-    def make_http_request(event_name, payload, api_key)
-      use_staging = ENV["USE_STAGING_ENDPOINT"] && !ENV["USE_STAGING_ENDPOINT"].empty?
-      production_url = use_staging ? "https://deadbro.aberatii.com/apm/v1/metrics" : "https://www.deadbro.com/apm/v1/metrics"
-      endpoint_url = @configuration.ruby_dev ? "http://localhost:3100/apm/v1/metrics" : production_url
-      uri = URI.parse(endpoint_url)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = (uri.scheme == "https")
-      http.open_timeout = @configuration.open_timeout
-      http.read_timeout = @configuration.read_timeout
-
-      request = Net::HTTP::Post.new(uri.request_uri)
-      request["Content-Type"] = "application/json"
-      request["Authorization"] = "Bearer #{api_key}"
-      if @configuration.settings_received_at
-        request["X-Settings-Received-At"] = @configuration.settings_received_at.utc.iso8601
-      end
-      body = {event: event_name, payload: payload, sent_at: Time.now.utc.iso8601, revision: @configuration.resolve_deploy_id}
-      request.body = JSON.dump(body)
-
-      # Fire-and-forget using a short-lived thread to avoid blocking the request cycle.
-      Thread.new do
-        response = http.request(request)
-
-        if response
-          # Update circuit breaker based on response
-          if @circuit_breaker && @configuration.circuit_breaker_enabled
-            if response.is_a?(Net::HTTPSuccess)
-              @circuit_breaker.send(:on_success)
-            else
-              @circuit_breaker.send(:on_failure)
-            end
-          end
-
-          # Apply remote settings if the backend included them in the response
-          apply_settings_from_response(response)
-
-          if response.is_a?(Net::HTTPSuccess) && event_name == "heartbeat"
-            @configuration.last_heartbeat_at = Time.now.utc
-          end
-        elsif @circuit_breaker && @configuration.circuit_breaker_enabled
-          # Treat nil response as failure for circuit breaker
-          @circuit_breaker.send(:on_failure)
-        end
-
-        response
-      rescue Timeout::Error
-        # Update circuit breaker on timeout
-        if @circuit_breaker && @configuration.circuit_breaker_enabled
-          @circuit_breaker.send(:on_failure)
-        end
-      rescue
-        # Update circuit breaker on exception
-        if @circuit_breaker && @configuration.circuit_breaker_enabled
-          @circuit_breaker.send(:on_failure)
-        end
-      end
-
-      nil
-    end
-
-    def make_monitor_request(payload, api_key)
-      use_staging = ENV["USE_STAGING_ENDPOINT"] && !ENV["USE_STAGING_ENDPOINT"].empty?
-      production_url = use_staging ? "https://deadbro.aberatii.com/apm/v1/monitor" : "https://www.deadbro.com/apm/v1/monitor"
-      endpoint_url = @configuration.ruby_dev ? "http://localhost:3100/apm/v1/monitor" : production_url
-      uri = URI.parse(endpoint_url)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = (uri.scheme == "https")
-      http.open_timeout = @configuration.open_timeout
-      http.read_timeout = @configuration.read_timeout
-
-      request = Net::HTTP::Post.new(uri.request_uri)
-      request["Content-Type"] = "application/json"
-      request["Authorization"] = "Bearer #{api_key}"
-      body = {payload: payload, sent_at: Time.now.utc.iso8601, revision: @configuration.resolve_deploy_id}
-      request.body = JSON.dump(body)
-
-      # Fire-and-forget using a short-lived thread to avoid blocking
-      Thread.new do
-        response = http.request(request)
-
-        if response
-          # Update circuit breaker based on response
-          if @circuit_breaker && @configuration.circuit_breaker_enabled
-            if response.is_a?(Net::HTTPSuccess)
-              @circuit_breaker.send(:on_success)
-            else
-              @circuit_breaker.send(:on_failure)
-            end
-          end
-        elsif @circuit_breaker && @configuration.circuit_breaker_enabled
-          # Treat nil response as failure for circuit breaker
-          @circuit_breaker.send(:on_failure)
-        end
-
-        response
-      rescue Timeout::Error
-        # Update circuit breaker on timeout
-        if @circuit_breaker && @configuration.circuit_breaker_enabled
-          @circuit_breaker.send(:on_failure)
-        end
-      rescue
-        # Update circuit breaker on exception
-        if @circuit_breaker && @configuration.circuit_breaker_enabled
-          @circuit_breaker.send(:on_failure)
-        end
-      end
-
-      nil
-    end
-
     def log_debug(message)
       if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
         Rails.logger.debug(message)