dontbugme 0.1.0

data/lib/dontbugme/configuration.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  class Configuration
+    attr_accessor :store,
+                  :sqlite_path,
+                  :postgresql_connection,
+                  :enable_web_ui,
+                  :web_ui_mount_path,
+                  :recording_mode,
+                  :record_on_error,
+                  :record_jobs,
+                  :record_requests,
+                  :sample_rate,
+                  :capture_sql_binds,
+                  :capture_http_headers,
+                  :capture_http_body,
+                  :capture_redis_values,
+                  :source_mode,
+                  :source_filter,
+                  :source_depth,
+                  :source_stack_limit,
+                  :max_spans_per_trace,
+                  :span_overflow_strategy,
+                  :max_sql_bind_size,
+                  :max_http_body_size,
+                  :max_redis_value_size,
+                  :max_span_detail_size,
+                  :max_trace_buffer_bytes,
+                  :retention,
+                  :max_traces,
+                  :async_store
+
+    def initialize
+      apply_environment_defaults
+    end
+
+    def apply_environment_defaults
+      env = defined?(Rails) ? Rails.env.to_s : 'development'
+
+      case env
+      when 'test'
+        apply_test_defaults
+      when 'production'
+        apply_production_defaults
+      else
+        apply_development_defaults
+      end
+    end
+
+    def apply_development_defaults
+      self.store = :sqlite
+      self.sqlite_path = 'tmp/inspector/inspector.db'
+      self.postgresql_connection = nil
+      self.enable_web_ui = true
+      self.web_ui_mount_path = '/inspector'
+      self.recording_mode = :always
+      self.record_on_error = true
+      self.record_jobs = :all
+      self.record_requests = :all
+      self.sample_rate = 1.0
+      self.capture_sql_binds = true
+      self.capture_http_headers = []
+      self.capture_http_body = false
+      self.capture_redis_values = false
+      self.source_mode = :full
+      self.source_filter = %w[app/ lib/]
+      self.source_depth = 3
+      self.source_stack_limit = 50
+      self.max_spans_per_trace = 1_000
+      self.span_overflow_strategy = :count
+      self.max_sql_bind_size = 4_096
+      self.max_http_body_size = 8_192
+      self.max_redis_value_size = 512
+      self.max_span_detail_size = 8_192
+      self.max_trace_buffer_bytes = 10 * 1024 * 1024 # 10 MB
+      self.retention = retention_seconds(72, :hours)
+      self.max_traces = 10_000
+      self.async_store = false
+    end
+
+    def apply_test_defaults
+      apply_development_defaults
+      self.store = :memory
+      self.recording_mode = :off
+      self.enable_web_ui = false
+      self.record_on_error = false
+      self.max_trace_buffer_bytes = 5 * 1024 * 1024 # 5 MB
+    end
+
+    def apply_production_defaults
+      apply_development_defaults
+      self.store = :postgresql
+      self.enable_web_ui = false
+      self.recording_mode = :selective
+      self.record_on_error = true
+      self.capture_sql_binds = false
+      self.source_mode = :shallow
+      self.source_depth = 1
+      self.source_stack_limit = 30
+      self.max_spans_per_trace = 500
+      self.max_sql_bind_size = 512
+      self.max_http_body_size = 1_024
+      self.max_span_detail_size = 2_048
+      self.max_trace_buffer_bytes = 5 * 1024 * 1024 # 5 MB
+      self.retention = retention_seconds(24, :hours)
+      self.async_store = true
+    end
+
+    def recording?
+      return false if recording_mode == :off
+      return true if recording_mode == :always
+
+      # :selective — caller (Recorder) decides based on record_jobs, record_requests, etc.
+      true
+    end
+
+    def should_record_job?(job_class)
+      return false if record_jobs == :none
+      return true if record_jobs == :all
+      return record_jobs.include?(job_class.to_s) if record_jobs.is_a?(Array)
+
+      false
+    end
+
+    def should_record_request?(env)
+      return false if record_requests == :none
+      return true if record_requests == :all
+      return record_requests.call(env) if record_requests.respond_to?(:call)
+
+      false
+    end
+
+    private
+
+    def retention_seconds(value, unit)
+      return value if value.is_a?(Integer)
+      return value.to_i if defined?(ActiveSupport) && value.respond_to?(:to_i)
+
+      case unit
+      when :hours then value * 3600
+      when :days then value * 86400
+      else value
+      end
+    end
+  end
+end

data/lib/dontbugme/context.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  class Context
+    KEY = :dontbugme_trace
+
+    class << self
+      def current
+        Thread.current[KEY]
+      end
+
+      def current=(trace)
+        Thread.current[KEY] = trace
+      end
+
+      def active?
+        !current.nil?
+      end
+
+      def clear!
+        Thread.current[KEY] = nil
+      end
+    end
+  end
+end

data/lib/dontbugme/correlation.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Correlation
+    KEY = :dontbugme_correlation_id
+
+    class << self
+      def current
+        Thread.current[KEY]
+      end
+
+      def current=(id)
+        Thread.current[KEY] = id
+      end
+
+      def generate
+        "corr_#{SecureRandom.hex(8)}"
+      end
+
+      def clear!
+        Thread.current[KEY] = nil
+      end
+    end
+  end
+end

data/lib/dontbugme/engine.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  class Engine < ::Rails::Engine
+    isolate_namespace Dontbugme
+
+    # Mount in config/routes.rb:
+    #   mount Dontbugme::Engine, at: '/inspector'
+    # Enable/disable via config.enable_web_ui (default: true in dev, false in prod)
+  end
+end

data/lib/dontbugme/formatters/diff.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module Dontbugme
+  module Formatters
+    class Diff
+      def self.format(trace_a, trace_b)
+        new(trace_a, trace_b).format
+      end
+
+      def initialize(trace_a, trace_b)
+        @trace_a = trace_a
+        @trace_b = trace_b
+        @alignment = align_spans
+      end
+
+      def format
+        lines = []
+        lines << ''
+        lines << "  #{@trace_a.identifier} — Execution Diff"
+        lines << '  ' + ('─' * 60)
+        lines << ''
+        lines << "  Trace A: #{@trace_a.id} (#{@trace_a.status}, #{duration_str(@trace_a)})"
+        lines << "  Trace B: #{@trace_b.id} (#{@trace_b.status}, #{duration_str(@trace_b)})"
+        lines << ''
+
+        @alignment.each do |result|
+          lines << format_result(result)
+        end
+
+        lines << ''
+        lines.join("\n")
+      end
+
+      private
+
+      def align_spans
+        spans_a = spans_with_error(@trace_a)
+        spans_b = spans_with_error(@trace_b)
+        results = []
+        i = j = 0
+
+        while i < spans_a.size || j < spans_b.size
+          span_a = spans_a[i]
+          span_b = spans_b[j]
+
+          if span_a.nil?
+            results << { type: :new, span_a: nil, span_b: span_b }
+            j += 1
+          elsif span_b.nil?
+            results << { type: :missing, span_a: span_a, span_b: nil }
+            i += 1
+          else
+            key_a = span_key(span_a)
+            key_b = span_key(span_b)
+
+            if key_a == key_b
+              if span_equal?(span_a, span_b)
+                results << { type: :identical, span_a: span_a, span_b: span_b }
+              else
+                results << { type: :changed, span_a: span_a, span_b: span_b }
+              end
+              i += 1
+              j += 1
+            elsif key_a < key_b
+              results << { type: :missing, span_a: span_a, span_b: nil }
+              i += 1
+            else
+              results << { type: :new, span_a: nil, span_b: span_b }
+              j += 1
+            end
+          end
+        end
+
+        results
+      end
+
+      def spans_with_error(trace)
+        spans = trace.raw_spans.dup
+        if trace.error
+          error_span = OpenStruct.new(
+            category: :custom,
+            operation: 'EXCEPTION',
+            detail: "#{trace.error[:class]}: #{trace.error[:message]}",
+            payload: trace.error
+          )
+          spans << error_span
+        end
+        spans
+      end
+
+      def span_key(span)
+        detail = normalize_detail(span.detail)
+        "#{span.category}:#{span.operation}:#{detail}"
+      end
+
+      def normalize_detail(detail)
+        return '' if detail.nil?
+        # Normalize SQL: collapse whitespace, remove exact values for comparison
+        detail = detail.to_s.strip.gsub(/\s+/, ' ')
+        # Truncate for alignment (compare structure, not values)
+        detail[0, 80]
+      end
+
+      def span_equal?(span_a, span_b)
+        return false unless span_a.category == span_b.category
+        return false unless span_a.operation == span_b.operation
+
+        case span_a.category
+        when :http
+          (span_a.payload[:status] || span_a.payload['status']) == (span_b.payload[:status] || span_b.payload['status'])
+        when :sql
+          normalize_detail(span_a.detail) == normalize_detail(span_b.detail)
+        else
+          normalize_detail(span_a.detail) == normalize_detail(span_b.detail)
+        end
+      end
+
+      def format_result(result)
+        case result[:type]
+        when :identical
+          "  IDENTICAL  #{format_span_short(result[:span_a])}"
+        when :changed
+          lines = ["  CHANGED    #{format_span_short(result[:span_a])}"]
+          lines << "               A: #{format_span_detail(result[:span_a])}"
+          lines << "               B: #{format_span_detail(result[:span_b])} ←"
+          lines.join("\n")
+        when :missing
+          "  MISSING    #{format_span_short(result[:span_a])}    ← never reached in B"
+        when :new
+          span_b = result[:span_b]
+          if span_b.operation == 'EXCEPTION'
+            err = span_b.payload
+            detail = err ? "#{err[:class]}: #{truncate(err[:message].to_s, 40)}" : 'EXCEPTION'
+            "  NEW        EXCEPTION #{detail}    ← only in B"
+          else
+            "  NEW        #{format_span_short(span_b)}    ← only in B"
+          end
+        else
+          ''
+        end
+      end
+
+      def format_span_short(span)
+        return '' unless span
+
+        detail = truncate(span.detail, 50)
+        "#{span.category.to_s.upcase} #{span.operation} #{detail}"
+      end
+
+      def format_span_detail(span)
+        case span.category
+        when :http
+          status = span.payload[:status] || span.payload['status']
+          duration = span.duration_ms ? "#{span.duration_ms.round}ms" : ''
+          "#{status} #{status_label(status)} (#{duration})".strip
+        when :sql
+          truncate(span.detail, 60)
+        else
+          truncate(span.detail, 60)
+        end
+      end
+
+      def status_label(code)
+        return '' unless code
+        return 'OK' if code.to_i.between?(200, 299)
+        return 'Timeout' if code.to_i == 408 || code.to_i == 504
+        return 'Error' if code.to_i >= 400
+
+        ''
+      end
+
+      def duration_str(trace)
+        ms = trace.duration_ms
+        ms ? "#{ms.round}ms" : 'N/A'
+      end
+
+      def truncate(str, max)
+        return '' if str.nil? || str.empty?
+        return str if str.length <= max
+
+        "#{str[0, max - 3]}..."
+      end
+    end
+  end
+end

data/lib/dontbugme/formatters/json.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Formatters
+    class Json
+      def self.format(trace)
+        trace.to_h.to_json
+      end
+    end
+  end
+end

data/lib/dontbugme/formatters/timeline.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Formatters
+    class Timeline
+      def self.format(trace, only: nil, slow: nil)
+        new(trace, only: only, slow: slow).format
+      end
+
+      def initialize(trace, only: nil, slow: nil)
+        @trace = trace
+        @only = only&.to_sym
+        @slow = slow
+      end
+
+      def format
+        lines = []
+        lines << ''
+        lines << "  #{@trace.identifier}"
+        lines << "  Status: #{@trace.status} | Duration: #{duration_str} | Recorded: #{time_ago}"
+        lines << ''
+        lines << '  TIMELINE'
+        lines << '  ' + ('─' * 60)
+        lines << ''
+        lines << format_start_span
+        lines << ''
+
+        spans_to_show.each do |span|
+          lines << format_span(span)
+        end
+
+        lines << ''
+        lines << format_finish_span
+
+        if @trace.truncated_spans_count.to_i.positive?
+          lines << ''
+          lines << "  ... #{@trace.truncated_spans_count} additional spans truncated"
+        end
+
+        lines << ''
+        lines.join("\n")
+      end
+
+      private
+
+      def format_start_span
+        label = case @trace.kind
+                when :sidekiq then 'Job started'
+                when :request then 'Request started'
+                else 'Started'
+                end
+        "  0.0ms   ▸ #{label}"
+      end
+
+      def format_finish_span
+        label = case @trace.kind
+                when :sidekiq then 'Job finished'
+                when :request then 'Request finished'
+                else 'Finished'
+                end
+        duration = @trace.duration_ms ? "#{@trace.duration_ms.round(1)}ms" : '0ms'
+        "  #{duration}   ▸ #{label}"
+      end
+
+      def spans_to_show
+        spans = @trace.raw_spans
+        spans = spans.select { |s| s.category == @only } if @only
+        spans = spans.select { |s| s.duration_ms.to_f >= @slow } if @slow
+        spans
+      end
+
+      def format_span(span)
+        offset = span.started_at.to_f.round(1)
+        duration = span.duration_ms ? "(#{span.duration_ms.round(1)}ms)" : ''
+        detail = format_span_detail(span)
+        line = "  #{offset}ms   ▸ #{span.category.to_s.upcase} #{span.operation} #{detail} #{duration}".strip
+        lines = [line]
+        lines << "            → #{span.source}" if span.source && !span.source.empty?
+        lines.join("\n")
+      end
+
+      def format_span_detail(span)
+        case span.category
+        when :http
+          status = span.payload[:status] || span.payload['status']
+          status_str = status ? " → #{status}" : ''
+          truncate_detail(span.detail + status_str, 55)
+        else
+          truncate_detail(span.detail, 50)
+        end
+      end
+
+      def truncate_detail(str, max_len)
+        return '' if str.nil? || str.empty?
+
+        str = str.strip
+        return str if str.length <= max_len
+
+        "#{str[0, max_len - 3]}..."
+      end
+
+      def duration_str
+        ms = @trace.duration_ms
+        ms ? "#{ms.round}ms" : 'N/A'
+      end
+
+      def time_ago
+        return 'N/A' unless @trace.started_at_utc
+
+        sec = Time.now - @trace.started_at_utc
+        if sec < 60 then "#{sec.round} sec ago"
+        elsif sec < 3600 then "#{(sec / 60).round} min ago"
+        elsif sec < 86400 then "#{(sec / 3600).round} hours ago"
+        else "#{(sec / 86400).round} days ago"
+        end
+      end
+    end
+  end
+end

data/lib/dontbugme/middleware/rack.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Middleware
+    class Rack
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) unless Dontbugme.config.recording?
+
+        request = ::Rack::Request.new(env)
+        request_id = env['action_dispatch.request_id'] || request.get_header('HTTP_X_REQUEST_ID') || SecureRandom.uuid
+        correlation_id = env['HTTP_X_CORRELATION_ID'] || Correlation.generate
+        Correlation.current = correlation_id
+
+        method = request.request_method
+        path = request.path
+        identifier = "#{method} #{path}"
+
+        metadata = {
+          request_id: request_id,
+          correlation_id: correlation_id,
+          method: method,
+          path: path
+        }
+
+        Recorder.record(kind: :request, identifier: identifier, metadata: metadata) do
+          @app.call(env)
+        end
+      ensure
+        Correlation.clear!
+      end
+    end
+  end
+end

data/lib/dontbugme/middleware/sidekiq.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Middleware
+    class Sidekiq
+      def call(_worker, job, _queue)
+        return yield unless Dontbugme.config.recording?
+
+        job_class = job['class'] || job[:class] || 'Unknown'
+        jid = job['jid'] || job[:jid] || SecureRandom.hex(8)
+        correlation_id = job['correlation_id'] || job[:correlation_id] || Correlation.current
+        Correlation.current = correlation_id
+
+        identifier = "#{job_class} (jid=#{jid})"
+
+        metadata = {
+          jid: jid,
+          queue: job['queue'] || job[:queue],
+          args: job['args'] || job[:args],
+          correlation_id: correlation_id
+        }
+
+        Recorder.record(kind: :sidekiq, identifier: identifier, metadata: metadata) do
+          yield
+        end
+      ensure
+        Correlation.clear!
+      end
+    end
+  end
+end

data/lib/dontbugme/middleware/sidekiq_client.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Middleware
+    class SidekiqClient
+      def call(_worker_class, job, _queue, _redis_pool)
+        if Correlation.current
+          job['correlation_id'] = Correlation.current
+        end
+        yield
+      end
+    end
+  end
+end

data/lib/dontbugme/railtie.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'dontbugme'
+require 'dontbugme/engine'
+
+module Dontbugme
+  class Railtie < ::Rails::Railtie
+    config.dontbugme = ActiveSupport::OrderedOptions.new
+
+    initializer 'dontbugme.configure' do |app|
+      # Configuration defaults are applied in Configuration#initialize
+      # Merge any app-level config (e.g. config.dontbugme.store = :sqlite)
+      config = Dontbugme.config
+      app.config.dontbugme.each { |k, v| config.send("#{k}=", v) }
+    end
+
+    initializer 'dontbugme.subscribers' do
+      Dontbugme::Subscribers::ActiveRecord.subscribe
+      Dontbugme::Subscribers::NetHttp.subscribe
+      Dontbugme::Subscribers::Redis.subscribe
+      Dontbugme::Subscribers::Cache.subscribe
+      Dontbugme::Subscribers::ActionMailer.subscribe
+      Dontbugme::Subscribers::ActiveJob.subscribe
+    end
+
+    config.after_initialize do
+      # Sidekiq middleware
+      if defined?(Sidekiq)
+        Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add Dontbugme::Middleware::Sidekiq
+          end
+        end
+        Sidekiq.configure_client do |config|
+          config.client_middleware do |chain|
+            chain.add Dontbugme::Middleware::SidekiqClient
+          end
+        end
+      end
+
+      # Rack middleware
+      if defined?(Rails::Application)
+        Rails.application.config.middleware.insert 0, Dontbugme::Middleware::Rack
+      end
+    end
+  end
+end