dontbugme 0.1.0

data/lib/dontbugme/subscribers/action_mailer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Subscribers
+    class ActionMailer
+      EVENT = 'deliver.action_mailer'
+
+      def self.subscribe
+        return unless defined?(::ActionMailer::Base)
+
+        ::ActiveSupport::Notifications.subscribe(EVENT) do |*args|
+          call(*args)
+        end
+      end
+
+      def call(_name, start, finish, _id, payload)
+        return unless Context.active?
+        return unless Dontbugme.config.recording?
+
+        duration_ms = ((finish - start) * 1000).round(2)
+        mailer = payload[:mailer] || payload['mailer']
+        action = payload[:action] || payload['action']
+        message_id = payload[:message_id] || payload['message_id']
+
+        detail = "#{mailer}##{action}"
+        payload_data = {
+          mailer: mailer,
+          action: action,
+          message_id: message_id
+        }
+        payload_data[:to] = payload[:to] if payload[:to]
+        payload_data[:subject] = truncate(payload[:subject].to_s, 100) if payload[:subject]
+
+        Recorder.add_span(
+          category: :mailer,
+          operation: 'deliver',
+          detail: detail,
+          payload: payload_data,
+          duration_ms: duration_ms,
+          started_at: start
+        )
+      end
+
+      private
+
+      def truncate(str, max)
+        return str if str.length <= max
+
+        "#{str[0, max]}..."
+      end
+    end
+  end
+end

data/lib/dontbugme/subscribers/active_job.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Subscribers
+    class ActiveJob
+      EVENT = 'enqueue.active_job'
+
+      def self.subscribe
+        return unless defined?(::ActiveJob::Base)
+
+        ::ActiveSupport::Notifications.subscribe(EVENT) do |*args|
+          call(*args)
+        end
+      end
+
+      def call(_name, start, finish, _id, payload)
+        return unless Context.active?
+        return unless Dontbugme.config.recording?
+
+        duration_ms = ((finish - start) * 1000).round(2)
+        job_class = payload[:job]&.class&.name || payload[:job_class] || payload['job_class']
+        queue = payload[:queue] || payload['queue']
+        args = payload[:args] || payload['args'] || []
+
+        detail = "ENQUEUE #{job_class}"
+        payload_data = {
+          job: job_class,
+          queue: queue,
+          args: args.is_a?(Array) ? args.first(5) : args
+        }
+        payload_data[:scheduled_at] = payload[:scheduled_at] if payload[:scheduled_at]
+
+        Recorder.add_span(
+          category: :enqueue,
+          operation: 'ENQUEUE',
+          detail: detail,
+          payload: payload_data,
+          duration_ms: duration_ms,
+          started_at: start
+        )
+      end
+    end
+  end
+end

data/lib/dontbugme/subscribers/active_record.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Subscribers
+    class ActiveRecord < Base
+      EVENT = 'sql.active_record'
+
+      def self.subscribe
+        return unless defined?(::ActiveRecord::Base)
+
+        ::ActiveSupport::Notifications.subscribe(EVENT) do |*args|
+          call(*args)
+        end
+      end
+
+      def call(_name, start, finish, _id, payload)
+        return unless Context.active?
+
+        config = Dontbugme.config
+        return unless config.recording?
+
+        duration_ms = ((finish - start) * 1000).round(2)
+        sql = payload[:sql] || payload['sql'] || ''
+        binds = config.capture_sql_binds ? process_binds(payload) : []
+
+        operation = extract_operation(sql)
+        payload_data = {
+          name: payload[:name] || payload['name'],
+          connection_id: payload[:connection_id] || payload['connection_id']
+        }
+        payload_data[:binds] = binds if binds.any?
+
+        Recorder.add_span(
+          category: :sql,
+          operation: operation,
+          detail: sql,
+          payload: payload_data,
+          duration_ms: duration_ms,
+          started_at: start
+        )
+      end
+
+      private
+
+      def extract_operation(sql)
+        return 'UNKNOWN' if sql.nil? || sql.empty?
+
+        sql = sql.strip.upcase
+        if sql.start_with?('SELECT') then 'SELECT'
+        elsif sql.start_with?('INSERT') then 'INSERT'
+        elsif sql.start_with?('UPDATE') then 'UPDATE'
+        elsif sql.start_with?('DELETE') then 'DELETE'
+        elsif sql.start_with?('BEGIN') then 'BEGIN'
+        elsif sql.start_with?('COMMIT') then 'COMMIT'
+        elsif sql.start_with?('ROLLBACK') then 'ROLLBACK'
+        elsif sql.start_with?('SAVEPOINT') then 'SAVEPOINT'
+        elsif sql.start_with?('RELEASE') then 'RELEASE'
+        else 'OTHER'
+        end
+      end
+
+      def process_binds(payload)
+        binds = payload[:binds] || payload['binds'] || []
+        type_casted = payload[:type_casted_binds] || payload['type_casted_binds'] || binds
+        max_size = Dontbugme.config.max_sql_bind_size
+
+        Array(type_casted).map do |val|
+          truncate_value(val, max_size)
+        end
+      end
+
+      def truncate_value(val, max_size)
+        str = val.to_s
+        return str if str.bytesize <= max_size
+
+        truncated = str.byteslice(0, max_size)
+        "#{truncated}[truncated, #{str.bytesize}B]"
+      end
+    end
+  end
+end

data/lib/dontbugme/subscribers/base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Subscribers
+    class Base
+      def self.subscribe
+        raise NotImplementedError
+      end
+
+      def self.call(*args)
+        new.call(*args)
+      end
+
+      def call(_name, _start, _finish, _id, _payload)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/dontbugme/subscribers/cache.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Subscribers
+    class Cache
+      EVENTS = %w[
+        cache_read.active_support
+        cache_write.active_support
+        cache_delete.active_support
+        cache_exist?.active_support
+      ].freeze
+
+      def self.subscribe
+        return unless defined?(ActiveSupport::Cache::Store)
+
+        EVENTS.each do |event|
+          ::ActiveSupport::Notifications.subscribe(event) do |*args|
+            new.call(*args)
+          end
+        end
+      end
+
+      def call(name, start, finish, _id, payload)
+        return unless Context.active?
+        return unless Dontbugme.config.recording?
+
+        duration_ms = ((finish - start) * 1000).round(2)
+        operation = payload[:operation] || payload['operation'] || extract_operation(name)
+        key = payload[:key] || payload['key']
+        hit = payload[:hit] if payload.key?(:hit) || payload.key?('hit')
+
+        detail = "cache #{operation} #{key}"
+        payload_data = { key: key }
+        payload_data[:hit] = hit unless hit.nil?
+        payload_data[:super_operation] = payload[:super_operation] if payload[:super_operation]
+
+        Recorder.add_span(
+          category: :cache,
+          operation: operation.to_s.upcase,
+          detail: detail,
+          payload: payload_data,
+          duration_ms: duration_ms,
+          started_at: start
+        )
+      end
+
+      private
+
+      def extract_operation(event_name)
+        event_name.to_s.split('.').first
+      end
+    end
+  end
+end

data/lib/dontbugme/subscribers/net_http.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Subscribers
+    class NetHttp
+      def self.subscribe
+        return unless defined?(Net::HTTP)
+
+        Net::HTTP.prepend(Instrumentation)
+      end
+
+      module Instrumentation
+        def request(req, body = nil, &block)
+          return super unless Dontbugme::Context.active?
+          return super unless Dontbugme.config.recording?
+
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+          start_wall = Time.now
+          response = super
+          duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start_time).round(2)
+
+          record_span(req, response, start_wall, duration_ms)
+          response
+        rescue StandardError => e
+          duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start_time).round(2)
+          record_span(req, nil, start_wall, duration_ms, error: e)
+          raise
+        end
+
+        private
+
+        def record_span(req, response, start_wall, duration_ms, error: nil)
+          config = Dontbugme.config
+          uri = build_uri(req)
+          method = req.method
+          detail = "#{method} #{uri}"
+          payload = {
+            method: method,
+            url: uri,
+            status: response&.code&.to_i
+          }
+          payload[:error] = error.message if error
+
+          if config.capture_http_headers&.any?
+            payload[:request_headers] = capture_headers(req, config.capture_http_headers)
+          end
+
+          Dontbugme::Recorder.add_span(
+            category: :http,
+            operation: method,
+            detail: detail,
+            payload: payload,
+            duration_ms: duration_ms,
+            started_at: start_wall
+          )
+        end
+
+        def build_uri(req)
+          path = req.path.to_s.empty? ? '/' : req.path
+          "#{use_ssl? ? 'https' : 'http'}://#{address}:#{port}#{path}"
+        end
+
+        def capture_headers(req, header_names)
+          result = {}
+          max = Dontbugme.config.max_http_body_size
+          header_map = {
+            'content_type' => 'Content-Type',
+            'authorization_type' => 'Authorization',
+            'authorization' => 'Authorization'
+          }
+          header_names.each do |name|
+            key = header_map[name.to_s.downcase] || name.to_s.split('_').map(&:capitalize).join('-')
+            val = req[key]
+            result[name.to_s] = truncate(val.to_s, max) if val
+          end
+          result
+        end
+
+        def truncate(str, max)
+          return str if str.bytesize <= max
+
+          "#{str.byteslice(0, max)}[truncated]"
+        end
+      end
+    end
+  end
+end

data/lib/dontbugme/subscribers/redis.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Subscribers
+    class Redis
+      def self.subscribe
+        return unless defined?(::Redis)
+        return unless defined?(::Redis::Client)
+
+        ::Redis::Client.prepend(Instrumentation)
+      end
+
+      module Instrumentation
+        def call(command, &block)
+          return super unless Dontbugme::Context.active?
+          return super unless Dontbugme.config.recording?
+
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+          start_wall = Time.now
+          result = super
+          duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start_time).round(2)
+
+          record_span(command, start_wall, duration_ms)
+          result
+        rescue StandardError => e
+          duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start_time).round(2)
+          record_span(command, start_wall, duration_ms, error: e)
+          raise
+        end
+
+        private
+
+        def record_span(command, start_wall, duration_ms, error: nil)
+          cmd = Array(command).map(&:to_s)
+          operation = cmd.first&.upcase || 'UNKNOWN'
+          detail = cmd.join(' ')
+          config = Dontbugme.config
+
+          payload = { command: operation }
+          if config.capture_redis_values && cmd.size > 1
+            payload[:args] = cmd[1..].map { |a| truncate(a, config.max_redis_value_size) }
+          end
+          payload[:error] = error.message if error
+
+          Dontbugme::Recorder.add_span(
+            category: :redis,
+            operation: operation,
+            detail: detail,
+            payload: payload,
+            duration_ms: duration_ms,
+            started_at: start_wall
+          )
+        end
+
+        def truncate(str, max)
+          return str if str.to_s.bytesize <= max
+
+          "#{str.to_s.byteslice(0, max)}[truncated]"
+        end
+      end
+    end
+  end
+end

data/lib/dontbugme/trace.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Dontbugme
+  class Trace
+    attr_reader :id, :kind, :identifier, :metadata, :correlation_id
+    attr_accessor :status, :error, :truncated_spans_count
+
+    def initialize(kind:, identifier:, metadata: {})
+      @id = "tr_#{SecureRandom.hex(6)}"
+      @kind = kind.to_sym
+      @identifier = identifier.to_s
+      @metadata = metadata
+      @correlation_id = metadata[:correlation_id] || metadata['correlation_id']
+      @spans = []
+      @started_at_utc = Time.now.utc
+      @started_at_monotonic = now_monotonic_ms
+      @finished_at = nil
+      @status = :success
+      @error = nil
+      @truncated_spans_count = 0
+    end
+
+    def merge_tags!(**tags)
+      @metadata.merge!(tags.transform_keys(&:to_sym))
+    end
+
+    def add_span(span)
+      config = Dontbugme.config
+      max_spans = config.max_spans_per_trace
+
+      if @spans.size >= max_spans
+        @truncated_spans_count += 1
+        return
+      end
+
+      @spans << span
+    end
+
+    def spans
+      @span_collection ||= SpanCollection.new(@spans)
+    end
+
+    def raw_spans
+      @spans.freeze
+    end
+
+    def finish!(error: nil)
+      @finished_at = now_monotonic_ms
+      @status = error ? :error : :success
+      @error = error ? format_error(error) : nil
+    end
+
+    def started_at_utc
+      @started_at_utc
+    end
+
+    # Monotonic start time, used for computing span offsets during recording
+    def started_at_monotonic
+      @started_at_monotonic
+    end
+
+    # Wall-clock start time for computing span offsets from ActiveSupport::Notifications
+    def started_at_time
+      @started_at_utc
+    end
+
+    def duration_ms
+      return @duration_ms_stored if defined?(@duration_ms_stored) && @duration_ms_stored
+      return nil unless @finished_at
+
+      (@finished_at - @started_at_monotonic).round(2)
+    end
+
+    def to_h
+      {
+        id: id,
+        kind: kind,
+        identifier: identifier,
+        started_at: format_time(started_at_utc),
+        finished_at: @finished_at ? format_time(Time.at(@finished_at / 1000.0).utc) : nil,
+        duration_ms: duration_ms,
+        status: status,
+        error: error,
+        metadata: metadata,
+        correlation_id: correlation_id,
+        spans: raw_spans.map(&:to_h),
+        truncated_spans_count: truncated_spans_count
+      }
+    end
+
+    def self.from_h(hash)
+      trace = allocate
+      trace.instance_variable_set(:@id, hash[:id] || hash['id'])
+      trace.instance_variable_set(:@kind, (hash[:kind] || hash['kind']).to_sym)
+      trace.instance_variable_set(:@identifier, hash[:identifier] || hash['identifier'])
+      trace.instance_variable_set(:@metadata, (hash[:metadata] || hash['metadata'] || {}).transform_keys(&:to_sym))
+      trace.instance_variable_set(:@correlation_id, hash[:correlation_id] || hash['correlation_id'])
+      trace.instance_variable_set(:@status, (hash[:status] || hash['status'] || :success).to_sym)
+      trace.instance_variable_set(:@error, hash[:error] || hash['error'])
+      trace.instance_variable_set(:@truncated_spans_count, hash[:truncated_spans_count] || hash['truncated_spans_count'] || 0)
+
+      spans_data = hash[:spans] || hash['spans'] || []
+      trace.instance_variable_set(:@spans, spans_data.map { |s| Span.from_h(s) })
+
+      started = hash[:started_at] || hash['started_at']
+      trace.instance_variable_set(:@started_at_utc, started ? Time.parse(started.to_s) : nil)
+      trace.instance_variable_set(:@started_at_monotonic, 0)
+      trace.instance_variable_set(:@finished_at, nil)
+      trace.instance_variable_set(:@duration_ms_stored, hash[:duration_ms] || hash['duration_ms'])
+      trace
+    end
+
+    # Convenience for trace.spans by category
+    def spans_by_category(cat)
+      spans.select { |s| s.category == cat.to_sym }
+    end
+
+    def to_timeline(only: nil, slow: nil)
+      Formatters::Timeline.format(self, only: only, slow: slow)
+    end
+
+    private
+
+    def now_monotonic_ms
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+    end
+
+    def format_time(t)
+      t.respond_to?(:iso8601) ? t.iso8601(3) : t.utc.strftime('%Y-%m-%dT%H:%M:%S.%LZ')
+    end
+
+    def format_error(err)
+      {
+        class: err.class.name,
+        message: err.message,
+        backtrace: err.backtrace&.first(20)
+      }
+    end
+  end
+end

data/lib/dontbugme/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  VERSION = '0.1.0'
+end

data/lib/dontbugme.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Dontbugme
+  class Error < StandardError; end
+
+  class << self
+    attr_writer :config, :store
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield config
+    end
+
+    def store
+      @store ||= build_store
+    end
+
+    def trace(identifier, metadata: {}, &block)
+      Recorder.record(kind: :custom, identifier: identifier, metadata: metadata, &block)
+    end
+
+    def span(name, payload: {}, &block)
+      return yield unless Context.active?
+
+      start_mono = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+      start_wall = Time.now
+      result = yield
+      duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start_mono).round(2)
+
+      Recorder.add_span(
+        category: :custom,
+        operation: 'span',
+        detail: name.to_s,
+        payload: payload,
+        duration_ms: duration_ms,
+        started_at: start_wall
+      )
+      result
+    end
+
+    def snapshot(data)
+      return unless Context.active?
+
+      payload = data.is_a?(Hash) ? data : { value: data }
+      Recorder.add_span(
+        category: :snapshot,
+        operation: 'snapshot',
+        detail: 'snapshot',
+        payload: payload,
+        duration_ms: 0,
+        started_at: Time.now
+      )
+    end
+
+    def tag(**metadata)
+      return unless Context.active?
+
+      Context.current&.merge_tags!(**metadata)
+    end
+
+    private
+
+    def build_store
+      store = case config.store
+              when :sqlite
+                Store::Sqlite.new(path: config.sqlite_path)
+              when :memory
+                Store::Memory.new
+              when :postgresql
+                conn = config.postgresql_connection || (defined?(ActiveRecord::Base) && ActiveRecord::Base.connection)
+                conn ? Store::Postgresql.new(connection: conn) : Store::Sqlite.new(path: config.sqlite_path)
+              else
+                Store::Sqlite.new(path: config.sqlite_path)
+              end
+      config.async_store ? Store::Async.new(store) : store
+    end
+  end
+end
+
+require 'dontbugme/version'
+require 'dontbugme/configuration'
+require 'dontbugme/span'
+require 'dontbugme/span_collection'
+require 'dontbugme/trace'
+require 'dontbugme/context'
+require 'dontbugme/source_location'
+require 'dontbugme/recorder'
+require 'dontbugme/subscribers/base'
+require 'dontbugme/subscribers/active_record'
+require 'dontbugme/subscribers/net_http'
+require 'dontbugme/subscribers/redis'
+require 'dontbugme/subscribers/cache'
+require 'dontbugme/subscribers/action_mailer'
+require 'dontbugme/subscribers/active_job'
+require 'dontbugme/store/base'
+require 'dontbugme/store/memory'
+require 'dontbugme/store/sqlite'
+require 'dontbugme/store/postgresql'
+require 'dontbugme/store/async'
+require 'dontbugme/cleanup_job'
+require 'dontbugme/correlation'
+require 'dontbugme/middleware/sidekiq'
+require 'dontbugme/middleware/sidekiq_client'
+require 'dontbugme/middleware/rack'
+require 'dontbugme/formatters/timeline'
+require 'dontbugme/formatters/json'
+require 'dontbugme/formatters/diff'
+require 'dontbugme/cli'
+
+# Load Railtie when Rails is present (must be after all other requires)
+if defined?(Rails)
+  require 'dontbugme/railtie'
+end

data/lib/generators/dontbugme/install/install_generator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      def add_route
+        route "mount Dontbugme::Engine, at: '/inspector' if Dontbugme.config.enable_web_ui"
+      end
+
+      def create_initializer
+        template 'dontbugme.rb', 'config/initializers/dontbugme.rb'
+      end
+    end
+  end
+end