bugwatch-ruby 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21032d38b9ffee6bf1dbef68e9ce7c39b56c28b0eb2369d76bdf684b4ed25df3
-  data.tar.gz: 052521dd770495c7bd271313788d71e9b1d0fd8dede69f1d2fa86603bd25eccc
+  metadata.gz: 6d6a47f1c5176ec17f87160b5ab4a273e6ef68e76dee98f6e60ee5da474a61fd
+  data.tar.gz: 713ab0b06839f57c473a98c8f3e1cd46f2f43b2c9ccfef2b18d7ba0e3abb1076
 SHA512:
-  metadata.gz: 9895be8ecb3c5db57f8996b1d702f75da6658d8370a470b72b88b6b12dc5da8690461208991cd14980bb5a996b70a19854c6747e4f460b9a868a75b3da0aaae8
-  data.tar.gz: a51dd3a8af6502533474624b1c1352661e0a5ce047b25d5f30dd693810cce7fd7532af83b7071a6987760a6bd61cce485fc4b6700c8f2b5f9d3d5366ef9a1ee2
+  metadata.gz: cb255c2fcfe9562b06320de183bc1ee141f394eacb327eb6ad71739a662aaeb435f5da3248404a7074b45e6a397612d86fe8d243918284196cb7e3892c193f8a
+  data.tar.gz: 9ce11bcc466b319298cb788f51cdb1c89f00f6b3126189d02c9a7838eeb6f087291bb0864bc5115734849a1af966f2995385a627a057befbf815c63354e122ee

data/README.md

@@ -181,6 +181,55 @@ Bugwatch.send_feedback(
 )
 ```
 
+## Database query tracking
+
+The gem automatically subscribes to `sql.active_record` notifications and reports query performance data to your BugWatch instance. DB tracking is **enabled by default** — no extra setup required.
+
+### Configuration
+
+```ruby
+# config/initializers/bugwatch.rb
+Bugwatch.configure do |c|
+  # ... existing config ...
+
+  c.enable_db_tracking      = true   # default: true — set false to disable
+  c.db_sample_rate          = 1.0    # 0.0–1.0 — fraction of requests to track (default: 1.0)
+  c.db_query_threshold_ms   = 0      # only collect queries slower than this (default: 0 = all)
+  c.max_queries_per_request = 200    # cap per request to limit overhead (default: 200)
+end
+```
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `enable_db_tracking` | `true` | Master switch for DB tracking |
+| `db_sample_rate` | `1.0` | Fraction of requests whose queries are collected (0.0–1.0) |
+| `db_query_threshold_ms` | `0` | Minimum query duration (ms) to collect — set higher to focus on slow queries |
+| `max_queries_per_request` | `200` | Maximum queries stored per request |
+
+Schema operations and transaction bookkeeping (`BEGIN`, `COMMIT`, `ROLLBACK`) are automatically excluded. SQL literals are sanitized before sending, so no user data leaves your app.
+
+### Skipping tracking
+
+Wrap any code block with `Bugwatch.without_tracking` to suppress all performance tracking (DB queries and transaction recording) for queries executed inside it. This is useful when BugWatch monitors itself, or for any internal bookkeeping queries you don't want tracked.
+
+```ruby
+Bugwatch.without_tracking do
+  SomeModel.insert_all(records)  # not tracked
+end
+```
+
+In a controller:
+
+```ruby
+around_action :skip_tracking
+
+private
+
+def skip_tracking(&block)
+  Bugwatch.without_tracking(&block)
+end
+```
+
 ## How it works
 
 1. `Bugwatch::Middleware` wraps your entire Rack stack.

data/lib/bugwatch/configuration.rb

@@ -9,7 +9,11 @@ module Bugwatch
                   :logger,
                   :enable_performance_tracking,
                   :sample_rate,
-                  :ignore_request_paths
+                  :ignore_request_paths,
+                  :enable_db_tracking,
+                  :db_sample_rate,
+                  :db_query_threshold_ms,
+                  :max_queries_per_request
 
     def initialize
       @endpoint                    = nil
@@ -20,6 +24,10 @@ module Bugwatch
       @enable_performance_tracking = true
       @sample_rate                 = 1.0
       @ignore_request_paths        = []
+      @enable_db_tracking          = true
+      @db_sample_rate              = 1.0
+      @db_query_threshold_ms       = 0.0
+      @max_queries_per_request     = 200
     end
 
     def notify_for_release_stage?

data/lib/bugwatch/db_query_buffer.rb

@@ -0,0 +1,61 @@
+module Bugwatch
+  class DbQueryBuffer
+    BATCH_SIZE     = 50
+    FLUSH_INTERVAL = 15 # seconds
+
+    def initialize(config: Bugwatch.configuration)
+      @config = config
+      @sender = DbQuerySender.new(config: config)
+      @mutex  = Mutex.new
+      @buffer = []
+      start_flusher
+    end
+
+    def push(payload)
+      should_flush = false
+
+      @mutex.synchronize do
+        @buffer << payload
+        should_flush = @buffer.size >= BATCH_SIZE
+      end
+
+      flush if should_flush
+    end
+
+    def flush
+      batch = @mutex.synchronize do
+        items = @buffer
+        @buffer = []
+        items
+      end
+
+      @sender.send_batch(batch) unless batch.empty?
+    rescue StandardError
+      # Never let flushing break the app
+    end
+
+    def shutdown
+      stop_flusher
+      flush
+    end
+
+    private
+
+    def start_flusher
+      @flusher = Thread.new do
+        loop do
+          sleep FLUSH_INTERVAL
+          flush
+        end
+      rescue StandardError
+        # Silently handle thread errors
+      end
+      @flusher.abort_on_exception = false
+      @flusher.daemon = true if @flusher.respond_to?(:daemon=)
+    end
+
+    def stop_flusher
+      @flusher&.kill
+    end
+  end
+end

data/lib/bugwatch/db_query_sender.rb

@@ -0,0 +1,66 @@
+require "net/http"
+require "uri"
+require "json"
+
+module Bugwatch
+  class DbQuerySender
+    TIMEOUT = 3
+
+    def initialize(config: Bugwatch.configuration)
+      @config = config
+    end
+
+    def send_batch(grouped_payloads)
+      return if grouped_payloads.empty?
+      return unless @config.api_key
+      return unless @config.endpoint
+
+      Thread.new do
+        post_batch(grouped_payloads)
+      rescue StandardError
+        # Fire-and-forget: swallow all errors
+      end
+    end
+
+    private
+
+    def post_batch(grouped_payloads)
+      records = grouped_payloads.flat_map do |group|
+        group[:queries].map do |q|
+          {
+            transaction_name: group[:transaction_name],
+            environment:      group[:environment],
+            occurred_at:      group[:occurred_at],
+            sql:              q[:sql],
+            raw_sql:          q[:raw_sql],
+            duration_ms:      q[:duration_ms],
+            name:             q[:name],
+            operation:        q[:operation],
+            caller_location:  q[:caller_location]
+          }
+        end
+      end
+
+      return if records.empty?
+
+      uri = URI.parse("#{@config.endpoint.chomp("/")}/api/v1/db_queries/batch")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl       = uri.scheme == "https"
+      http.open_timeout  = TIMEOUT
+      http.read_timeout  = TIMEOUT
+      http.write_timeout = TIMEOUT
+
+      request = Net::HTTP::Post.new(uri.path)
+      request["Content-Type"]    = "application/json"
+      request["X-Api-Key"]       = @config.api_key
+      request["X-BugWatch-Ruby"] = Bugwatch::VERSION
+
+      request.body = JSON.generate({ queries: records })
+
+      http.request(request)
+    rescue StandardError
+      # Silently discard network errors
+    end
+  end
+end

data/lib/bugwatch/db_tracker.rb

@@ -0,0 +1,96 @@
+require "active_support/notifications"
+
+module Bugwatch
+  module DbTracker
+    THREAD_KEY = :bugwatch_db_tracker
+    IGNORED_NAMES = %w[SCHEMA EXPLAIN].freeze
+    IGNORED_SQL_PATTERNS = /\A\s*(BEGIN|COMMIT|ROLLBACK|SAVEPOINT|RELEASE SAVEPOINT)/i
+
+    CALLER_FILTER = %r{/(active_record|bugwatch|ruby/gems)/}
+
+    module_function
+
+    def subscribe!
+      ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        handle_event(event)
+      end
+    end
+
+    def start_request(collecting:)
+      Thread.current[THREAD_KEY] = {
+        queries: [],
+        total_db_ms: 0.0,
+        collecting: collecting
+      }
+    end
+
+    def finish_request
+      state = Thread.current[THREAD_KEY]
+      Thread.current[THREAD_KEY] = nil
+      state
+    end
+
+    def clear
+      Thread.current[THREAD_KEY] = nil
+    end
+
+    def handle_event(event)
+      return if Bugwatch.skip_tracking?
+
+      state = Thread.current[THREAD_KEY]
+      return unless state
+
+      name = event.payload[:name].to_s
+      sql  = event.payload[:sql].to_s
+      return if IGNORED_NAMES.include?(name)
+      return if sql.match?(IGNORED_SQL_PATTERNS)
+
+      duration_ms = event.duration
+
+      state[:total_db_ms] += duration_ms
+
+      return unless state[:collecting]
+
+      config = Bugwatch.configuration
+      return if duration_ms < config.db_query_threshold_ms
+      return if state[:queries].size >= config.max_queries_per_request
+
+      state[:queries] << {
+        sql: sanitize_sql(sql),
+        raw_sql: sql,
+        duration_ms: duration_ms.round(2),
+        name: name.presence,
+        operation: extract_operation(sql),
+        caller_location: extract_caller
+      }
+    rescue StandardError
+      # Never let tracking break the app
+    end
+
+    def sanitize_sql(sql)
+      s = sql.dup
+      s.gsub!(/'(?:[^'\\]|\\.)*'/, "?")
+      s.gsub!(/"(?:[^"\\]|\\.)*"/, "?") unless s.include?(".")
+      s.gsub!(/\b\d+(\.\d+)?\b/, "?")
+      s.gsub!(/\b(TRUE|FALSE|NULL)\b/i, "?")
+      s.gsub!(/IN\s*\(\s*\?(?:\s*,\s*\?)*\s*\)/i, "IN (?)")
+      s
+    end
+
+    def extract_operation(sql)
+      sql.strip.split(/\s/, 2).first&.upcase
+    end
+
+    def extract_caller
+      caller_locations(4, 30)&.each do |loc|
+        path = loc.path.to_s
+        next if path.match?(CALLER_FILTER)
+        return "#{loc.path}:#{loc.lineno}"
+      end
+      nil
+    end
+
+    private_class_method :handle_event, :sanitize_sql, :extract_operation, :extract_caller
+  end
+end

data/lib/bugwatch/middleware.rb

@@ -5,10 +5,16 @@ module Bugwatch
     end
 
     def call(env)
+      return @app.call(env) if Bugwatch.skip_tracking?
+
       start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       BreadcrumbCollector.clear
       UserContext.clear
 
+      config = Bugwatch.configuration
+      collecting = config.enable_db_tracking && (rand < config.db_sample_rate)
+      DbTracker.start_request(collecting: collecting)
+
       begin
         status, headers, body = @app.call(env)
         record_transaction(env, status, start)
@@ -24,6 +30,8 @@ module Bugwatch
 
         record_transaction(env, 500, start)
         raise
+      ensure
+        DbTracker.clear
       end
     end
 
@@ -35,6 +43,7 @@ module Bugwatch
       return unless config.track_request?(req.path)
 
       duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round
+      db_result = DbTracker.finish_request
 
       payload = {
         name:           "#{req.request_method} #{req.path}",
@@ -46,7 +55,18 @@ module Bugwatch
         occurred_at:    Time.now.utc.iso8601
       }
 
+      payload[:db_duration_ms] = db_result[:total_db_ms].round(1) if db_result
+
       Bugwatch.transaction_buffer.push(payload)
+
+      if db_result && db_result[:queries].any?
+        Bugwatch.db_query_buffer.push({
+          transaction_name: payload[:name],
+          environment:      config.release_stage,
+          occurred_at:      payload[:occurred_at],
+          queries:          db_result[:queries]
+        })
+      end
     rescue StandardError
       # Never let tracking break the app
     end

data/lib/bugwatch/railtie.rb

@@ -25,6 +25,12 @@ module Bugwatch
       end
     end
 
+    initializer "bugwatch.db_tracking" do
+      ActiveSupport.on_load(:active_record) do
+        Bugwatch::DbTracker.subscribe! if Bugwatch.configuration.enable_db_tracking
+      end
+    end
+
     initializer "bugwatch.error_subscriber" do
       if defined?(Rails.error) && Rails.error.respond_to?(:subscribe)
         Rails.error.subscribe(Bugwatch::ErrorSubscriber.new)

data/lib/bugwatch/version.rb

@@ -1,3 +1,3 @@
 module Bugwatch
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

data/lib/bugwatch.rb

@@ -11,6 +11,9 @@ require_relative "bugwatch/report_builder"
 require_relative "bugwatch/notification"
 require_relative "bugwatch/transaction_sender"
 require_relative "bugwatch/transaction_buffer"
+require_relative "bugwatch/db_tracker"
+require_relative "bugwatch/db_query_sender"
+require_relative "bugwatch/db_query_buffer"
 require_relative "bugwatch/feedback_sender"
 require_relative "bugwatch/feedback_helper"
 require_relative "bugwatch/middleware"
@@ -117,10 +120,28 @@ module Bugwatch
       end
     end
 
+    def without_tracking
+      Thread.current[:bugwatch_skip_tracking] = true
+      yield
+    ensure
+      Thread.current[:bugwatch_skip_tracking] = false
+    end
+
+    def skip_tracking?
+      Thread.current[:bugwatch_skip_tracking] == true
+    end
+
     def transaction_buffer
       @transaction_buffer ||= TransactionBuffer.new(config: configuration)
     end
+
+    def db_query_buffer
+      @db_query_buffer ||= DbQueryBuffer.new(config: configuration)
+    end
   end
 end
 
-at_exit { Bugwatch.transaction_buffer.shutdown rescue nil }
+at_exit do
+  Bugwatch.transaction_buffer.shutdown rescue nil
+  Bugwatch.db_query_buffer.shutdown rescue nil
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: bugwatch-ruby
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - BugWatch
 bindir: bin
 cert_chain: []
-date: 2026-04-13 00:00:00.000000000 Z
+date: 2026-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -52,6 +52,9 @@ files:
 - lib/bugwatch/backtrace_cleaner.rb
 - lib/bugwatch/breadcrumb_collector.rb
 - lib/bugwatch/configuration.rb
+- lib/bugwatch/db_query_buffer.rb
+- lib/bugwatch/db_query_sender.rb
+- lib/bugwatch/db_tracker.rb
 - lib/bugwatch/error_builder.rb
 - lib/bugwatch/error_subscriber.rb
 - lib/bugwatch/feedback_helper.rb