bugwatch-ruby 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21032d38b9ffee6bf1dbef68e9ce7c39b56c28b0eb2369d76bdf684b4ed25df3
-  data.tar.gz: 052521dd770495c7bd271313788d71e9b1d0fd8dede69f1d2fa86603bd25eccc
+  metadata.gz: c4cb56c42da0cab5b2e855deca671231a744b1624b5fcbd6dbef365f30bc9d08
+  data.tar.gz: 92889ce7b6cec458ee2c75c15759756acbaa32981051704c9a3534a42e58fe1d
 SHA512:
-  metadata.gz: 9895be8ecb3c5db57f8996b1d702f75da6658d8370a470b72b88b6b12dc5da8690461208991cd14980bb5a996b70a19854c6747e4f460b9a868a75b3da0aaae8
-  data.tar.gz: a51dd3a8af6502533474624b1c1352661e0a5ce047b25d5f30dd693810cce7fd7532af83b7071a6987760a6bd61cce485fc4b6700c8f2b5f9d3d5366ef9a1ee2
+  metadata.gz: 479c753810d0c158b339281f7f7c5c083134bfe4321cfe7739a28d24d14fc3c82fb26e17330de1bc92f13e41e66e2726c4fe0b42b2d5110301c3410e566fc564
+  data.tar.gz: 6b2a55bf2cdd3a01fd82bd96a51c75f50fbbc48a373b8102c7c6a301ab748c75f7434084402d56cbf3b2009a838648205fa95c4706eb07655a423ef290f35d49

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,94 @@
+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)
+      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

@@ -9,6 +9,10 @@ module Bugwatch
       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 +28,8 @@ module Bugwatch
 
         record_transaction(env, 500, start)
         raise
+      ensure
+        DbTracker.clear
       end
     end
 
@@ -35,6 +41,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 +53,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.6.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"
@@ -120,7 +123,14 @@ module Bugwatch
     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.6.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