bloop-sdk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5596c4ce2d5c135c37489bc42e8f5198e08747db4d2f042b4b0d92c4da922505
+  data.tar.gz: 83611d60a780e9b16d67b43199998984a5673174ea08b79d29b20962a29d7859
+SHA512:
+  metadata.gz: f16a1f358c7fd2406156c4a771b252fa186eb65cedfbf4dc5184aed896f7923805c119c5f317a914d9a0ca45d9b2f1cd1510a478bf08ef54f70132e03db1ebad
+  data.tar.gz: 933331f141544fa8f041e883094624cae9d9dbdbfcde3f1efbeb29d5e3e9056330e33f9bb4c8b31fe5a43dcc20c18b6fd64a4e14c45dc7c063451b0ee4fe4658

data/lib/bloop.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "net/http"
+require "json"
+require "uri"
+
+module Bloop
+  VERSION = "0.1.0"
+
+  class Client
+    attr_reader :endpoint, :project_key
+
+    # @param endpoint [String] Bloop server URL
+    # @param project_key [String] Project API key for HMAC signing
+    # @param environment [String] Environment tag (default: "production")
+    # @param release [String] Release version tag
+    # @param flush_interval [Numeric] Seconds between auto-flushes (default: 5)
+    # @param max_buffer_size [Integer] Flush when buffer reaches this size (default: 100)
+    def initialize(endpoint:, project_key:, environment: "production", release: "", flush_interval: 5, max_buffer_size: 100)
+      @endpoint = endpoint.chomp("/")
+      @project_key = project_key
+      @environment = environment
+      @release = release
+      @flush_interval = flush_interval
+      @max_buffer_size = max_buffer_size
+
+      @buffer = []
+      @mutex = Mutex.new
+      @closed = false
+
+      start_flush_thread
+      install_at_exit
+    end
+
+    # Capture an error event.
+    #
+    # @param error_type [String] The error class name
+    # @param message [String] Human-readable error message
+    # @param source [String] Source platform (default: "ruby")
+    # @param stack [String] Stack trace
+    # @param route_or_procedure [String] Route or method
+    # @param screen [String] Screen name (mobile)
+    # @param metadata [Hash] Arbitrary metadata
+    def capture(error_type:, message:, source: "ruby", stack: "", route_or_procedure: "", screen: "", metadata: nil, **kwargs)
+      return if @closed
+
+      event = {
+        timestamp: (Time.now.to_f * 1000).to_i,
+        source: source,
+        environment: @environment,
+        error_type: error_type,
+        message: message,
+      }
+      event[:release] = @release unless @release.empty?
+      event[:stack] = stack unless stack.empty?
+      event[:route_or_procedure] = route_or_procedure unless route_or_procedure.empty?
+      event[:screen] = screen unless screen.empty?
+      event[:metadata] = metadata if metadata
+
+      kwargs.each { |k, v| event[k] = v unless event.key?(k) }
+
+      @mutex.synchronize do
+        @buffer << event
+        flush_locked if @buffer.size >= @max_buffer_size
+      end
+    end
+
+    # Capture a Ruby exception.
+    #
+    # @param exception [Exception] The exception to capture
+    def capture_exception(exception, **kwargs)
+      capture(
+        error_type: exception.class.name,
+        message: exception.message,
+        stack: (exception.backtrace || []).join("\n"),
+        **kwargs
+      )
+    end
+
+    # Flush buffered events immediately.
+    def flush
+      @mutex.synchronize { flush_locked }
+    end
+
+    # Flush and stop the background thread.
+    def close
+      @closed = true
+      flush
+      @flush_thread&.kill
+    end
+
+    private
+
+    def flush_locked
+      return if @buffer.empty?
+
+      events = @buffer.dup
+      @buffer.clear
+
+      Thread.new { send_events(events) }
+    end
+
+    def send_events(events)
+      if events.size == 1
+        path = "/v1/ingest"
+        body = JSON.generate(events.first)
+      else
+        path = "/v1/ingest/batch"
+        body = JSON.generate({ events: events })
+      end
+
+      signature = OpenSSL::HMAC.hexdigest("SHA256", @project_key, body)
+
+      uri = URI("#{@endpoint}#{path}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.open_timeout = 5
+      http.read_timeout = 10
+
+      req = Net::HTTP::Post.new(uri.path)
+      req["Content-Type"] = "application/json"
+      req["X-Signature"] = signature
+      req["X-Project-Key"] = @project_key
+      req.body = body
+
+      http.request(req)
+    rescue StandardError
+      # Fire and forget — don't crash the host app
+    end
+
+    def start_flush_thread
+      @flush_thread = Thread.new do
+        loop do
+          sleep @flush_interval
+          flush unless @closed
+        rescue StandardError
+          # Ignore flush errors
+        end
+      end
+      @flush_thread.abort_on_exception = false
+    end
+
+    def install_at_exit
+      client = self
+      at_exit { client.close }
+    end
+  end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: bloop-sdk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- bloop
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-02-13 00:00:00.000000000 Z
+dependencies: []
+description: Capture and send error events to a bloop server. Zero external dependencies.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bloop.rb
+homepage: https://github.com/your-org/bloop
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/your-org/bloop
+  source_code_uri: https://github.com/your-org/bloop/tree/main/sdks/ruby
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Ruby SDK for bloop error observability
+test_files: []