dead_bro 0.2.0

data/lib/dead_bro/subscriber.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module DeadBro
+  class Subscriber
+    EVENT_NAME = "process_action.action_controller"
+
+    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 DeadBro.configuration.excluded_controller?(controller_name, action_name)
+            puts "excluded controller"
+            next
+          end
+          # If exclusive_controller_actions is defined and not empty, only track matching actions
+          unless DeadBro.configuration.exclusive_controller?(controller_name, action_name)
+            puts "exclusive controller"
+            next
+          end
+        rescue
+        end
+
+        duration_ms = ((finished - started) * 1000.0).round(2)
+        # 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
+        cache_events = defined?(DeadBro::CacheSubscriber) ? DeadBro::CacheSubscriber.stop_request_tracking : []
+        redis_events = defined?(DeadBro::RedisSubscriber) ? DeadBro::RedisSubscriber.stop_request_tracking : []
+
+        # Stop view rendering tracking and get collected view events
+        view_events = DeadBro::ViewRenderingSubscriber.stop_request_tracking
+        view_performance = DeadBro::ViewRenderingSubscriber.analyze_view_performance(view_events)
+
+        # Stop memory tracking and get collected memory data
+        if DeadBro.configuration.allocation_tracking_enabled && defined?(DeadBro::MemoryTrackingSubscriber)
+          detailed_memory = DeadBro::MemoryTrackingSubscriber.stop_request_tracking
+          memory_performance = DeadBro::MemoryTrackingSubscriber.analyze_memory_performance(detailed_memory)
+          # Keep memory_events compact and user-friendly (no large raw arrays)
+          memory_events = {
+            memory_before: detailed_memory[:memory_before],
+            memory_after: detailed_memory[:memory_after],
+            duration_seconds: detailed_memory[:duration_seconds],
+            allocations_count: (detailed_memory[:allocations] || []).length,
+            memory_snapshots_count: (detailed_memory[:memory_snapshots] || []).length,
+            large_objects_count: (detailed_memory[:large_objects] || []).length
+          }
+        else
+          lightweight_memory = DeadBro::LightweightMemoryTracker.stop_request_tracking
+          # Separate raw readings from derived performance metrics to avoid duplicating data
+          memory_events = {
+            memory_before: lightweight_memory[:memory_before],
+            memory_after: lightweight_memory[:memory_after]
+          }
+          memory_performance = {
+            memory_growth_mb: lightweight_memory[:memory_growth_mb],
+            gc_count_increase: lightweight_memory[:gc_count_increase],
+            heap_pages_increase: lightweight_memory[:heap_pages_increase],
+            duration_seconds: lightweight_memory[:duration_seconds]
+          }
+        end
+
+        # Record memory sample for leak detection (only if memory tracking enabled)
+        if DeadBro.configuration.memory_tracking_enabled
+          DeadBro::MemoryLeakDetector.record_memory_sample({
+            memory_usage: memory_usage_mb,
+            gc_count: gc_stats[:count],
+            heap_pages: gc_stats[:heap_allocated_pages],
+            object_count: gc_stats[:heap_live_slots],
+            request_id: data[:request_id],
+            controller: data[:controller],
+            action: data[:action]
+          })
+        end
+
+        # Report exceptions attached to this action (e.g. controller/view errors)
+        if data[:exception] || data[:exception_object]
+          begin
+            exception_class, exception_message = data[:exception] if data[:exception]
+            exception_obj = data[:exception_object]
+            backtrace = Array(exception_obj&.backtrace).first(50)
+
+            error_payload = {
+              controller: data[:controller],
+              action: data[:action],
+              format: data[:format],
+              method: data[:method],
+              path: safe_path(data),
+              status: data[:status],
+              duration_ms: duration_ms,
+              rails_env: rails_env,
+              host: safe_host,
+              params: safe_params(data),
+              user_agent: safe_user_agent(data),
+              user_id: extract_user_id(data),
+              exception_class: exception_class || exception_obj&.class&.name,
+              message: (exception_message || exception_obj&.message).to_s[0, 1000],
+              backtrace: backtrace,
+              error: true,
+              logs: DeadBro.logger.logs
+            }
+
+            event_name = (exception_class || exception_obj&.class&.name || "exception").to_s
+            client.post_metric(event_name: event_name, payload: error_payload)
+          rescue
+          ensure
+            next
+          end
+        end
+
+        payload = {
+          controller: data[:controller],
+          action: data[:action],
+          format: data[:format],
+          method: data[:method],
+          path: safe_path(data),
+          status: data[:status],
+          duration_ms: duration_ms,
+          view_runtime_ms: data[:view_runtime],
+          db_runtime_ms: data[:db_runtime],
+          host: safe_host,
+          rails_env: rails_env,
+          params: safe_params(data),
+          user_agent: safe_user_agent(data),
+          user_id: extract_user_id(data),
+          memory_usage: memory_usage_mb,
+          gc_stats: gc_stats,
+          sql_count: sql_count(data),
+          sql_queries: sql_queries,
+          http_outgoing: Thread.current[:dead_bro_http_events] || [],
+          cache_events: cache_events,
+          redis_events: redis_events,
+          cache_hits: cache_hits(data),
+          cache_misses: cache_misses(data),
+          view_events: view_events,
+          view_performance: view_performance,
+          memory_events: memory_events,
+          memory_performance: memory_performance,
+          logs: DeadBro.logger.logs
+        }
+        client.post_metric(event_name: name, payload: payload)
+      end
+    end
+
+    def self.safe_path(data)
+      path = data[:path] || (data[:request] && data[:request].path)
+      path.to_s
+    rescue
+      ""
+    end
+
+    def self.safe_host
+      if defined?(Rails) && Rails.respond_to?(:application)
+        begin
+          Rails.application.class.module_parent_name
+        rescue
+          ""
+        end
+      else
+        ""
+      end
+    end
+
+    def self.rails_env
+      if defined?(Rails) && Rails.respond_to?(:env)
+        Rails.env
+      else
+        ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development"
+      end
+    end
+
+    def self.safe_params(data)
+      return {} unless data[:params]
+
+      params = data[:params]
+      begin
+        params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
+      rescue
+      end
+
+      unless params.is_a?(Hash)
+        return {}
+      end
+
+      # Remove router-provided keys that we already send at top-level
+      router_keys = %w[controller action format]
+
+      # Filter out sensitive parameters
+      sensitive_keys = %w[password password_confirmation token secret key]
+
+      filtered = params.dup
+      router_keys.each { |k| filtered.delete(k) || filtered.delete(k.to_sym) }
+      filtered = filtered.except(*sensitive_keys, *sensitive_keys.map(&:to_sym)) if filtered.respond_to?(:except)
+
+      # Truncate deeply to keep payload small and safe
+      truncate_value(filtered)
+    rescue
+      {}
+    end
+
+    # Recursively truncate values to reasonable sizes to avoid huge payloads
+    def self.truncate_value(value, max_str: 200, max_array: 20, max_hash_keys: 30)
+      case value
+      when String
+        (value.length > max_str) ? value[0, max_str] + "…" : value
+      when Numeric, TrueClass, FalseClass, NilClass
+        value
+      when Array
+        value[0, max_array].map { |v| truncate_value(v, max_str: max_str, max_array: max_array, max_hash_keys: max_hash_keys) }
+      when Hash
+        entries = value.to_a[0, max_hash_keys]
+        entries.each_with_object({}) do |(k, v), memo|
+          memo[k] = truncate_value(v, max_str: max_str, max_array: max_array, max_hash_keys: max_hash_keys)
+        end
+      else
+        (value.to_s.length > max_str) ? value.to_s[0, max_str] + "…" : value.to_s
+      end
+    end
+
+    def self.safe_user_agent(data)
+      begin
+        # Prefer request object if available
+        if data[:request]
+          ua = nil
+          if data[:request].respond_to?(:user_agent)
+            ua = data[:request].user_agent
+          elsif data[:request].respond_to?(:env)
+            ua = data[:request].env && data[:request].env["HTTP_USER_AGENT"]
+          end
+          return ua.to_s[0..200]
+        end
+
+        # Fallback to headers object/hash if present in notification data
+        if data[:headers]
+          headers = data[:headers]
+          if headers.respond_to?(:[])
+            ua = headers["HTTP_USER_AGENT"] || headers["User-Agent"] || headers["user-agent"]
+            return ua.to_s[0..200]
+          elsif headers.respond_to?(:to_h)
+            h = begin
+              headers.to_h
+            rescue
+              {}
+            end
+            ua = h["HTTP_USER_AGENT"] || h["User-Agent"] || h["user-agent"]
+            return ua.to_s[0..200]
+          end
+        end
+
+        # Fallback to env hash if present in notification data
+        if data[:env].is_a?(Hash)
+          ua = data[:env]["HTTP_USER_AGENT"]
+          return ua.to_s[0..200]
+        end
+
+        ""
+      rescue
+        ""
+      end
+    rescue
+      ""
+    end
+
+    def self.memory_usage_mb
+      if defined?(GC) && GC.respond_to?(:stat)
+        # Get memory usage in MB
+        memory_kb = begin
+          `ps -o rss= -p #{Process.pid}`.to_i
+        rescue
+          0
+        end
+        (memory_kb / 1024.0).round(2)
+      else
+        0
+      end
+    rescue
+      0
+    end
+
+    def self.gc_stats
+      if defined?(GC) && GC.respond_to?(:stat)
+        stats = GC.stat
+        {
+          count: stats[:count] || 0,
+          heap_allocated_pages: stats[:heap_allocated_pages] || 0,
+          heap_sorted_pages: stats[:heap_sorted_pages] || 0,
+          total_allocated_objects: stats[:total_allocated_objects] || 0
+        }
+      else
+        {}
+      end
+    rescue
+      {}
+    end
+
+    def self.sql_count(data)
+      # Count SQL queries from the payload if available
+      if data[:sql_count]
+        data[:sql_count]
+      elsif defined?(ActiveRecord) && ActiveRecord::Base.connection
+        # Try to get from ActiveRecord connection
+        begin
+          ActiveRecord::Base.connection.query_cache.size
+        rescue
+          0
+        end
+      else
+        0
+      end
+    rescue
+      0
+    end
+
+    def self.cache_hits(data)
+      if data[:cache_hits]
+        data[:cache_hits]
+      elsif defined?(Rails) && Rails.cache.respond_to?(:stats)
+        begin
+          Rails.cache.stats[:hits]
+        rescue
+          0
+        end
+      else
+        0
+      end
+    rescue
+      0
+    end
+
+    def self.cache_misses(data)
+      if data[:cache_misses]
+        data[:cache_misses]
+      elsif defined?(Rails) && Rails.cache.respond_to?(:stats)
+        begin
+          Rails.cache.stats[:misses]
+        rescue
+          0
+        end
+      else
+        0
+      end
+    rescue
+      0
+    end
+
+    def self.extract_user_id(data)
+      data[:headers].env["warden"].user.id
+    rescue
+      nil
+    end
+  end
+end

data/lib/dead_bro/version.rb

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

data/lib/dead_bro/view_rendering_subscriber.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module DeadBro
+  class ViewRenderingSubscriber
+    # Rails view rendering events
+    RENDER_TEMPLATE_EVENT = "render_template.action_view"
+    RENDER_PARTIAL_EVENT = "render_partial.action_view"
+    RENDER_COLLECTION_EVENT = "render_collection.action_view"
+
+    THREAD_LOCAL_KEY = :dead_bro_view_events
+
+    def self.subscribe!(client: Client.new)
+      # Track template rendering
+      ActiveSupport::Notifications.subscribe(RENDER_TEMPLATE_EVENT) do |name, started, finished, _unique_id, data|
+        duration_ms = ((finished - started) * 1000.0).round(2)
+
+        view_info = {
+          type: "template",
+          identifier: safe_identifier(data[:identifier]),
+          layout: data[:layout],
+          duration_ms: duration_ms,
+          virtual_path: data[:virtual_path],
+          rendered_at: Time.now.utc.to_i
+        }
+
+        add_view_event(view_info)
+      end
+
+      # Track partial rendering
+      ActiveSupport::Notifications.subscribe(RENDER_PARTIAL_EVENT) do |name, started, finished, _unique_id, data|
+        duration_ms = ((finished - started) * 1000.0).round(2)
+
+        view_info = {
+          type: "partial",
+          identifier: safe_identifier(data[:identifier]),
+          layout: data[:layout],
+          duration_ms: duration_ms,
+          virtual_path: data[:virtual_path],
+          cache_key: data[:cache_key],
+          rendered_at: Time.now.utc.to_i
+        }
+
+        add_view_event(view_info)
+      end
+
+      # Track collection rendering (for partials rendered in loops)
+      ActiveSupport::Notifications.subscribe(RENDER_COLLECTION_EVENT) do |name, started, finished, _unique_id, data|
+        duration_ms = ((finished - started) * 1000.0).round(2)
+
+        view_info = {
+          type: "collection",
+          identifier: safe_identifier(data[:identifier]),
+          layout: data[:layout],
+          duration_ms: duration_ms,
+          virtual_path: data[:virtual_path],
+          cache_key: data[:cache_key],
+          count: data[:count],
+          cached_count: data[:cached_count],
+          rendered_at: Time.now.utc.to_i
+        }
+
+        add_view_event(view_info)
+      end
+    rescue
+      # Never raise from instrumentation install
+    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.add_view_event(view_info)
+      if Thread.current[THREAD_LOCAL_KEY]
+        Thread.current[THREAD_LOCAL_KEY] << view_info
+      end
+    end
+
+    def self.safe_identifier(identifier)
+      return "" unless identifier.is_a?(String)
+
+      # Extract meaningful parts of the file path
+      # e.g., "/app/views/users/show.html.erb" -> "users/show.html.erb"
+      identifier.split("/").last(3).join("/")
+    rescue
+      identifier.to_s
+    end
+
+    # Analyze view rendering performance
+    def self.analyze_view_performance(view_events)
+      return {} if view_events.empty?
+
+      total_duration = view_events.sum { |event| event[:duration_ms] }
+
+      # Group by view type
+      by_type = view_events.group_by { |event| event[:type] }
+
+      # Find slowest views
+      slowest_views = view_events.sort_by { |event| -event[:duration_ms] }.first(5)
+
+      # Find most frequently rendered views
+      view_frequency = view_events.group_by { |event| event[:identifier] }
+        .transform_values(&:count)
+        .sort_by { |_, count| -count }
+        .first(5)
+
+      # Calculate cache hit rates for partials
+      partials = view_events.select { |event| event[:type] == "partial" }
+      cache_hits = partials.count { |event| event[:cache_key] }
+      cache_hit_rate = partials.any? ? (cache_hits.to_f / partials.count * 100).round(2) : 0
+
+      # Collection rendering analysis
+      collections = view_events.select { |event| event[:type] == "collection" }
+      total_collection_items = collections.sum { |event| event[:count] || 0 }
+      total_cached_items = collections.sum { |event| event[:cached_count] || 0 }
+      collection_cache_hit_rate = (total_collection_items > 0) ?
+        (total_cached_items.to_f / total_collection_items * 100).round(2) : 0
+
+      {
+        total_views_rendered: view_events.count,
+        total_view_duration_ms: total_duration.round(2),
+        average_view_duration_ms: (total_duration / view_events.count).round(2),
+        by_type: by_type.transform_values(&:count),
+        slowest_views: slowest_views.map { |view|
+          {
+            identifier: view[:identifier],
+            duration_ms: view[:duration_ms],
+            type: view[:type]
+          }
+        },
+        most_frequent_views: view_frequency.map { |identifier, count|
+          {
+            identifier: identifier,
+            count: count
+          }
+        },
+        partial_cache_hit_rate: cache_hit_rate,
+        collection_cache_hit_rate: collection_cache_hit_rate,
+        total_collection_items: total_collection_items,
+        total_cached_collection_items: total_cached_items
+      }
+    end
+  end
+end

data/lib/dead_bro.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "dead_bro/version"
+
+module DeadBro
+  autoload :Configuration, "dead_bro/configuration"
+  autoload :Client, "dead_bro/client"
+  autoload :CircuitBreaker, "dead_bro/circuit_breaker"
+  autoload :Subscriber, "dead_bro/subscriber"
+  autoload :SqlSubscriber, "dead_bro/sql_subscriber"
+  autoload :SqlTrackingMiddleware, "dead_bro/sql_tracking_middleware"
+  autoload :CacheSubscriber, "dead_bro/cache_subscriber"
+  autoload :RedisSubscriber, "dead_bro/redis_subscriber"
+  autoload :ViewRenderingSubscriber, "dead_bro/view_rendering_subscriber"
+  autoload :MemoryTrackingSubscriber, "dead_bro/memory_tracking_subscriber"
+  autoload :MemoryLeakDetector, "dead_bro/memory_leak_detector"
+  autoload :LightweightMemoryTracker, "dead_bro/lightweight_memory_tracker"
+  autoload :MemoryHelpers, "dead_bro/memory_helpers"
+  autoload :JobSubscriber, "dead_bro/job_subscriber"
+  autoload :JobSqlTrackingMiddleware, "dead_bro/job_sql_tracking_middleware"
+  autoload :Logger, "dead_bro/logger"
+  begin
+    require "dead_bro/railtie"
+  rescue LoadError
+  end
+
+  class Error < StandardError; end
+
+  def self.configure
+    yield configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+  
+  def self.reset_configuration!
+    @configuration = nil
+    @client = nil
+  end
+
+  # Returns a shared Client instance for use across the application
+  def self.client
+    @client ||= Client.new
+  end
+
+  # Returns a process-stable deploy identifier used when none is configured.
+  # Memoized per-Ruby process to avoid generating a new UUID per request.
+  def self.process_deploy_id
+    @process_deploy_id ||= begin
+      require "securerandom"
+      SecureRandom.uuid
+    end
+  end
+
+  # Returns the logger instance for storing and retrieving log messages
+  def self.logger
+    @logger ||= Logger.new
+  end
+
+  # Returns the current environment (Rails.env or ENV fallback)
+  def self.env
+    if defined?(Rails) && Rails.respond_to?(:env)
+      Rails.env
+    else
+      ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development"
+    end
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: dead_bro
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Emanuel Comsa
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Gem used by DeadBro - Rails APM to track performance metrics of Rails
+  apps.
+email:
+- office@rubydev.ro
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- FEATURES.md
+- README.md
+- lib/dead_bro.rb
+- lib/dead_bro/cache_subscriber.rb
+- lib/dead_bro/circuit_breaker.rb
+- lib/dead_bro/client.rb
+- lib/dead_bro/configuration.rb
+- lib/dead_bro/error_middleware.rb
+- lib/dead_bro/http_instrumentation.rb
+- lib/dead_bro/job_sql_tracking_middleware.rb
+- lib/dead_bro/job_subscriber.rb
+- lib/dead_bro/lightweight_memory_tracker.rb
+- lib/dead_bro/logger.rb
+- lib/dead_bro/memory_helpers.rb
+- lib/dead_bro/memory_leak_detector.rb
+- lib/dead_bro/memory_tracking_subscriber.rb
+- lib/dead_bro/railtie.rb
+- lib/dead_bro/redis_subscriber.rb
+- lib/dead_bro/sql_subscriber.rb
+- lib/dead_bro/sql_tracking_middleware.rb
+- lib/dead_bro/subscriber.rb
+- lib/dead_bro/version.rb
+- lib/dead_bro/view_rendering_subscriber.rb
+homepage: https://www.deadbro.com
+licenses: []
+metadata:
+  homepage_uri: https://www.deadbro.com
+  source_code_uri: https://github.com/rubydevro/dead_bro
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Minimal APM for Rails apps.
+test_files: []