dontbugme 0.1.0

data/lib/dontbugme/recorder.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  class Recorder
+    class << self
+      def record(kind:, identifier:, metadata: {}, &block)
+        return yield unless Dontbugme.config.recording?
+        return yield unless should_sample?
+
+        metadata = metadata.dup
+        metadata[:correlation_id] ||= Correlation.current || Correlation.generate
+        Correlation.current = metadata[:correlation_id]
+
+        trace = Trace.new(kind: kind, identifier: identifier, metadata: metadata)
+        Context.current = trace
+
+        yield
+        trace.finish!
+        persist(trace)
+        trace
+      rescue StandardError => e
+        trace&.finish!(error: e)
+        persist(trace) if trace && Dontbugme.config.record_on_error
+        raise
+      ensure
+        Context.clear!
+        Correlation.clear! unless kind == :request
+      end
+
+      def add_span(category:, operation:, detail:, payload: {}, duration_ms: 0, started_at: nil)
+        trace = Context.current
+        return unless trace
+
+        # started_at can be a Time (from ActiveSupport::Notifications) or we compute from monotonic
+        started_offset = if started_at
+          ((started_at - trace.started_at_time) * 1000).round(2)
+        else
+          (Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - trace.started_at_monotonic - duration_ms).round(2)
+        end
+        source = SourceLocation.capture
+
+        span = Span.new(
+          category: category,
+          operation: operation,
+          detail: detail,
+          payload: payload,
+          started_at: started_offset,
+          duration_ms: duration_ms,
+          source: source
+        )
+
+        trace.add_span(span)
+      end
+
+      private
+
+      def should_sample?
+        rate = Dontbugme.config.sample_rate.to_f
+        return true if rate >= 1.0
+
+        Random.rand < rate
+      end
+
+      def persist(trace)
+        store = Dontbugme.store
+        store&.save_trace(trace)
+      end
+    end
+  end
+end

data/lib/dontbugme/source_location.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  class SourceLocation
+    class << self
+      def capture
+        return nil unless Dontbugme.config.recording?
+        return nil if Dontbugme.config.source_mode == :off
+
+        config = Dontbugme.config
+        limit = config.source_stack_limit
+        depth = config.source_mode == :shallow ? 1 : config.source_depth
+        filters = config.source_filter
+
+        locations = caller_locations(1, limit)
+        return nil if locations.nil? || locations.empty?
+
+        exclude_patterns = %w[dontbugme /gems/ bundler]
+        app_frames = locations.select do |loc|
+          path = loc.absolute_path || loc.path.to_s
+          next false if exclude_patterns.any? { |p| path.include?(p) }
+          filters.any? { |f| path.include?(f) }
+        end
+
+        return nil if app_frames.empty?
+
+        frames_to_keep = app_frames.first(depth)
+        frames_to_keep.map { |loc| format_location(loc) }.join(' <- ')
+      end
+
+      private
+
+      def format_location(loc)
+        path = loc.absolute_path || loc.path.to_s
+        # Use relative path from cwd if possible for shorter output
+        base = path
+        if defined?(Rails) && Rails.root
+          base = Pathname.new(path).relative_path_from(Rails.root).to_s rescue path
+        end
+        "#{base}:#{loc.lineno} in `#{loc.label}`"
+      end
+    end
+  end
+end

data/lib/dontbugme/span.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  class Span
+    attr_reader :id, :category, :operation, :detail, :payload, :started_at, :duration_ms, :source
+
+    def initialize(
+      category:,
+      operation:,
+      detail:,
+      payload: {},
+      started_at:,
+      duration_ms:,
+      source: nil
+    )
+      @id = "sp_#{SecureRandom.hex(4)}"
+      @category = category.to_sym
+      @operation = operation.to_s
+      max_size = defined?(Dontbugme) && Dontbugme.respond_to?(:config) ? Dontbugme.config&.max_span_detail_size : 8192
+      @detail = truncate_string(detail.to_s, max_size)
+      @payload = payload
+      @started_at = started_at
+      @duration_ms = duration_ms
+      @source = source
+    end
+
+    def to_h
+      {
+        id: id,
+        category: category,
+        operation: operation,
+        detail: detail,
+        payload: payload,
+        started_at: started_at,
+        duration_ms: duration_ms,
+        source: source
+      }
+    end
+
+    def self.from_h(hash)
+      new(
+        category: hash[:category] || hash['category'],
+        operation: hash[:operation] || hash['operation'],
+        detail: hash[:detail] || hash['detail'],
+        payload: (hash[:payload] || hash['payload'] || {}).transform_keys(&:to_sym),
+        started_at: hash[:started_at] || hash['started_at'],
+        duration_ms: hash[:duration_ms] || hash['duration_ms'],
+        source: hash[:source] || hash['source']
+      )
+    end
+
+    private
+
+    def truncate_string(str, max_size)
+      return str if str.nil? || max_size.nil?
+      return str if str.bytesize <= max_size
+
+      truncated = str.byteslice(0, max_size)
+      original_size = str.bytesize
+      "#{truncated}[truncated, #{format_bytes(original_size)} original]"
+    end
+
+    def format_bytes(bytes)
+      return "#{bytes}B" if bytes < 1024
+      return "#{(bytes / 1024.0).round(1)}KB" if bytes < 1024 * 1024
+
+      "#{(bytes / (1024.0 * 1024)).round(1)}MB"
+    end
+  end
+end

data/lib/dontbugme/span_collection.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  class SpanCollection
+    include Enumerable
+
+    def initialize(spans)
+      @spans = spans.to_a.freeze
+    end
+
+    def each(&block)
+      @spans.each(&block)
+    end
+
+    def count
+      @spans.count
+    end
+
+    def category(cat)
+      @spans.select { |s| s.category == cat.to_sym }
+    end
+
+    def method_missing(method_name, *args, &block)
+      cat = method_name.to_s.downcase.to_sym
+      return category(cat) if known_category?(cat)
+
+      super
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      known_category?(method_name.to_s.downcase.to_sym) || super
+    end
+
+    private
+
+    def known_category?(cat)
+      %i[sql http redis cache mailer enqueue custom snapshot].include?(cat)
+    end
+  end
+end

data/lib/dontbugme/store/async.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Store
+    class Async < Base
+      def initialize(backend)
+        @backend = backend
+        @queue = Queue.new
+        @thread = start_worker
+      end
+
+      def save_trace(trace)
+        @queue << [:save, trace]
+      end
+
+      def find_trace(trace_id)
+        @backend.find_trace(trace_id)
+      end
+
+      def search(filters = {})
+        @backend.search(filters)
+      end
+
+      def cleanup(before:)
+        @queue << [:cleanup, before]
+      end
+
+      private
+
+      def start_worker
+        Thread.new do
+          loop do
+            action, arg = @queue.pop
+            case action
+            when :save
+              @backend.save_trace(arg)
+            when :cleanup
+              @backend.cleanup(before: arg)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dontbugme/store/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Store
+    class Base
+      def save_trace(trace)
+        raise NotImplementedError
+      end
+
+      def find_trace(trace_id)
+        raise NotImplementedError
+      end
+
+      def search(filters = {})
+        raise NotImplementedError
+      end
+
+      def cleanup(before:)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/dontbugme/store/memory.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Dontbugme
+  module Store
+    class Memory < Base
+      def initialize
+        @traces = {}
+        @mutex = Mutex.new
+      end
+
+      def save_trace(trace)
+        @mutex.synchronize do
+          @traces[trace.id] = trace.to_h
+        end
+      end
+
+      def find_trace(trace_id)
+        data = @mutex.synchronize { @traces[trace_id] }
+        return nil unless data
+
+        Trace.from_h(data)
+      end
+
+      def search(filters = {})
+        traces = @mutex.synchronize { @traces.values.dup }
+        traces = apply_filters(traces, filters)
+        traces.sort_by { |t| t[:started_at] || '' }.reverse.map { |h| Trace.from_h(h) }
+      end
+
+      def cleanup(before:)
+        cutoff = before.is_a?(Time) ? before : Time.parse(before.to_s)
+        @mutex.synchronize do
+          @traces.delete_if { |_, t| parse_time(t[:started_at]) < cutoff }
+        end
+      end
+
+      private
+
+      def apply_filters(traces, filters)
+        traces = traces.select { |t| t[:status] == filters[:status].to_s } if filters[:status]
+        traces = traces.select { |t| t[:status] == filters['status'].to_s } if filters['status']
+        traces = traces.select { |t| t[:kind].to_s == filters[:kind].to_s } if filters[:kind]
+        if filters[:identifier]
+          pattern = /#{Regexp.escape(filters[:identifier].to_s)}/i
+          traces = traces.select { |t| t[:identifier].to_s.match?(pattern) }
+        end
+        if filters[:correlation_id]
+          cid = filters[:correlation_id].to_s
+          traces = traces.select { |t| (t[:correlation_id] || t.dig(:metadata, :correlation_id)).to_s == cid }
+        end
+        traces = traces.first(filters[:limit] || filters['limit'] || 100)
+        traces
+      end
+
+      def parse_time(val)
+        return Time.at(0) unless val
+        val.is_a?(Time) ? val : Time.parse(val.to_s)
+      end
+    end
+  end
+end

data/lib/dontbugme/store/postgresql.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Dontbugme
+  module Store
+    class Postgresql < Base
+      def initialize(connection: nil)
+        @connection = connection || Dontbugme.config.postgresql_connection || default_connection
+        raise ArgumentError, 'PostgreSQL store requires a database connection' unless @connection
+        ensure_schema
+      end
+
+      def save_trace(trace)
+        data = trace.to_h
+        correlation_id = data[:correlation_id] || data[:metadata]&.dig(:correlation_id)
+        exec_params(
+          <<~SQL,
+            INSERT INTO dontbugme_traces
+            (id, kind, identifier, status, started_at, duration_ms, correlation_id, metadata_json, spans_json, error_json)
+            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+            ON CONFLICT (id) DO UPDATE SET
+              kind = EXCLUDED.kind,
+              identifier = EXCLUDED.identifier,
+              status = EXCLUDED.status,
+              started_at = EXCLUDED.started_at,
+              duration_ms = EXCLUDED.duration_ms,
+              correlation_id = EXCLUDED.correlation_id,
+              metadata_json = EXCLUDED.metadata_json,
+              spans_json = EXCLUDED.spans_json,
+              error_json = EXCLUDED.error_json
+          SQL
+          data[:id],
+          data[:kind].to_s,
+          data[:identifier],
+          data[:status].to_s,
+          data[:started_at],
+          data[:duration_ms],
+          correlation_id,
+          data[:metadata].to_json,
+          data[:spans].to_json,
+          data[:error]&.to_json
+        )
+      end
+
+      def find_trace(trace_id)
+        result = query_result('SELECT * FROM dontbugme_traces WHERE id = $1', [trace_id])
+        return nil if result.blank?
+
+        row = result.is_a?(Array) ? result.first : result.to_a.first
+        return nil unless row
+
+        row_to_trace(row)
+      end
+
+      def search(filters = {})
+        sql = 'SELECT * FROM dontbugme_traces WHERE 1=1'
+        params = []
+        i = 1
+
+        if filters[:status]
+          params << filters[:status].to_s
+          sql += " AND status = $#{i}"
+          i += 1
+        end
+        if filters[:kind]
+          params << filters[:kind].to_s
+          sql += " AND kind = $#{i}"
+          i += 1
+        end
+        if filters[:identifier]
+          params << "%#{filters[:identifier]}%"
+          sql += " AND identifier LIKE $#{i}"
+          i += 1
+        end
+        if filters[:correlation_id]
+          params << filters[:correlation_id].to_s
+          sql += " AND correlation_id = $#{i}"
+          i += 1
+        end
+
+        params << (filters[:limit] || filters['limit'] || 100)
+        sql += " ORDER BY started_at DESC LIMIT $#{i}"
+
+        result = query_result(sql, params)
+        rows = result.respond_to?(:to_a) ? result.to_a : Array(result)
+        rows.map { |row| row_to_trace(normalize_row(row)) }
+      end
+
+      def cleanup(before:)
+        cutoff = before.is_a?(Time) ? before.utc.iso8601 : before.to_s
+        exec_params('DELETE FROM dontbugme_traces WHERE started_at < $1', [cutoff])
+      end
+
+      def query_result(sql, params)
+        if conn.respond_to?(:exec_query)
+          conn.exec_query(sql, 'Dontbugme', params)
+        else
+          exec_params(sql, params)
+        end
+      end
+
+      def normalize_row(row)
+        return row if row.respond_to?(:[])
+
+        row
+      end
+
+      private
+
+      def conn
+        @connection
+      end
+
+      def default_connection
+        return nil unless defined?(ActiveRecord::Base)
+
+        ActiveRecord::Base.connection
+      end
+
+      def exec_params(sql, params)
+        if conn.respond_to?(:raw_connection)
+          conn.raw_connection.exec_params(sql, params)
+        elsif conn.respond_to?(:exec_params)
+          conn.exec_params(sql, params)
+        else
+          # Fallback: use execute with sanitization
+          sanitized = ActiveRecord::Base.sanitize_sql_array([sql] + params)
+          conn.execute(sanitized)
+        end
+      end
+
+      def exec_query(sql, params = [])
+        if conn.respond_to?(:exec_query)
+          conn.exec_query(sql, 'Dontbugme', params)
+        else
+          result = exec_params(sql, params)
+          result
+        end
+      end
+
+      def ensure_schema
+        return unless conn
+
+        conn.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS dontbugme_traces (
+            id VARCHAR(32) PRIMARY KEY,
+            kind VARCHAR(32),
+            identifier VARCHAR(512),
+            status VARCHAR(32),
+            started_at TIMESTAMP,
+            duration_ms REAL,
+            correlation_id VARCHAR(64),
+            metadata_json JSONB,
+            spans_json JSONB,
+            error_json JSONB
+          )
+        SQL
+        conn.execute('CREATE INDEX IF NOT EXISTS idx_dontbugme_started_at ON dontbugme_traces(started_at)')
+        conn.execute('CREATE INDEX IF NOT EXISTS idx_dontbugme_status ON dontbugme_traces(status)')
+        conn.execute('CREATE INDEX IF NOT EXISTS idx_dontbugme_correlation_id ON dontbugme_traces(correlation_id)')
+      rescue StandardError
+        # Schema might already exist
+      end
+
+      def row_to_trace(row)
+        metadata_json = row['metadata_json'] || row[:metadata_json]
+        spans_json = row['spans_json'] || row[:spans_json]
+        error_json = row['error_json'] || row[:error_json]
+        hash = {
+          id: row['id'] || row[:id],
+          kind: row['kind'] || row[:kind],
+          identifier: row['identifier'] || row[:identifier],
+          status: row['status'] || row[:status],
+          started_at: (row['started_at'] || row[:started_at])&.to_s,
+          duration_ms: (row['duration_ms'] || row[:duration_ms])&.to_f,
+          correlation_id: row['correlation_id'] || row[:correlation_id],
+          metadata: metadata_json ? (metadata_json.is_a?(String) ? JSON.parse(metadata_json, symbolize_names: true) : metadata_json) : {},
+          spans: spans_json ? (spans_json.is_a?(String) ? JSON.parse(spans_json, symbolize_names: true) : spans_json) : [],
+          error: error_json ? (error_json.is_a?(String) ? JSON.parse(error_json, symbolize_names: true) : error_json) : nil
+        }
+        Trace.from_h(hash)
+      end
+    end
+  end
+end

data/lib/dontbugme/store/sqlite.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+
+module Dontbugme
+  module Store
+    class Sqlite < Base
+      def initialize(path: nil)
+        @path = path || Dontbugme.config.sqlite_path
+        ensure_directory
+        ensure_schema
+      end
+
+      def save_trace(trace)
+        data = trace.to_h
+        correlation_id = data[:correlation_id] || data[:metadata]&.dig(:correlation_id)
+        db.execute(
+          'INSERT OR REPLACE INTO traces (id, kind, identifier, status, started_at, duration_ms, correlation_id, metadata_json, spans_json, error_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
+          data[:id],
+          data[:kind].to_s,
+          data[:identifier],
+          data[:status].to_s,
+          data[:started_at],
+          data[:duration_ms],
+          correlation_id,
+          data[:metadata].to_json,
+          data[:spans].to_json,
+          data[:error]&.to_json
+        )
+      end
+
+      def find_trace(trace_id)
+        row = db.execute('SELECT id, kind, identifier, status, started_at, duration_ms, correlation_id, metadata_json, spans_json, error_json FROM traces WHERE id = ?', trace_id).first
+        return nil unless row
+
+        row_to_trace(row)
+      end
+
+      def search(filters = {})
+        sql = 'SELECT id, kind, identifier, status, started_at, duration_ms, correlation_id, metadata_json, spans_json, error_json FROM traces WHERE 1=1'
+        params = []
+
+        if filters[:status]
+          sql += ' AND status = ?'
+          params << filters[:status].to_s
+        end
+        if filters[:kind]
+          sql += ' AND kind = ?'
+          params << filters[:kind].to_s
+        end
+        if filters[:identifier]
+          sql += ' AND identifier LIKE ?'
+          params << "%#{filters[:identifier]}%"
+        end
+        if filters[:correlation_id]
+          sql += ' AND correlation_id = ?'
+          params << filters[:correlation_id].to_s
+        end
+
+        sql += ' ORDER BY started_at DESC LIMIT ?'
+        params << (filters[:limit] || filters['limit'] || 100)
+
+        rows = db.execute(sql, *params)
+        rows.map { |row| row_to_trace(row) }
+      end
+
+      def cleanup(before:)
+        cutoff = before.is_a?(Time) ? before.iso8601 : before.to_s
+        db.execute('DELETE FROM traces WHERE started_at < ?', cutoff)
+      end
+
+      private
+
+      def db
+        @db ||= begin
+          require 'sqlite3'
+          SQLite3::Database.new(@path)
+        end
+      end
+
+      def ensure_directory
+        dir = File.dirname(@path)
+        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      end
+
+      def ensure_schema
+        db.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS traces (
+            id TEXT PRIMARY KEY,
+            kind TEXT,
+            identifier TEXT,
+            status TEXT,
+            started_at TEXT,
+            duration_ms REAL,
+            correlation_id TEXT,
+            metadata_json TEXT,
+            spans_json TEXT,
+            error_json TEXT
+          )
+        SQL
+        migrate_add_correlation_id
+        db.execute('CREATE INDEX IF NOT EXISTS idx_traces_started_at ON traces(started_at)')
+        db.execute('CREATE INDEX IF NOT EXISTS idx_traces_status ON traces(status)')
+        db.execute('CREATE INDEX IF NOT EXISTS idx_traces_correlation_id ON traces(correlation_id)')
+      end
+
+      def migrate_add_correlation_id
+        return if db.execute("PRAGMA table_info(traces)").any? { |col| col[1] == 'correlation_id' }
+
+        db.execute('ALTER TABLE traces ADD COLUMN correlation_id TEXT')
+      end
+
+      def row_to_trace(row)
+        # row: [id, kind, identifier, status, started_at, duration_ms, correlation_id, metadata_json, spans_json, error_json]
+        # Handle both old schema (9 cols) and new (10 cols)
+        if row.size >= 10
+          hash = {
+            id: row[0],
+            kind: row[1],
+            identifier: row[2],
+            status: row[3],
+            started_at: row[4],
+            duration_ms: row[5],
+            metadata: row[7] ? JSON.parse(row[7], symbolize_names: true) : {},
+            spans: row[8] ? JSON.parse(row[8], symbolize_names: true) : [],
+            error: row[9] ? JSON.parse(row[9], symbolize_names: true) : nil
+          }
+          hash[:correlation_id] = row[6] if row[6]
+          hash[:metadata][:correlation_id] ||= row[6] if row[6]
+        else
+          hash = {
+            id: row[0],
+            kind: row[1],
+            identifier: row[2],
+            status: row[3],
+            started_at: row[4],
+            duration_ms: row[5],
+            metadata: row[6] ? JSON.parse(row[6], symbolize_names: true) : {},
+            spans: row[7] ? JSON.parse(row[7], symbolize_names: true) : [],
+            error: row[8] ? JSON.parse(row[8], symbolize_names: true) : nil
+          }
+        end
+        Trace.from_h(hash)
+      end
+    end
+  end
+end