dead_bro 0.2.9 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8badc23e17a92bca8e8057c8c49c6ba7a1535975a7da9f61a43fd0e2b80f56b5
-  data.tar.gz: 32ed00be83e65d97b89e3467129f95986d0417ec27839066a83b7706182a28ba
+  metadata.gz: 56f6a72ccfa1a5e362c74eddace39a1ffeba97d06bab551f38d9091311609770
+  data.tar.gz: 20ee34708c5eed8ac00af8d462953422ba7a24e3b9701e56e31eea8ba35752f0
 SHA512:
-  metadata.gz: becf47113fbfb03c8f851f54e3e518588e8ebc963f762d68b699b3a01dad7bab381c6d07c323abeb1d1414f20a24d949bf4cc245821ea96c4ee38e8e155f82ad
-  data.tar.gz: 1071fe9473be03be215822ab0bc9349ba1569a03f6d01fca372911f390c584227ebcd4c42272da8dd66198b560c5f09de83c42b6238dd8710241889c9e2cdb55
+  metadata.gz: 932ce6601969ac9f95ba0ce327b93a5412c167a4c7fe367d0c14bd05c5c751b69bb3da48eaf829e73bcf6ca10c66fd7678ff0caca4eba7e0ec42a3b4bae72e54
+  data.tar.gz: 032ee4230c5b043a7ef8cf176963500eb60157927ad18f18c8e657f2439b31ab8b3526e7dd90036f79ec5fc7e978b55de540fcad14925f1fb33ffb6308379964

data/FEATURES.md

@@ -284,12 +284,7 @@ A comprehensive feature list for comparing ApmBro with other APM (Application Pe
 ## 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
+- **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

data/README.md

@@ -30,6 +30,25 @@ 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).
 
+### Deploy / release tracking (ECS, Kubernetes, autoscaling groups)
+
+DeadBro sends a **`revision`** string on every payload so charts and deploys group metrics by release. If you do **not** configure a stable value, the gem generates a UUID **once per Ruby process**. With multiple containers or EC2 instances, each replica then looks like a separate deployment.
+
+**Use one shared identifier for every task in the same rollout**, for example:
+
+- Set `DEAD_BRO_DEPLOY_ID` (or `dead_bro_DEPLOY_ID`) in the task definition / pod spec to your **git SHA**, **image digest**, or CD **release id** injected at build or deploy time.
+- Or set it in Ruby (this wins over environment variables when non-blank):
+
+```ruby
+DeadBro.configure do |config|
+  config.deploy_id = ENV.fetch("GIT_SHA") { raise "Set GIT_SHA in the task definition" }
+end
+```
+
+The gem also checks these environment variables in order (first non-empty wins): `DEAD_BRO_DEPLOY_ID`, `dead_bro_DEPLOY_ID`, `GIT_REV`, `GIT_COMMIT`, `GIT_COMMIT_SHA`, `GIT_SHA`, `CODEBUILD_RESOLVED_SOURCE_REVISION`, `HEROKU_SLUG_COMMIT`, `RENDER_GIT_COMMIT`, `DD_VERSION`, `APP_REVISION`, `RELEASE_VERSION`, `SOURCE_VERSION`.
+
+For **Amazon ECS**, add one of these variables in your task definition from CodeBuild, GitHub Actions, or your pipeline so all tasks in the service share the same value for that image version.
+
 ### 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).
@@ -388,6 +407,69 @@ The control plane job sends a single JSON payload roughly shaped like:
 Not all fields will be present in all environments; unsupported or unavailable metrics may be `null` or omitted, and any hard failures are captured in `error_class` / `error_message` fields per section.
 
 
+## One-Off Analysis with `DeadBro.analyze`
+
+Use `DeadBro.analyze` to profile any block of code inline — useful in the Rails console, rake tasks, or debug sessions. It tracks execution time, SQL queries, and memory usage without sending data to the DeadBro backend.
+
+```ruby
+result = DeadBro.analyze("load active users") do
+  User.where(active: true).includes(:profile).to_a
+end
+```
+
+Returns a `DeadBro::AnalysisResult` struct.
+
+### Return Value
+
+`DeadBro::AnalysisResult` exposes:
+
+| Member | Type | Description |
+|---|---|---|
+| `label` | String | Label passed to the block |
+| `total_time_ms` | Float | Wall time of the block |
+| `sql_count` | Integer | Number of SQL queries executed |
+| `sql_time_ms` | Float | Total SQL execution time |
+| `sql_queries` | Array | Per-query breakdown (see below) |
+| `memory_before_mb` | Float | RSS before block |
+| `memory_after_mb` | Float | RSS after block |
+| `memory_delta_mb` | Float | Memory change |
+| `memory_details` | Hash | GC stats, new objects, heap pages |
+
+**`sql_queries` is intentionally excluded from `inspect`/`to_s`** to avoid flooding the console with a long array. Access it explicitly when needed:
+
+```ruby
+result             # => #<DeadBro::AnalysisResult label="load active users" total_time_ms=42.3 ...>
+result.sql_queries # => [{sql: "SELECT ...", query_type: "SELECT", count: 3, total_time_ms: 12.1}, ...]
+```
+
+### Options
+
+```ruby
+DeadBro.analyze("my block", verbose: true) do
+  # verbose: true lowers the Rails log level to DEBUG and enables
+  # ActiveRecord.verbose_query_logs for the duration of the block
+  MyService.call
+end
+```
+
+### Helper methods
+
+```ruby
+result.most_queries    # top 5 query patterns by execution count
+result.longest_queries # top 5 query patterns by total_time_ms
+```
+
+Both return an array of query hashes (same shape as `sql_queries`):
+
+- `sql` — normalized SQL (literals replaced, whitespace collapsed)
+- `query_type` — e.g. `"SELECT"`, `"INSERT"`, `"UPDATE"`
+- `count` — how many times this pattern ran
+- `total_time_ms` — combined time across all occurrences
+
+### `sql_queries` fields
+
+`result.sql_queries` returns the full list. Each entry is a hash with the same fields as above.
+
 ## 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.

data/lib/dead_bro/configuration.rb

@@ -7,7 +7,7 @@ module DeadBro
     # returns it in a response; local configure() values apply until the next remote update.
     attr_accessor :api_key, :open_timeout, :read_timeout, :enabled, :ruby_dev,
       :circuit_breaker_enabled, :circuit_breaker_failure_threshold, :circuit_breaker_recovery_timeout,
-      :circuit_breaker_retry_timeout, :deploy_id, :disk_paths, :interfaces_ignore
+      :circuit_breaker_retry_timeout, :disk_paths, :interfaces_ignore
 
     # Remote-managed settings (overwritten by backend JSON `settings` on successful API responses)
     attr_accessor :memory_tracking_enabled, :allocation_tracking_enabled,
@@ -30,6 +30,24 @@ module DeadBro
 
     HEARTBEAT_INTERVAL = 60 # seconds
 
+    # First non-empty ENV value wins for release/revision payloads and deploy grouping on the server.
+    # Order is roughly: DeadBro-native → common CI/hosting → observability tooling.
+    DEPLOY_REVISION_ENV_KEYS = %w[
+      DEAD_BRO_DEPLOY_ID
+      dead_bro_DEPLOY_ID
+      GIT_REV
+      GIT_COMMIT
+      GIT_COMMIT_SHA
+      GIT_SHA
+      CODEBUILD_RESOLVED_SOURCE_REVISION
+      HEROKU_SLUG_COMMIT
+      RENDER_GIT_COMMIT
+      DD_VERSION
+      APP_REVISION
+      RELEASE_VERSION
+      SOURCE_VERSION
+    ].freeze
+
     REMOTE_SETTING_KEYS = %w[
       enabled sample_rate memory_tracking_enabled allocation_tracking_enabled
       explain_analyze_enabled slow_query_threshold_ms max_sql_queries_to_send max_logs_to_send
@@ -47,7 +65,7 @@ module DeadBro
       @circuit_breaker_failure_threshold = 3
       @circuit_breaker_recovery_timeout = 60
       @circuit_breaker_retry_timeout = 300
-      @deploy_id = resolve_deploy_id
+      @explicit_deploy_revision = nil
       @disk_paths = ["/"]
       @interfaces_ignore = %w[lo lo0 docker0]
 
@@ -74,6 +92,17 @@ module DeadBro
       @settings_mutex = Mutex.new
     end
 
+    # Current release revision sent as `revision` on all API payloads — same semantics as `#resolve_deploy_id`.
+    def deploy_id
+      resolve_deploy_id
+    end
+
+    # Overrides ENV-based resolution when set to a non-empty string (or clears override when nil/blank).
+    def deploy_id=(value)
+      s = value&.respond_to?(:to_s) ? value.to_s.strip : ""
+      @explicit_deploy_revision = s.empty? ? nil : s
+    end
+
     def excluded_controllers=(value)
       @excluded_controllers = Array(value).map(&:to_s)
       @compiled_excluded_controllers = compile_patterns(@excluded_controllers)
@@ -124,7 +153,20 @@ module DeadBro
     end
 
     def resolve_deploy_id
-      ENV["dead_bro_DEPLOY_ID"] || ENV["GIT_REV"] || ENV["HEROKU_SLUG_COMMIT"] || DeadBro.process_deploy_id
+      explicit = @explicit_deploy_revision&.to_s&.strip
+      return explicit unless explicit.nil? || explicit.empty?
+
+      DEPLOY_REVISION_ENV_KEYS.each do |key|
+        v = ENV[key]
+        next unless v.respond_to?(:to_s)
+
+        stripped = v.to_s.strip
+        next if stripped.empty?
+
+        return stripped
+      end
+
+      DeadBro.process_deploy_id
     end
 
     def excluded_controller?(controller_name, action_name = nil)

data/lib/dead_bro/elasticsearch_subscriber.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module DeadBro
+  class ElasticsearchSubscriber
+    THREAD_LOCAL_KEY = :dead_bro_elasticsearch_events
+    MAX_TRACKED_EVENTS = 500
+
+    # Install gem-based notification subscriber (request.elasticsearch / request.elastic_transport).
+    # The Net::HTTP path is handled by HttpInstrumentation, which calls .record directly.
+    def self.subscribe!
+      install_notifications_subscription!
+    rescue
+    end
+
+    # Called by HttpInstrumentation when it detects a Net::HTTP request to an ES host.
+    def self.record(method:, path:, status:, duration_ms:)
+      events = Thread.current[THREAD_LOCAL_KEY]
+      return unless events
+      return unless should_continue_tracking?
+
+      events << build_event(method, path, status, duration_ms)
+    rescue
+    end
+
+    def self.start_request_tracking
+      Thread.current[THREAD_LOCAL_KEY] = []
+    end
+
+    def self.stop_request_tracking
+      events = Thread.current[THREAD_LOCAL_KEY]
+      Thread.current[THREAD_LOCAL_KEY] = nil
+      events || []
+    end
+
+    def self.should_continue_tracking?
+      events = Thread.current[THREAD_LOCAL_KEY]
+      return false unless events
+      return false if events.length >= MAX_TRACKED_EVENTS
+
+      start_time = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
+      if start_time
+        elapsed_seconds = Time.now - start_time
+        return false if elapsed_seconds >= DeadBro::MAX_TRACKING_DURATION_SECONDS
+      end
+
+      true
+    end
+
+    def self.extract_operation(method, path)
+      return "unknown" if path.nil?
+
+      clean = path.to_s.split("?").first.to_s
+      m = method.to_s.upcase
+
+      if clean =~ /_search\z/i
+        "search"
+      elsif clean =~ /_msearch\z/i
+        "msearch"
+      elsif clean =~ /_bulk\z/i
+        "bulk"
+      elsif clean =~ /_doc\/[^\/]+\/_update\z/i
+        "update"
+      elsif clean =~ /_update\/[^\/]+\z/i
+        "update"
+      elsif clean =~ /_delete_by_query\z/i
+        "delete_by_query"
+      elsif clean =~ /_count\z/i
+        "count"
+      elsif clean =~ /_mapping\z/i
+        m == "GET" ? "get_mapping" : "put_mapping"
+      elsif clean =~ /_doc\/[^\/]+\z/i
+        case m
+        when "GET"        then "get"
+        when "DELETE"     then "delete"
+        when "POST", "PUT" then "index"
+        else "doc"
+        end
+      elsif clean =~ /_doc\z/i
+        "index"
+      elsif clean =~ /\A\/_cluster\//i
+        "cluster"
+      elsif clean =~ /\A\/_cat\//i
+        "cat"
+      elsif clean =~ /\A\/[^\/]+\z/
+        case m
+        when "PUT"    then "create_index"
+        when "DELETE" then "delete_index"
+        when "HEAD"   then "index_exists"
+        when "GET"    then "get_index"
+        else "index_op"
+        end
+      else
+        m.downcase
+      end
+    rescue
+      "unknown"
+    end
+
+    def self.sanitize_path(path)
+      return "" if path.nil?
+      path.to_s
+        .gsub(/\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i, "/{id}")
+        .gsub(/\/\d+(?=\/|\z)/, "/{id}")
+    rescue
+      path.to_s
+    end
+
+    class << self
+      private
+
+      def install_notifications_subscription!
+        return unless defined?(::ActiveSupport::Notifications)
+
+        %w[request.elasticsearch request.elastic_transport].each do |event_name|
+          ::ActiveSupport::Notifications.subscribe(event_name) do |_name, started, finished, _id, payload|
+            events = Thread.current[THREAD_LOCAL_KEY]
+            next unless events
+            next unless should_continue_tracking?
+
+            duration_ms = ((finished - started) * 1000.0).round(2)
+            method = payload[:method].to_s.upcase
+            path = payload[:path].to_s
+            events << build_event(method, path, payload[:status], duration_ms)
+          rescue
+          end
+        end
+      rescue
+      end
+
+      def build_event(method, path, status, duration_ms)
+        {
+          method: method.to_s.upcase,
+          path: sanitize_path(path),
+          operation: extract_operation(method, path),
+          status: status,
+          duration_ms: duration_ms
+        }
+      end
+    end
+  end
+end

data/lib/dead_bro/http_instrumentation.rb

@@ -12,6 +12,7 @@ module DeadBro
     def self.install!(client: Client.new)
       install_net_http!(client)
       install_typhoeus!(client) if defined?(::Typhoeus)
+      install_faraday!(client) if defined?(::Faraday)
     rescue
       # Never raise from instrumentation install
     end
@@ -38,23 +39,37 @@ module DeadBro
                 nil
               end
 
-              # 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?("aberatii.com"))
+              host = (uri && uri.host) || @address
+              port = (uri && uri.port) || @port
+              is_es_host = DeadBro::HttpInstrumentation.elasticsearch_host?(host, port)
+              # Skip localhost/internal only for non-ES hosts. ES on localhost (e.g. port 9200)
+              # must still be tracked; only skip the deadbro backend itself.
+              skip_instrumentation = !is_es_host && uri && (uri.to_s.include?("localhost") || uri.to_s.include?("aberatii.com"))
 
-              unless skip_instrumentation
+              if is_es_host
+                # Route to elasticsearch subscriber instead of http_outgoing
+                if Thread.current[DeadBro::ElasticsearchSubscriber::THREAD_LOCAL_KEY]
+                  path = (uri && uri.path) || req.path
+                  DeadBro::ElasticsearchSubscriber.record(
+                    method: req.method,
+                    path: path,
+                    status: response && response.code.to_i,
+                    duration_ms: duration_ms
+                  )
+                end
+              elsif !skip_instrumentation
+                lib = DeadBro::HttpInstrumentation.typesense_host?(host, port) ? "typesense" : "net_http"
                 payload = {
-                  library: "net_http",
+                  library: lib,
                   method: req.method,
                   url: uri && uri.to_s,
-                  host: (uri && uri.host) || @address,
+                  host: host,
                   path: (uri && uri.path) || req.path,
                   status: response && response.code.to_i,
                   duration_ms: duration_ms,
                   exception: error && error.class.name
                 }
-                # Accumulate per-request; only send with controller metric
-                if Thread.current[THREAD_LOCAL_KEY] && should_continue_tracking?
+                if Thread.current[THREAD_LOCAL_KEY] && DeadBro::HttpInstrumentation.should_continue_tracking?
                   Thread.current[THREAD_LOCAL_KEY] << payload
                 end
               end
@@ -85,8 +100,6 @@ module DeadBro
                 (respond_to?(:base_url) ? base_url : nil)
               end
 
-              # 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") || req_url.include?("deadbro.aberatii.com/apm/v1/metrics"))
 
               unless skip_instrumentation
@@ -97,8 +110,7 @@ module DeadBro
                   status: response && response.code,
                   duration_ms: duration_ms
                 }
-                # Accumulate per-request; only send with controller metric
-                if Thread.current[THREAD_LOCAL_KEY] && should_continue_tracking?
+                if Thread.current[THREAD_LOCAL_KEY] && DeadBro::HttpInstrumentation.should_continue_tracking?
                   Thread.current[THREAD_LOCAL_KEY] << payload
                 end
               end
@@ -112,15 +124,96 @@ module DeadBro
     rescue
     end
 
-    # Check if we should continue tracking based on count and time limits
+    def self.install_faraday!(client)
+      return unless defined?(::Faraday)
+
+      unless defined?(::DeadBro::FaradayMiddleware)
+        middleware_klass = Class.new(::Faraday::Middleware) do
+          def call(env)
+            start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            response = nil
+            begin
+              response = @app.call(env)
+            ensure
+              finish_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+              duration_ms = ((finish_time - start_time) * 1000.0).round(2)
+              begin
+                url = env.url
+                host = url.host.to_s
+                port = url.port
+                url_str = url.to_s
+
+                is_es_host = DeadBro::HttpInstrumentation.elasticsearch_host?(host, port)
+                skip = !is_es_host && (url_str.include?("localhost") || url_str.include?("aberatii.com"))
+
+                if is_es_host
+                  if Thread.current[DeadBro::ElasticsearchSubscriber::THREAD_LOCAL_KEY]
+                    DeadBro::ElasticsearchSubscriber.record(
+                      method: env.method.to_s.upcase,
+                      path: url.path,
+                      status: response&.status,
+                      duration_ms: duration_ms
+                    )
+                  end
+                elsif !skip
+                  lib = DeadBro::HttpInstrumentation.typesense_host?(host, port) ? "typesense" : "faraday"
+                  payload = {
+                    library: lib,
+                    method: env.method.to_s.upcase,
+                    url: url_str,
+                    host: host,
+                    path: url.path,
+                    status: response&.status,
+                    duration_ms: duration_ms
+                  }
+                  key = DeadBro::HttpInstrumentation::THREAD_LOCAL_KEY
+                  if Thread.current[key] && DeadBro::HttpInstrumentation.should_continue_tracking?
+                    Thread.current[key] << payload
+                  end
+                end
+              rescue
+              end
+            end
+          end
+        end
+        ::DeadBro.const_set(:FaradayMiddleware, middleware_klass)
+      end
+
+      unless defined?(::DeadBro::FaradayInstrumentation)
+        instrumentation_mod = Module.new do
+          define_method(:initialize) do |url = nil, options = {}, &block|
+            super(url, options, &block)
+            unless builder.handlers.map(&:klass).include?(::DeadBro::FaradayMiddleware)
+              builder.use(::DeadBro::FaradayMiddleware)
+            end
+          rescue
+          end
+        end
+        ::DeadBro.const_set(:FaradayInstrumentation, instrumentation_mod)
+      end
+
+      ::Faraday::Connection.prepend(::DeadBro::FaradayInstrumentation) unless ::Faraday::Connection.ancestors.include?(::DeadBro::FaradayInstrumentation)
+    rescue
+    end
+
+    def self.elasticsearch_host?(host, port)
+      return false if host.nil?
+      return true if port == 9200
+      h = host.to_s
+      h.end_with?(".elastic.co") || h.end_with?(".es.amazonaws.com") || h.include?("elasticsearch")
+    end
+
+    def self.typesense_host?(host, port)
+      return false if host.nil?
+      port == 8108 || host.to_s.end_with?(".typesense.io")
+    end
+
     def self.should_continue_tracking?
       events = Thread.current[THREAD_LOCAL_KEY]
       return false unless events
 
-      # Check count limit
       return false if events.length >= MAX_TRACKED_EVENTS
 
-      # Check time limit
       start_time = Thread.current[DeadBro::TRACKING_START_TIME_KEY]
       if start_time
         elapsed_seconds = Time.now - start_time

data/lib/dead_bro/job_subscriber.rb

@@ -215,7 +215,7 @@ module DeadBro
           (arg.length > 200) ? arg[0, 200] + "..." : arg
         when Hash
           # Filter sensitive keys and limit size
-          filtered = arg.except(*%w[password token secret key])
+          filtered = arg.reject { |k, _| %w[password token secret key].include?(k.to_s) }
           (filtered.keys.size > 20) ? filtered.first(20).to_h : filtered
         when Array
           arg.first(5)

data/lib/dead_bro/railtie.rb

@@ -32,6 +32,10 @@ if defined?(Rails) && defined?(Rails::Railtie)
           require "dead_bro/redis_subscriber"
           DeadBro::RedisSubscriber.subscribe!
 
+          # Install Elasticsearch / OpenSearch tracking
+          require "dead_bro/elasticsearch_subscriber"
+          DeadBro::ElasticsearchSubscriber.subscribe!
+
           # Install view rendering tracking
           require "dead_bro/view_rendering_subscriber"
           DeadBro::ViewRenderingSubscriber.subscribe!(client: shared_client)

data/lib/dead_bro/sql_subscriber.rb

@@ -151,9 +151,8 @@ module DeadBro
     # storm from spawning unbounded background threads.
     MAX_PENDING_EXPLAINS = 20
     # Overall wall-clock we're willing to block the request thread for pending
-    # EXPLAINs. Dropped from 5s → 1s: if the plan isn't ready by then, skip it
-    # rather than stall the request.
-    EXPLAIN_WAIT_TIMEOUT_SECONDS = 1.0
+    # EXPLAINs. If the plan isn't ready by then, skip it rather than stall the request.
+    EXPLAIN_WAIT_TIMEOUT_SECONDS = 5.0
 
     def self.wait_for_pending_explains(timeout_seconds)
       pending = Thread.current[THREAD_LOCAL_EXPLAIN_PENDING_KEY]

data/lib/dead_bro/sql_tracking_middleware.rb

@@ -40,6 +40,11 @@ module DeadBro
         DeadBro::MemoryTrackingSubscriber.start_request_tracking
       end
 
+      # Start Elasticsearch tracking for this request
+      if defined?(DeadBro::ElasticsearchSubscriber)
+        DeadBro::ElasticsearchSubscriber.start_request_tracking
+      end
+
       # Start outgoing HTTP accumulation for this request
       Thread.current[:dead_bro_http_events] = []
 
@@ -74,7 +79,8 @@ module DeadBro
         Thread.current[:dead_bro_lightweight_memory] = nil
       end
 
-      # Clean up HTTP events and tracking start time
+      # Clean up HTTP events, ES events, and tracking start time
+      Thread.current[:dead_bro_elasticsearch_events] = nil
       Thread.current[:dead_bro_http_events] = nil
       Thread.current[DeadBro::TRACKING_START_TIME_KEY] = nil
     end

data/lib/dead_bro/subscriber.rb

@@ -46,9 +46,10 @@ module DeadBro
         # Stop SQL tracking and get collected queries (this was started by the request)
         sql_queries = DeadBro::SqlSubscriber.stop_request_tracking
 
-        # Stop cache and redis tracking
+        # Stop cache, redis, and elasticsearch tracking
         cache_events = defined?(DeadBro::CacheSubscriber) ? DeadBro::CacheSubscriber.stop_request_tracking : []
         redis_events = defined?(DeadBro::RedisSubscriber) ? DeadBro::RedisSubscriber.stop_request_tracking : []
+        elasticsearch_events = defined?(DeadBro::ElasticsearchSubscriber) ? DeadBro::ElasticsearchSubscriber.stop_request_tracking : []
 
         # Stop view rendering tracking and get collected view events
         view_events = DeadBro::ViewRenderingSubscriber.stop_request_tracking
@@ -152,6 +153,7 @@ module DeadBro
           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,
@@ -171,6 +173,7 @@ module DeadBro
       DeadBro::SqlSubscriber.stop_request_tracking if defined?(DeadBro::SqlSubscriber)
       DeadBro::CacheSubscriber.stop_request_tracking if defined?(DeadBro::CacheSubscriber)
       DeadBro::RedisSubscriber.stop_request_tracking if defined?(DeadBro::RedisSubscriber)
+      DeadBro::ElasticsearchSubscriber.stop_request_tracking if defined?(DeadBro::ElasticsearchSubscriber)
       DeadBro::ViewRenderingSubscriber.stop_request_tracking if defined?(DeadBro::ViewRenderingSubscriber)
       DeadBro::LightweightMemoryTracker.stop_request_tracking if defined?(DeadBro::LightweightMemoryTracker)
       if DeadBro.configuration.allocation_tracking_enabled && defined?(DeadBro::MemoryTrackingSubscriber)

data/lib/dead_bro/version.rb

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

data/lib/dead_bro.rb

@@ -13,6 +13,7 @@ module DeadBro
   autoload :SqlTrackingMiddleware, "dead_bro/sql_tracking_middleware"
   autoload :CacheSubscriber, "dead_bro/cache_subscriber"
   autoload :RedisSubscriber, "dead_bro/redis_subscriber"
+  autoload :ElasticsearchSubscriber, "dead_bro/elasticsearch_subscriber"
   autoload :ViewRenderingSubscriber, "dead_bro/view_rendering_subscriber"
   autoload :MemoryTrackingSubscriber, "dead_bro/memory_tracking_subscriber"
   autoload :MemoryLeakDetector, "dead_bro/memory_leak_detector"
@@ -30,6 +31,57 @@ module DeadBro
 
   class Error < StandardError; end
 
+  # Returned by DeadBro.analyze. sql_queries is intentionally omitted from
+  # inspect/to_s/pretty_print to avoid bloating console output.
+  # Access it explicitly via .sql_queries.
+  class AnalysisResult
+    attr_reader :label, :total_time_ms, :sql_count, :sql_time_ms,
+                :sql_queries, :memory_before_mb, :memory_after_mb,
+                :memory_delta_mb, :memory_details, :verbose
+
+    def initialize(label:, total_time_ms:, sql_count:, sql_time_ms:, sql_queries:,
+                   memory_before_mb:, memory_after_mb:, memory_delta_mb:,
+                   memory_details:, verbose:)
+      @label = label
+      @total_time_ms = total_time_ms
+      @sql_count = sql_count
+      @sql_time_ms = sql_time_ms
+      @sql_queries = sql_queries
+      @memory_before_mb = memory_before_mb
+      @memory_after_mb = memory_after_mb
+      @memory_delta_mb = memory_delta_mb
+      @memory_details = memory_details
+      @verbose = verbose
+    end
+
+    def inspect
+      "#<DeadBro::AnalysisResult label=#{label.inspect} total_time_ms=#{total_time_ms} " \
+        "sql_count=#{sql_count} sql_time_ms=#{sql_time_ms} " \
+        "memory_before_mb=#{memory_before_mb} memory_after_mb=#{memory_after_mb} " \
+        "memory_delta_mb=#{memory_delta_mb}>"
+    end
+
+    alias_method :to_s, :inspect
+
+    def most_queries
+      sql_queries.max_by(5) { |q| q[:count] }
+    end
+
+    def longest_queries
+      sql_queries.max_by(5) { |q| q[:total_time_ms] }
+    end
+
+    def pretty_print(pp)
+      pp.text(inspect)
+    end
+
+    def [](key)
+      public_send(key)
+    rescue NoMethodError
+      nil
+    end
+  end
+
   def self.configure
     yield configuration
   end
@@ -102,7 +154,8 @@ module DeadBro
   # - memory before/after and delta
   # - when detailed memory tracking is enabled, GC and allocation stats
   #
-  # The return value of this method is a hash with the following keys:
+  # The return value is a DeadBro::AnalysisResult struct. sql_queries is omitted from
+  # inspect/to_s but accessible via .sql_queries. Other members:
   # - :label
   # - :total_time_ms
   # - :sql_count
@@ -249,8 +302,6 @@ module DeadBro
         entry[:type] ||= q[:query_type]
       end
 
-      top_query_signatures = query_signatures.sort_by { |_, data| -data[:count] }.first(3)
-
       # Capture post-block memory state — always, regardless of config.
       gc_after = begin; GC.stat; rescue; {}; end
       memory_after_mb = begin; DeadBro::MemoryHelpers.rss_mb; rescue; memory_before_mb; end
@@ -287,38 +338,6 @@ module DeadBro
         large_objects: large_objects
       )
 
-      sql_queries_segment = ""
-      unless top_query_signatures.empty?
-        formatted_queries = top_query_signatures.map do |sig, data|
-          type = data[:type] || "SQL"
-          count = data[:count]
-          total_ms = data[:total_time_ms].round(2)
-          "#{type} #{sig} (#{count}x, #{total_ms}ms)"
-        end
-        sql_queries_segment = ", sql_top_queries=[#{formatted_queries.join(" | ")}]"
-      end
-
-      warnings = detailed_memory_summary[:warnings]
-      warnings_segment = warnings.any? ? ", warnings=[#{warnings.join(", ")}]" : ""
-      summary = "Analysis for #{label} - total_time=#{total_time_ms}ms, " \
-                "sql_queries=#{sql_count}, sql_time=#{sql_time_ms}ms, " \
-                "memory_before=#{memory_before_mb.round(2)}MB, " \
-                "memory_after=#{memory_after_mb.round(2)}MB, " \
-                "memory_delta=#{memory_delta_mb}MB, " \
-                "gc_collections=+#{detailed_memory_summary[:gc_collections]}, " \
-                "heap_pages_added=+#{detailed_memory_summary[:heap_pages_added]}, " \
-                "new_objects=+#{detailed_memory_summary[:new_objects]}" \
-                "#{sql_queries_segment}#{warnings_segment}"
-
-      begin
-        DeadBro.logger.info(summary)
-      rescue
-        begin
-          $stdout.puts("[DeadBro] #{summary}")
-        rescue
-        end
-      end
-
       # Build structured result hash to return to the caller
       sql_queries_detail = query_signatures.map do |sig, data|
         {
@@ -329,7 +348,7 @@ module DeadBro
         }
       end
 
-      analysis_result = {
+      analysis_result = AnalysisResult.new(
         label: label,
         total_time_ms: total_time_ms,
         sql_count: sql_count,
@@ -340,7 +359,7 @@ module DeadBro
         memory_delta_mb: memory_delta_mb,
         memory_details: detailed_memory_summary,
         verbose: verbose
-      }
+      )
     end
 
     raise error if error

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dead_bro
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.2.12
 platform: ruby
 authors:
 - Emanuel Comsa
@@ -34,6 +34,7 @@ files:
 - lib/dead_bro/collectors/system.rb
 - lib/dead_bro/configuration.rb
 - lib/dead_bro/dispatcher.rb
+- lib/dead_bro/elasticsearch_subscriber.rb
 - lib/dead_bro/error_middleware.rb
 - lib/dead_bro/http_instrumentation.rb
 - lib/dead_bro/job_sql_tracking_middleware.rb
@@ -64,7 +65,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="