tensorbuzz-api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e6c56342468d420d2953579a8724215a497335b7d574d2efd99853e88e21aae1
+  data.tar.gz: ce6ae673c3562b6fa1119e0ac48f5db086353cbd8268f55ad043581c45133f43
+SHA512:
+  metadata.gz: a7d3a46e7cdde24c0257aaf433235260824e6f15db03a5aa784628b877e5a710160c70bf3b0597e0bf7007f481cb8f740e666763ca4fb48e275e08b95974534b
+  data.tar.gz: 253e6d374148290d16534380b8878e39fe12846bec9207bf5b3afd5fbf8299ce40729e0501b13a6f4513a874bb5c662cade7d99222fc5990c6bd37c404079389

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kasper Stöckel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,55 @@
+# tensorbuzz-api for Ruby
+
+Ruby, Rack, Rails, and Sidekiq error reporting for TensorBuzz.
+
+## Installation
+
+```ruby
+gem "tensorbuzz-api"
+```
+
+## Configuration
+
+```ruby
+require "tensorbuzz/api"
+
+TensorBuzz::BugReporting.configure do |config|
+  config.auth_token = ENV.fetch("TENSORBUZZ_BUG_REPORT_AUTH_TOKEN")
+  config.project_id = ENV.fetch("TENSORBUZZ_BUG_REPORT_PROJECT_ID")
+  config.hostname = ENV["TENSORBUZZ_BUG_REPORT_HOSTNAME"]
+  config.environment = ENV.fetch("RAILS_ENV", "production")
+  config.release = ENV["APP_RELEASE"]
+  config.logger = Rails.logger
+end
+```
+
+The default endpoint is `https://server.tensorbuzz.com/errors/reports`. Set
+`config.post_url` when using another TensorBuzz installation.
+
+## Reporting
+
+```ruby
+TensorBuzz::BugReporting.report(error, parameters: {order_id: order.id})
+TensorBuzz::BugReporting.report_message("Payment session creation failed")
+
+TensorBuzz::BugReporting.with_parameters(user_id: user.id) do
+  perform_work
+end
+```
+
+Scoped parameters are attached to exceptions that leave the block, allowing a
+later Rails or Sidekiq handler to report the original context.
+
+## Rails and Sidekiq
+
+```ruby
+require "tensorbuzz/api/rails"
+require "tensorbuzz/api/sidekiq"
+
+TensorBuzz::Api::Rails.configure
+TensorBuzz::Api::Sidekiq.configure
+```
+
+The Rack middleware reports uncaught request errors and re-raises the original
+exception. The Sidekiq integration uses Sidekiq's error-handler API. Reporting
+failures are logged and never replace the application exception.

data/lib/tensorbuzz/api/bug_reporting.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'socket'
+
+module TensorBuzz
+  module Api
+    class BugReporting
+      CAPTURED_PARAMETERS_VARIABLE = :@tensorbuzz_captured_parameters
+      CONTEXT_KEY = :tensorbuzz_bug_reporting_context
+
+      class << self
+        attr_reader :current
+
+        def configure
+          configuration = Configuration.new
+          yield configuration
+          configuration.validate!
+          @current = new(configuration)
+        end
+
+        def report(error, **options)
+          current&.report(error, **options)
+        end
+
+        def report_message(message, **options)
+          report(RuntimeError.new(message), **options)
+        end
+
+        def safely_report(error, **options)
+          report(error, **options)
+        rescue StandardError => e
+          current&.log_reporting_error(e)
+          nil
+        end
+
+        def with_parameters(parameters)
+          return yield unless current
+
+          context_id = SecureRandom.hex(16)
+          context[context_id] = parameters
+          yield
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          current&.capture_parameters_for_error(e)
+          raise
+        ensure
+          context.delete(context_id) if context_id
+        end
+
+        def reset!
+          @current = nil
+          Thread.current[CONTEXT_KEY] = nil
+        end
+
+        def context
+          Thread.current[CONTEXT_KEY] ||= {}
+        end
+      end
+
+      def initialize(configuration, transport: Transport.new(configuration))
+        @configuration = configuration
+        @transport = transport
+      end
+
+      def report(error, environment: nil, http_method: nil, parameters: nil, remote_ip: nil,
+                 request_body: nil, url: nil, user_agent: nil)
+        normalized_error = normalize_error(error)
+        stack_trace = Array(normalized_error.backtrace)
+        file_path, line_number = location_from(stack_trace)
+        merged_environment = compact_hash(
+          application_environment: configuration.environment,
+          release: configuration.release
+        ).merge(environment || {})
+        payload = {
+          authToken: configuration.auth_token,
+          projectId: configuration.project_id,
+          hostname: configuration.hostname || Socket.gethostname,
+          runtimeEnvironment: 'ruby',
+          error: {
+            backtrace: stack_trace,
+            environment: Sanitizer.call(merged_environment),
+            error_class: normalized_error.class.name,
+            file_path:,
+            http_method:,
+            line_number:,
+            message: normalized_error.message,
+            parameters: Sanitizer.call(merged_parameters(normalized_error, parameters)),
+            remote_ip:,
+            request_body: Sanitizer.call(request_body),
+            url:,
+            user_agent:
+          }.compact
+        }
+        response = transport.post(payload)
+
+        Response.new(
+          bug_report_id: response['bugReportId'],
+          bug_report_instance_id: response['bugReportInstanceId'],
+          project_id: response['projectId'],
+          project_slug: response['projectSlug'],
+          url: response['url']
+        )
+      end
+
+      def capture_parameters_for_error(error)
+        return if error.instance_variable_defined?(CAPTURED_PARAMETERS_VARIABLE)
+
+        error.instance_variable_set(CAPTURED_PARAMETERS_VARIABLE, merged_parameters(error, nil))
+      end
+
+      def log_reporting_error(error)
+        logger = configuration.logger
+        message = "TensorBuzz reporting failed: #{error.class}: #{error.message}"
+
+        if logger
+          logger.error(message)
+        else
+          warn(message)
+        end
+      end
+
+      private
+
+      attr_reader :configuration, :transport
+
+      def compact_hash(**values)
+        values.compact
+      end
+
+      def deep_merge(left, right)
+        left.merge(right) do |_key, left_value, right_value|
+          if left_value.is_a?(Hash) && right_value.is_a?(Hash)
+            deep_merge(left_value, right_value)
+          else
+            right_value
+          end
+        end
+      end
+
+      def location_from(backtrace)
+        backtrace.each do |line|
+          match = line.match(/\A(.+?):(\d+)(?::|\z)/)
+          return [match[1], match[2].to_i] if match
+        end
+
+        [nil, nil]
+      end
+
+      def merged_parameters(error, parameters)
+        values = self.class.context.values
+        if error.instance_variable_defined?(CAPTURED_PARAMETERS_VARIABLE)
+          captured = error.instance_variable_get(CAPTURED_PARAMETERS_VARIABLE)
+        end
+        values << captured if captured
+        values << parameters if parameters
+        values.compact.reduce({}) { |result, value| deep_merge(result, value) }
+      end
+
+      def normalize_error(error)
+        normalized_error = error.is_a?(Exception) ? error : RuntimeError.new(error.to_s)
+        normalized_error.set_backtrace(caller(2)) if normalized_error.backtrace.nil? || normalized_error.backtrace.empty?
+        normalized_error
+      end
+    end
+  end
+end

data/lib/tensorbuzz/api/configuration.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TensorBuzz
+  module Api
+    class Configuration
+      attr_accessor :auth_token, :environment, :hostname, :logger, :open_timeout,
+                    :post_url, :project_id, :read_timeout, :release
+
+      def initialize
+        @open_timeout = 2
+        @post_url = 'https://server.tensorbuzz.com/errors/reports'
+        @read_timeout = 5
+      end
+
+      def validate!
+        raise ArgumentError, 'TensorBuzz auth_token is required' if auth_token.to_s.empty?
+        raise ArgumentError, 'TensorBuzz project_id is required' if project_id.to_s.empty?
+      end
+    end
+  end
+end

data/lib/tensorbuzz/api/rack_middleware.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'rack'
+require 'rack/request'
+require 'json'
+
+module TensorBuzz
+  module Api
+    class RackMiddleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(environment)
+        app.call(environment)
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        safely_report(e, environment)
+        raise
+      end
+
+      private
+
+      attr_reader :app
+
+      def safely_report(error, environment)
+        request = Rack::Request.new(environment)
+        BugReporting.safely_report(
+          error,
+          environment: rack_environment(environment),
+          http_method: request.request_method,
+          parameters: { query: request.GET },
+          remote_ip: request.ip,
+          request_body: parsed_request_body(request),
+          url: request.url,
+          user_agent: request.user_agent
+        )
+      rescue StandardError => e
+        BugReporting.current&.log_reporting_error(e)
+        BugReporting.safely_report(error)
+      end
+
+      def parsed_request_body(request)
+        return request.POST unless request.media_type == 'application/json'
+
+        body = request.body.read
+        request.body.rewind
+        JSON.parse(body)
+      rescue StandardError
+        nil
+      end
+
+      def rack_environment(environment)
+        environment.each_with_object({}) do |(key, value), result|
+          result[key] = value if key.start_with?('SERVER_', 'HTTP_') && value.is_a?(String)
+        end
+      end
+    end
+  end
+end

data/lib/tensorbuzz/api/rails.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'tensorbuzz/api/rack_middleware'
+
+module TensorBuzz
+  module Api
+    module Rails
+      def self.configure
+        ::Rails.application.config.middleware.use RackMiddleware
+      end
+    end
+  end
+end

data/lib/tensorbuzz/api/response.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module TensorBuzz
+  module Api
+    Response = Data.define(:bug_report_id, :bug_report_instance_id, :project_id, :project_slug, :url)
+  end
+end

data/lib/tensorbuzz/api/sanitizer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module TensorBuzz
+  module Api
+    class Sanitizer
+      MAX_ARRAY_LENGTH = 100
+      MAX_DEPTH = 8
+      MAX_HASH_KEYS = 100
+      MAX_STRING_LENGTH = 4_000
+      SENSITIVE_KEY = /(authorization|cookie|password|secret|session|token)/i
+
+      def self.call(value, depth: 0, key: nil)
+        return '[redacted]' if key.to_s.match?(SENSITIVE_KEY)
+        return '[maximum depth reached]' if depth >= MAX_DEPTH
+
+        case value
+        when Array
+          value.first(MAX_ARRAY_LENGTH).map { |item| call(item, depth: depth + 1) }
+        when Hash
+          value.first(MAX_HASH_KEYS).to_h do |child_key, child_value|
+            [child_key.to_s, call(child_value, depth: depth + 1, key: child_key)]
+          end
+        when String
+          truncate(value)
+        when Numeric, TrueClass, FalseClass, NilClass
+          value
+        else
+          truncate(value.to_s)
+        end
+      end
+
+      def self.truncate(value)
+        return value if value.length <= MAX_STRING_LENGTH
+
+        "#{value[0, MAX_STRING_LENGTH]}[truncated #{value.length - MAX_STRING_LENGTH} characters]"
+      end
+
+      private_class_method :truncate
+    end
+  end
+end

data/lib/tensorbuzz/api/sidekiq.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module TensorBuzz
+  module Api
+    module Sidekiq
+      def self.configure
+        require 'sidekiq'
+
+        ::Sidekiq.configure_server do |config|
+          config.error_handlers << proc do |error, context, _configuration = nil|
+            BugReporting.safely_report(error, parameters: { sidekiq: context })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tensorbuzz/api/transport.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+module TensorBuzz
+  module Api
+    class ReportingError < StandardError; end
+
+    class Transport
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def post(payload)
+        uri = URI(configuration.post_url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.open_timeout = configuration.open_timeout
+        http.read_timeout = configuration.read_timeout
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request['Content-Type'] = 'application/json'
+        request.body = JSON.generate(payload)
+        response = http.request(request)
+
+        raise ReportingError, "TensorBuzz rejected the report with HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body)
+      rescue JSON::ParserError => e
+        raise ReportingError, "TensorBuzz returned invalid JSON: #{e.message}"
+      rescue ReportingError
+        raise
+      rescue StandardError => e
+        raise ReportingError, "Could not report to TensorBuzz: #{e.message}"
+      end
+
+      private
+
+      attr_reader :configuration
+    end
+  end
+end

data/lib/tensorbuzz/api/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module TensorBuzz
+  module Api
+    VERSION = '0.1.0'
+  end
+end

data/lib/tensorbuzz/api.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'tensorbuzz/api/version'
+require 'tensorbuzz/api/configuration'
+require 'tensorbuzz/api/response'
+require 'tensorbuzz/api/sanitizer'
+require 'tensorbuzz/api/transport'
+require 'tensorbuzz/api/bug_reporting'
+
+module TensorBuzz
+  BugReporting = Api::BugReporting
+  ReportingError = Api::ReportingError
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: tensorbuzz-api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kasper Stöckel
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Reports Ruby, Rack, Rails, and Sidekiq errors to TensorBuzz.
+email:
+- k@spernj.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/tensorbuzz/api.rb
+- lib/tensorbuzz/api/bug_reporting.rb
+- lib/tensorbuzz/api/configuration.rb
+- lib/tensorbuzz/api/rack_middleware.rb
+- lib/tensorbuzz/api/rails.rb
+- lib/tensorbuzz/api/response.rb
+- lib/tensorbuzz/api/sanitizer.rb
+- lib/tensorbuzz/api/sidekiq.rb
+- lib/tensorbuzz/api/transport.rb
+- lib/tensorbuzz/api/version.rb
+homepage: https://github.com/kaspernj/tensorbuzz
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/kaspernj/tensorbuzz/tree/master/tensorbuzz-api-ruby
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Ruby client for TensorBuzz bug reporting.
+test_files: []