bugwatch-ruby 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d6a47f1c5176ec17f87160b5ab4a273e6ef68e76dee98f6e60ee5da474a61fd
-  data.tar.gz: 713ab0b06839f57c473a98c8f3e1cd46f2f43b2c9ccfef2b18d7ba0e3abb1076
+  metadata.gz: c2096369bb2864dc1713e2998bc6438302122dc3237194c4f12349094d4b046e
+  data.tar.gz: 472e7299734b4f451401a3d828c3465ac1071fb1cd8a1bfba49edebd66db06dc
 SHA512:
-  metadata.gz: cb255c2fcfe9562b06320de183bc1ee141f394eacb327eb6ad71739a662aaeb435f5da3248404a7074b45e6a397612d86fe8d243918284196cb7e3892c193f8a
-  data.tar.gz: 9ce11bcc466b319298cb788f51cdb1c89f00f6b3126189d02c9a7838eeb6f087291bb0864bc5115734849a1af966f2995385a627a057befbf815c63354e122ee
+  metadata.gz: 013ae4e4faa1dba3cc77ccc7dc9a81646025aaeb30cd9b835e512ee0d47bc3cfd58f44c47f9516e2272ec352e912470163d8dee0d394e490001f37d58c6df1c2
+  data.tar.gz: 38f4a61e9b51617b4095b3ee6d8320453ec4de615c6a76aa8c13303a2ef9a22cd8c4cde377b261ef447040a9ede948e4e4b462d15ce91019b34ca8ecaef46aaa

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/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

@@ -5,7 +5,9 @@ module Bugwatch
     end
 
     def call(env)
-      return @app.call(env) if Bugwatch.skip_tracking?
+      if Bugwatch.skip_tracking? || skip_path?(env)
+        return @app.call(env)
+      end
 
       start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       BreadcrumbCollector.clear
@@ -15,6 +17,9 @@ module Bugwatch
       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)
@@ -32,11 +37,17 @@ module Bugwatch
         raise
       ensure
         DbTracker.clear
+        HttpTracker.clear
       end
     end
 
     private
 
+    def skip_path?(env)
+      path = env["PATH_INFO"].to_s
+      Bugwatch.configuration.ignore_request_paths.any? { |pattern| path.match?(pattern) }
+    end
+
     def record_transaction(env, status, start)
       config = Bugwatch.configuration
       req = Rack::Request.new(env)
@@ -67,6 +78,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,6 +31,10 @@ 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)

data/lib/bugwatch/version.rb

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

data/lib/bugwatch.rb

@@ -14,6 +14,9 @@ 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"
@@ -138,10 +141,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.0
+  version: 0.8.0
 platform: ruby
 authors:
 - BugWatch
 bindir: bin
 cert_chain: []
-date: 2026-04-14 00:00:00.000000000 Z
+date: 2026-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -59,6 +59,9 @@ 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