dead_bro 0.2.9 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8badc23e17a92bca8e8057c8c49c6ba7a1535975a7da9f61a43fd0e2b80f56b5
-  data.tar.gz: 32ed00be83e65d97b89e3467129f95986d0417ec27839066a83b7706182a28ba
+  metadata.gz: 1ac04c555f3f82572e94327d09b90672869eb17c129deb87c78f746625cb5afd
+  data.tar.gz: 4639f701e7bd5dff8b36933e85b405dbbe43a2ccc664c94f16b6e2ea98987fda
 SHA512:
-  metadata.gz: becf47113fbfb03c8f851f54e3e518588e8ebc963f762d68b699b3a01dad7bab381c6d07c323abeb1d1414f20a24d949bf4cc245821ea96c4ee38e8e155f82ad
-  data.tar.gz: 1071fe9473be03be215822ab0bc9349ba1569a03f6d01fca372911f390c584227ebcd4c42272da8dd66198b560c5f09de83c42b6238dd8710241889c9e2cdb55
+  metadata.gz: fee0d59a0362226babd057547b8138078d5ce3da4a75a3c5a2bbd175ee21b3043485e9f6c8e0b0a27a18c2373f10827fc7804f64c96888a41eea8d3c8eb8ea74
+  data.tar.gz: 1e044e7a275a5e52843119e00488a8a458e6d6f95420543014edd1074985bcdeebe1cbeef579e436a4eb31836eb6f9e24961c039851c4c82b2b0a76184cf23d2

data/README.md

@@ -388,6 +388,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/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/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.10"
 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.10
 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