bugwatch-ruby 0.7.1 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1cf7953dfa5c81c889aa0e51cc8ed4211b06c566620c48248e1171580cde9077
-  data.tar.gz: c8eacd0b880a71d0502ef6622d4a30257932de7ed72d3665d36c92db5db47635
+  metadata.gz: f7845d9912f5a403dec979a3457ab7e121a12fb3de870b978d864d8eafb71755
+  data.tar.gz: cc43de7851a77523328ca61f5e8b0cd0d4aaa0f9867b3229aa9e34fb04e45a1a
 SHA512:
-  metadata.gz: 8c65e8c7831523385112c3bb24148c118d0c0124f30dea1022f2c5a39d05f775b53c088dfecc007ada12af0c0c41657bfb0376b638153a837981b08923e0ce03
-  data.tar.gz: 9d4d10c1ce02671998a4085550d59f11e2dcefb15a3b9b1177d16081cd33a52b24a3316bc1295b318ea0ba9c02bc35347487c6ccbe071760898fb5e62a2670e6
+  metadata.gz: 1d5479d1aa4ea0b1060c06328835f8c11b808389d83656a70121ab78e8ff30887caf828433edc27541d39e91ae76e43a568fa08bbf30e014a9c12246d5b88fb3
+  data.tar.gz: 3eb19a7f384614714730f68b07243d98064c4b90cca61b90a92b84a10a817cceabc1a520cf61ffdfcdc806a7deb64f0d7dc6157a7f9e0a9b0724ac809f243afb

data/README.md

@@ -257,8 +257,8 @@ Sensitive params (`password`, `token`, `secret`, `key`, `auth`, `credit`, `card`
 ## Publishing
 
 ```bash
-cd /home/max/bugwatch-ruby
+cd gems/bugwatch-ruby
 gem build bugwatch-ruby.gemspec
 gem signin
-gem push bugwatch-ruby-0.1.0.gem
+gem push bugwatch-ruby-0.8.0.gem
 ```

data/lib/bugwatch/active_job_handler.rb

@@ -3,6 +3,7 @@ module Bugwatch
     def call(job, exception)
       return if Bugwatch.configuration.ignore?(exception)
       return unless Bugwatch.configuration.notify_for_release_stage?
+      return if ReportedExceptions.reported?(exception)
 
       payload = ErrorBuilder.new(exception).build
       payload[:context] = {
@@ -13,6 +14,7 @@ module Bugwatch
       }
 
       Notification.new(payload).deliver
+      ReportedExceptions.mark(exception)
     end
 
     private

data/lib/bugwatch/configuration.rb

@@ -13,7 +13,10 @@ module Bugwatch
                   :enable_db_tracking,
                   :db_sample_rate,
                   :db_query_threshold_ms,
-                  :max_queries_per_request
+                  :max_queries_per_request,
+                  :enable_http_tracking,
+                  :http_sample_rate,
+                  :max_http_calls_per_request
 
     def initialize
       @endpoint                    = nil
@@ -28,6 +31,9 @@ module Bugwatch
       @db_sample_rate              = 1.0
       @db_query_threshold_ms       = 0.0
       @max_queries_per_request     = 200
+      @enable_http_tracking        = true
+      @http_sample_rate            = 1.0
+      @max_http_calls_per_request  = 100
     end
 
     def notify_for_release_stage?

data/lib/bugwatch/controller_rescue_hook.rb

@@ -0,0 +1,23 @@
+module Bugwatch
+  module ControllerRescueHook
+    def rescue_with_handler(exception, **kwargs)
+      handler = super
+
+      if handler && exception.is_a?(Exception) && !ReportedExceptions.reported?(exception)
+        begin
+          context = {
+            handled:    true,
+            controller: self.class.name,
+            action:     (action_name if respond_to?(:action_name))
+          }.compact
+
+          Bugwatch.notify(exception, context: context)
+        rescue StandardError
+          # Never let reporting break the host's rescue flow
+        end
+      end
+
+      handler
+    end
+  end
+end

data/lib/bugwatch/error_subscriber.rb

@@ -3,6 +3,7 @@ module Bugwatch
     def report(error, handled:, severity:, context: {}, source: nil)
       return if Bugwatch.configuration.ignore?(error)
       return unless Bugwatch.configuration.notify_for_release_stage?
+      return if ReportedExceptions.reported?(error)
 
       payload = ErrorBuilder.new(error).build
       payload[:context] = context.merge(
@@ -12,6 +13,7 @@ module Bugwatch
       ).compact
 
       Notification.new(payload).deliver
+      ReportedExceptions.mark(error)
     end
   end
 end

data/lib/bugwatch/http_call_buffer.rb

@@ -0,0 +1,61 @@
+module Bugwatch
+  class HttpCallBuffer
+    BATCH_SIZE     = 50
+    FLUSH_INTERVAL = 15 # seconds
+
+    def initialize(config: Bugwatch.configuration)
+      @config = config
+      @sender = HttpCallSender.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/http_call_sender.rb

@@ -0,0 +1,68 @@
+require "net/http"
+require "uri"
+require "json"
+
+module Bugwatch
+  class HttpCallSender
+    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
+        Bugwatch.without_tracking { 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[:calls].map do |c|
+          {
+            transaction_name: group[:transaction_name],
+            environment:      group[:environment],
+            occurred_at:      group[:occurred_at],
+            host:             c[:host],
+            port:             c[:port],
+            method:           c[:method],
+            path:             c[:path],
+            status_code:      c[:status_code],
+            duration_ms:      c[:duration_ms],
+            library:          c[:library],
+            caller_location:  c[:caller_location]
+          }
+        end
+      end
+
+      return if records.empty?
+
+      uri = URI.parse("#{@config.endpoint.chomp("/")}/api/v1/http_calls/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({ http_calls: records })
+
+      http.request(request)
+    rescue StandardError
+      # Silently discard network errors
+    end
+  end
+end

data/lib/bugwatch/http_tracker.rb

@@ -0,0 +1,101 @@
+require "net/http"
+
+module Bugwatch
+  module HttpTracker
+    THREAD_KEY = :bugwatch_http_tracker
+
+    CALLER_FILTER = %r{/(bugwatch|ruby/gems)/}
+
+    module NetHttpPatch
+      def request(req, body = nil, &block)
+        return super if Thread.current[:bugwatch_skip_tracking]
+        return super unless HttpTracker.collecting?
+
+        start    = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        response = super
+        duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round(2)
+
+        HttpTracker.handle_call(self, req, response, duration_ms)
+        response
+      rescue Exception # rubocop:disable Lint/RescueException
+        raise
+      end
+    end
+
+    module_function
+
+    def subscribe!
+      return if Net::HTTP.ancestors.include?(NetHttpPatch)
+
+      Net::HTTP.prepend(NetHttpPatch)
+    end
+
+    def start_request(collecting:)
+      Thread.current[THREAD_KEY] = {
+        calls:      [],
+        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 collecting?
+      state = Thread.current[THREAD_KEY]
+      state && state[:collecting]
+    end
+
+    def handle_call(http, req, response, duration_ms)
+      state = Thread.current[THREAD_KEY]
+      return unless state
+      return unless state[:collecting]
+
+      config = Bugwatch.configuration
+      return if state[:calls].size >= config.max_http_calls_per_request
+
+      state[:calls] << {
+        host:            http.address,
+        port:            http.port,
+        method:          req.method,
+        path:            extract_path(req.path),
+        status_code:     response.code.to_i,
+        duration_ms:     duration_ms,
+        library:         detect_library,
+        caller_location: extract_caller
+      }
+    rescue StandardError
+      # Never let tracking break the app
+    end
+
+    def extract_path(full_path)
+      full_path.to_s.split("?").first
+    end
+
+    def detect_library
+      caller_locations(4, 20)&.each do |loc|
+        path = loc.path.to_s
+        return "faraday"  if path.include?("faraday")
+        return "httparty" if path.include?("httparty")
+      end
+      "net_http"
+    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_call, :extract_path, :detect_library, :extract_caller
+  end
+end

data/lib/bugwatch/middleware.rb

@@ -12,11 +12,15 @@ module Bugwatch
       start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       BreadcrumbCollector.clear
       UserContext.clear
+      ReportedExceptions.clear
 
       config = Bugwatch.configuration
       collecting = config.enable_db_tracking && (rand < config.db_sample_rate)
       DbTracker.start_request(collecting: collecting)
 
+      collecting_http = config.enable_http_tracking && (rand < config.http_sample_rate)
+      HttpTracker.start_request(collecting: collecting_http)
+
       begin
         status, headers, body = @app.call(env)
         record_transaction(env, status, start)
@@ -24,16 +28,22 @@ module Bugwatch
       rescue Exception => e # rubocop:disable Lint/RescueException
         duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round
 
-        unless Bugwatch.configuration.ignore?(e)
-          payload = ErrorBuilder.new(e, env).build
-          payload[:duration_ms] = duration_ms
-          Notification.new(payload).deliver
+        begin
+          if !Bugwatch.configuration.ignore?(e) && !ReportedExceptions.reported?(e)
+            payload = ErrorBuilder.new(e, env).build
+            payload[:duration_ms] = duration_ms
+            Notification.new(payload).deliver
+            ReportedExceptions.mark(e)
+          end
+        rescue StandardError
+          # Never let reporting failures drop the original exception
         end
 
         record_transaction(env, 500, start)
         raise
       ensure
         DbTracker.clear
+        HttpTracker.clear
       end
     end
 
@@ -74,6 +84,16 @@ module Bugwatch
           queries:          db_result[:queries]
         })
       end
+
+      http_result = HttpTracker.finish_request
+      if http_result && http_result[:calls].any?
+        Bugwatch.http_call_buffer.push({
+          transaction_name: payload[:name],
+          environment:      config.release_stage,
+          occurred_at:      payload[:occurred_at],
+          calls:            http_result[:calls]
+        })
+      end
     rescue StandardError
       # Never let tracking break the app
     end

data/lib/bugwatch/railtie.rb

@@ -31,11 +31,21 @@ module Bugwatch
       end
     end
 
+    initializer "bugwatch.http_tracking" do
+      Bugwatch::HttpTracker.subscribe! if Bugwatch.configuration.enable_http_tracking
+    end
+
     initializer "bugwatch.error_subscriber" do
       if defined?(Rails.error) && Rails.error.respond_to?(:subscribe)
         Rails.error.subscribe(Bugwatch::ErrorSubscriber.new)
       end
     end
+
+    initializer "bugwatch.controller_rescue_hook" do
+      ActiveSupport.on_load(:action_controller) do
+        prepend Bugwatch::ControllerRescueHook
+      end
+    end
   end
 
   module ControllerMethods

data/lib/bugwatch/reported_exceptions.rb

@@ -0,0 +1,19 @@
+module Bugwatch
+  module ReportedExceptions
+    THREAD_KEY = :bugwatch_reported_exceptions
+
+    def self.mark(exception)
+      return unless exception
+      (Thread.current[THREAD_KEY] ||= []) << exception.object_id
+    end
+
+    def self.reported?(exception)
+      return false unless exception
+      (Thread.current[THREAD_KEY] || []).include?(exception.object_id)
+    end
+
+    def self.clear
+      Thread.current[THREAD_KEY] = nil
+    end
+  end
+end

data/lib/bugwatch/version.rb

@@ -1,3 +1,3 @@
 module Bugwatch
-  VERSION = "0.7.1"
+  VERSION = "0.8.1"
 end

data/lib/bugwatch.rb

@@ -6,6 +6,7 @@ require_relative "bugwatch/configuration"
 require_relative "bugwatch/user_context"
 require_relative "bugwatch/breadcrumb_collector"
 require_relative "bugwatch/backtrace_cleaner"
+require_relative "bugwatch/reported_exceptions"
 require_relative "bugwatch/error_builder"
 require_relative "bugwatch/report_builder"
 require_relative "bugwatch/notification"
@@ -14,11 +15,15 @@ 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/http_tracker"
+require_relative "bugwatch/http_call_sender"
+require_relative "bugwatch/http_call_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"
+require_relative "bugwatch/controller_rescue_hook"
 require_relative "bugwatch/railtie" if defined?(Rails::Railtie)
 
 module Bugwatch
@@ -34,10 +39,12 @@ module Bugwatch
     def notify(exception, context: {})
       return if configuration.ignore?(exception)
       return unless configuration.notify_for_release_stage?
+      return if ReportedExceptions.reported?(exception)
 
       payload = ErrorBuilder.new(exception).build
       payload.merge!(context)
       Notification.new(payload).deliver
+      ReportedExceptions.mark(exception)
     end
 
     def report(title, category: "other", severity: "warning", tags: {})
@@ -138,10 +145,15 @@ module Bugwatch
     def db_query_buffer
       @db_query_buffer ||= DbQueryBuffer.new(config: configuration)
     end
+
+    def http_call_buffer
+      @http_call_buffer ||= HttpCallBuffer.new(config: configuration)
+    end
   end
 end
 
 at_exit do
   Bugwatch.transaction_buffer.shutdown rescue nil
-  Bugwatch.db_query_buffer.shutdown rescue nil
+  Bugwatch.db_query_buffer.shutdown    rescue nil
+  Bugwatch.http_call_buffer.shutdown   rescue nil
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: bugwatch-ruby
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.1
 platform: ruby
 authors:
 - BugWatch
 bindir: bin
 cert_chain: []
-date: 2026-04-14 00:00:00.000000000 Z
+date: 2026-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -52,6 +52,7 @@ files:
 - lib/bugwatch/backtrace_cleaner.rb
 - lib/bugwatch/breadcrumb_collector.rb
 - lib/bugwatch/configuration.rb
+- lib/bugwatch/controller_rescue_hook.rb
 - lib/bugwatch/db_query_buffer.rb
 - lib/bugwatch/db_query_sender.rb
 - lib/bugwatch/db_tracker.rb
@@ -59,10 +60,14 @@ files:
 - lib/bugwatch/error_subscriber.rb
 - lib/bugwatch/feedback_helper.rb
 - lib/bugwatch/feedback_sender.rb
+- lib/bugwatch/http_call_buffer.rb
+- lib/bugwatch/http_call_sender.rb
+- lib/bugwatch/http_tracker.rb
 - lib/bugwatch/middleware.rb
 - lib/bugwatch/notification.rb
 - lib/bugwatch/railtie.rb
 - lib/bugwatch/report_builder.rb
+- lib/bugwatch/reported_exceptions.rb
 - lib/bugwatch/transaction_buffer.rb
 - lib/bugwatch/transaction_sender.rb
 - lib/bugwatch/user_context.rb