bugwatch-ruby 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9d4ff0ad03b9ab70f5f37f3a4656f7b1746a86c22ee33e429242c08c0527036
-  data.tar.gz: 0a9c5bc904036439926f2e7097d07db78d8e5139ed3d2df81a57c98836661a97
+  metadata.gz: c4cb56c42da0cab5b2e855deca671231a744b1624b5fcbd6dbef365f30bc9d08
+  data.tar.gz: 92889ce7b6cec458ee2c75c15759756acbaa32981051704c9a3534a42e58fe1d
 SHA512:
-  metadata.gz: 59abfb1a125beba2a9aff1676e0299625e6b352cb4b71005b6e4a2854cff3d19758578ce6a91addadbd64f8a7656449e3766da0b3edc5659dc6f49a3953ce733
-  data.tar.gz: 579309e1a64318f07275fc4139481021d94cd01fb816f36b42cd5b8f8a0eac273d6e690b920649cd8787eee59b555b371592fe308f16396b91c84c118b2925df
+  metadata.gz: 479c753810d0c158b339281f7f7c5c083134bfe4321cfe7739a28d24d14fc3c82fb26e17330de1bc92f13e41e66e2726c4fe0b42b2d5110301c3410e566fc564
+  data.tar.gz: 6b2a55bf2cdd3a01fd82bd96a51c75f50fbbc48a373b8102c7c6a301ab748c75f7434084402d56cbf3b2009a838648205fa95c4706eb07655a423ef290f35d49

data/README.md

@@ -121,6 +121,66 @@ release: bundle exec rails db:migrate && bundle exec rails bugwatch:track_deploy
 
 The build will write the commit SHA to `REVISION`, and the release phase will read it back and report the deploy to BugWatch.
 
+## User Feedback Widget
+
+Drop a feedback form into any view so users can report issues directly from your app. The form submits to BugWatch's feedback API — no controller code needed.
+
+```erb
+<%%= bugwatch_feedback_widget %>
+```
+
+The helper renders a plain, unstyled HTML form with CSS classes you can target:
+
+| Class | Element |
+|-------|---------|
+| `.bugwatch-feedback-form` | The `<form>` wrapper |
+| `.bugwatch-feedback-field` | Each field's `<div>` |
+| `.bugwatch-feedback-label` | `<label>` elements |
+| `.bugwatch-feedback-input` | Text/email `<input>` |
+| `.bugwatch-feedback-textarea` | The message `<textarea>` |
+| `.bugwatch-feedback-submit` | Submit `<button>` |
+| `.bugwatch-feedback-success` | Success message (hidden by default) |
+| `.bugwatch-feedback-error` | Error message (hidden by default) |
+
+### Options
+
+```erb
+<%%= bugwatch_feedback_widget(
+  user_email: current_user&.email,
+  user_name:  current_user&.name,
+  placeholder: "Describe the issue...",
+  submit_text: "Report Issue",
+  success_message: "We got it — thanks!",
+  issue_id: @issue_id,        # optional: link to a specific BugWatch issue
+  metadata: { page: "checkout" }
+) %>
+```
+
+### Styling example (Tailwind)
+
+```css
+.bugwatch-feedback-form { @apply space-y-4 max-w-md; }
+.bugwatch-feedback-label { @apply block text-sm font-medium text-gray-700; }
+.bugwatch-feedback-input,
+.bugwatch-feedback-textarea { @apply w-full border rounded-lg px-3 py-2 text-sm; }
+.bugwatch-feedback-submit { @apply bg-blue-600 text-white px-4 py-2 rounded-lg text-sm; }
+.bugwatch-feedback-success { @apply text-green-600 text-sm; }
+.bugwatch-feedback-error { @apply text-red-600 text-sm; }
+```
+
+### Server-side feedback
+
+You can also send feedback from Ruby (e.g. from a controller that handles your own form):
+
+```ruby
+Bugwatch.send_feedback(
+  params[:message],
+  email: current_user.email,
+  name:  current_user.name,
+  url:   request.original_url
+)
+```
+
 ## 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,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/feedback_helper.rb

@@ -0,0 +1,86 @@
+module Bugwatch
+  module FeedbackHelper
+    # Renders a minimal, unstyled feedback widget form.
+    #
+    # The form submits via fetch to the BugWatch feedback API.
+    # All markup uses "bugwatch-feedback-*" CSS classes so you
+    # can style it however you want without collisions.
+    #
+    # Options:
+    #   :user_email  - Pre-fill email (e.g. current_user.email)
+    #   :user_name   - Pre-fill name  (e.g. current_user.name)
+    #   :issue_id    - Link feedback to a specific BugWatch issue
+    #   :metadata    - Hash of extra data to attach
+    #   :placeholder - Textarea placeholder text
+    #   :submit_text - Submit button label (default: "Send Feedback")
+    #   :success_message - Message shown after successful submit
+    #
+    def bugwatch_feedback_widget(user_email: nil, user_name: nil, issue_id: nil, metadata: {}, placeholder: "What happened? Tell us about the issue...", submit_text: "Send Feedback", success_message: "Thanks for your feedback!")
+      config   = Bugwatch.configuration
+      endpoint = "#{config.endpoint&.chomp("/")}/api/v1/feedback"
+      api_key  = config.api_key
+      widget_id = "bugwatch-feedback-#{SecureRandom.hex(4)}"
+
+      html = <<~HTML
+        <form id="#{widget_id}" class="bugwatch-feedback-form" data-bugwatch-feedback>
+          <div class="bugwatch-feedback-field">
+            <label for="#{widget_id}-name" class="bugwatch-feedback-label">Name</label>
+            <input type="text" id="#{widget_id}-name" name="name" value="#{ERB::Util.html_escape(user_name.to_s)}" class="bugwatch-feedback-input" />
+          </div>
+          <div class="bugwatch-feedback-field">
+            <label for="#{widget_id}-email" class="bugwatch-feedback-label">Email</label>
+            <input type="email" id="#{widget_id}-email" name="email" value="#{ERB::Util.html_escape(user_email.to_s)}" class="bugwatch-feedback-input" />
+          </div>
+          <div class="bugwatch-feedback-field">
+            <label for="#{widget_id}-message" class="bugwatch-feedback-label">Message</label>
+            <textarea id="#{widget_id}-message" name="message" required class="bugwatch-feedback-textarea" placeholder="#{ERB::Util.html_escape(placeholder)}"></textarea>
+          </div>
+          <button type="submit" class="bugwatch-feedback-submit">#{ERB::Util.html_escape(submit_text)}</button>
+          <div class="bugwatch-feedback-success" style="display:none">#{ERB::Util.html_escape(success_message)}</div>
+          <div class="bugwatch-feedback-error" style="display:none"></div>
+        </form>
+        <script>
+          (function() {
+            var form = document.getElementById("#{widget_id}");
+            form.addEventListener("submit", function(e) {
+              e.preventDefault();
+              var btn     = form.querySelector(".bugwatch-feedback-submit");
+              var success = form.querySelector(".bugwatch-feedback-success");
+              var error   = form.querySelector(".bugwatch-feedback-error");
+              success.style.display = "none";
+              error.style.display   = "none";
+              btn.disabled = true;
+
+              var body = {
+                api_key: #{api_key.to_json},
+                message: form.querySelector("[name=message]").value,
+                name:    form.querySelector("[name=name]").value || undefined,
+                email:   form.querySelector("[name=email]").value || undefined,
+                url:     window.location.href
+              };
+              #{issue_id ? "body.issue_id = #{issue_id.to_json};" : ""}
+              #{metadata.any? ? "body.metadata = #{metadata.to_json};" : ""}
+
+              fetch(#{endpoint.to_json}, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body)
+              }).then(function(r) {
+                if (!r.ok) throw new Error("Request failed");
+                form.querySelector("[name=message]").value = "";
+                success.style.display = "";
+                btn.disabled = false;
+              }).catch(function(err) {
+                error.textContent = "Something went wrong. Please try again.";
+                error.style.display = "";
+                btn.disabled = false;
+              });
+            });
+          })();
+        </script>
+      HTML
+
+      html.html_safe
+    end
+  end
+end

data/lib/bugwatch/feedback_sender.rb

@@ -0,0 +1,58 @@
+require "net/http"
+require "uri"
+require "json"
+
+module Bugwatch
+  class FeedbackSender
+    TIMEOUT = 3
+
+    def initialize(message:, email: nil, name: nil, url: nil, issue_id: nil, metadata: {}, config: Bugwatch.configuration)
+      @message  = message
+      @email    = email
+      @name     = name
+      @url      = url
+      @issue_id = issue_id
+      @metadata = metadata
+      @config   = config
+    end
+
+    def deliver
+      return unless @config.api_key
+      return unless @config.endpoint
+
+      Thread.new do
+        post_feedback
+      rescue StandardError
+        # Fire-and-forget: never affect the host app
+      end
+    end
+
+    private
+
+    def post_feedback
+      uri = URI.parse("#{@config.endpoint.chomp("/")}/api/v1/feedback")
+
+      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
+
+      payload = { message: @message }
+      payload[:email]    = @email    if @email
+      payload[:name]     = @name     if @name
+      payload[:url]      = @url      if @url
+      payload[:issue_id] = @issue_id if @issue_id
+      payload[:metadata] = @metadata if @metadata.any?
+
+      request.body = JSON.generate(payload)
+
+      http.request(request)
+    end
+  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

@@ -19,6 +19,18 @@ module Bugwatch
       end
     end
 
+    initializer "bugwatch.view_helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include Bugwatch::FeedbackHelper
+      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.4.0"
+  VERSION = "0.6.0"
 end

data/lib/bugwatch.rb

@@ -11,6 +11,11 @@ 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"
 require_relative "bugwatch/active_job_handler"
 require_relative "bugwatch/error_subscriber"
@@ -43,6 +48,15 @@ module Bugwatch
       Notification.new(payload).deliver
     end
 
+    def send_feedback(message, email: nil, name: nil, url: nil, issue_id: nil, metadata: {})
+      return if message.to_s.strip.empty?
+
+      FeedbackSender.new(
+        message: message, email: email, name: name,
+        url: url, issue_id: issue_id, metadata: metadata
+      ).deliver
+    end
+
     def set_user(id: nil, email: nil, name: nil, **custom)
       UserContext.set(id: id, email: email, name: name, **custom)
     end
@@ -109,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.4.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,8 +52,13 @@ 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
+- lib/bugwatch/feedback_sender.rb
 - lib/bugwatch/middleware.rb
 - lib/bugwatch/notification.rb
 - lib/bugwatch/railtie.rb