bloop-sdk 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1764f66fe2c239ea3e9d45a71ac8f8102a9156d15c3059c166bac8a21e94c1cf
-  data.tar.gz: 69f5b714a508254bf6e63523edbdfb639f0bf771bb983b3ab11015f9f96729b8
+  metadata.gz: b3b81ab4b7b39d4506aea43446dcbe3edd0dc5a0e6a48cfcfc43f7099d431de8
+  data.tar.gz: 97a70ca0526d687aee37a1521adf3c9c4b219e861d1bd2d77dd3b120c8ef332a
 SHA512:
-  metadata.gz: 7d94fbd7aa25b6d80b40d6b9caa611af131c82343482d7d2cab19293537a29482863b6bdb2a0c9c6ed4930570d7e599b5e1fe7ac381a544b783af1753b353647
-  data.tar.gz: e3937e140ffd35c5d7522728a29c7850663c65dcdac91084dcc54f074a4883ed73aa3533567d72df2fb6553a6d97ee1b1388f04be5cb3d8a8a99e6a6b1ed5889
+  metadata.gz: 7c30b8bd8af65b7e6863a6b00e45e101930a44deaf7b5de5828dd7ae963f150ed6886bab600e3eb229be08633a053004621b52df45db1974701dc099d6e4ddf2
+  data.tar.gz: 1d1dabab850bb3302a23ffd05eb6c519a6d400fc00c9b4b15c0eb635a933bb38a5fae1c7e2b5354f9391bdfe8b3880e83acc6c05778f29bcc13a2f7a1cd46c0b

data/lib/bloop/client.rb

@@ -0,0 +1,362 @@
+# frozen_string_literal: true
+
+# Bloop error reporting and LLM tracing client for Ruby.
+#
+# Zero external runtime dependencies -- uses only Ruby stdlib.
+
+require "json"
+require "net/http"
+require "openssl"
+require "securerandom"
+require "uri"
+
+module Bloop
+  # Captures and sends error events and LLM traces to a bloop server.
+  #
+  # Usage:
+  #   client = Bloop::Client.new(endpoint: "https://bloop.example.com", project_key: "your-key")
+  #   client.capture(error_type: "TypeError", message: "something went wrong")
+  #   client.close
+  #
+  class Client
+    attr_reader :endpoint, :project_key, :environment, :release
+
+    def initialize(
+      endpoint:,
+      project_key:,
+      flush_interval: 5.0,
+      max_buffer_size: 100,
+      environment: "production",
+      release: ""
+    )
+      @endpoint = endpoint.chomp("/")
+      @project_key = project_key
+      @flush_interval = flush_interval
+      @max_buffer_size = max_buffer_size
+      @environment = environment
+      @release = release
+
+      @buffer = []
+      @trace_buffer = []
+      @lock = Mutex.new
+      @closed = false
+
+      _schedule_flush
+    end
+
+    # -- Error Tracking --
+
+    def capture(
+      error_type:,
+      message:,
+      source: "ruby",
+      stack: "",
+      route_or_procedure: "",
+      screen: "",
+      metadata: nil
+    )
+      event = {
+        "timestamp" => Time.now.to_i,
+        "source" => source,
+        "environment" => @environment,
+        "release" => @release,
+        "error_type" => error_type,
+        "message" => message,
+        "stack" => stack,
+        "route_or_procedure" => route_or_procedure,
+        "screen" => screen,
+        "metadata" => metadata || {},
+      }
+
+      @lock.synchronize do
+        @buffer << event
+        _flush_locked if @buffer.size >= @max_buffer_size
+      end
+    end
+
+    # -- LLM Tracing --
+
+    # Create a new LLM trace.
+    #
+    #   trace = client.trace(name: "chat")
+    #   span = trace.span(model: "gpt-4o")
+    #   span.set_tokens(100, 50)
+    #   span.end
+    #   trace.end
+    #
+    def trace(name: "", trace_id: nil, session_id: nil, user_id: nil, prompt_name: nil, prompt_version: nil)
+      Trace.new(
+        client: self,
+        name: name,
+        trace_id: trace_id || SecureRandom.uuid.delete("-"),
+        session_id: session_id,
+        user_id: user_id,
+        prompt_name: prompt_name,
+        prompt_version: prompt_version,
+      )
+    end
+
+    # Buffer a completed trace for batch sending.
+    def _send_trace(trace_data)
+      @lock.synchronize do
+        @trace_buffer << trace_data
+        _flush_traces_locked if @trace_buffer.size >= 10
+      end
+    end
+
+    # -- Auto-Instrumentation --
+
+    # Wrap an OpenAI-compatible client for automatic LLM tracing.
+    #
+    # Works with the ruby-openai gem. Returns a wrapped client that
+    # auto-traces all chat() calls.
+    #
+    #   require "openai"
+    #   openai = client.wrap_openai(OpenAI::Client.new(access_token: "..."))
+    #   response = openai.chat(parameters: { model: "gpt-4o", messages: [...] })
+    #
+    def wrap_openai(openai_client)
+      Integrations::OpenAI.wrap(openai_client, self)
+    end
+
+    # Wrap an Anthropic client for automatic LLM tracing.
+    #
+    # Works with the anthropic gem. Returns a wrapped client that
+    # auto-traces all messages() calls.
+    #
+    #   require "anthropic"
+    #   anthropic = client.wrap_anthropic(Anthropic::Client.new(api_key: "..."))
+    #   response = anthropic.messages(parameters: { model: "claude-3-5-sonnet", messages: [...] })
+    #
+    def wrap_anthropic(anthropic_client)
+      Integrations::Anthropic.wrap(anthropic_client, self)
+    end
+
+    # -- Flush & Transport --
+
+    # Send all buffered events and traces immediately.
+    def flush
+      @lock.synchronize do
+        _flush_locked
+        _flush_traces_locked
+      end
+    end
+
+    # Flush remaining events and stop the background timer.
+    def close
+      @closed = true
+      @timer&.kill
+      flush
+    end
+
+    private
+
+    def _flush_locked
+      return if @buffer.empty?
+
+      events = @buffer.dup
+      @buffer.clear
+      _send_events(events)
+    end
+
+    def _flush_traces_locked
+      return if @trace_buffer.empty?
+
+      traces = @trace_buffer.dup
+      @trace_buffer.clear
+      Thread.new { _send_traces_batch(traces) }
+    end
+
+    def _send_events(events)
+      if events.size == 1
+        _post("/v1/ingest", events[0])
+      else
+        _post("/v1/ingest/batch", { "events" => events })
+      end
+    end
+
+    def _send_traces_batch(traces)
+      _post("/v1/traces/batch", { "traces" => traces })
+    rescue StandardError
+      # Fire-and-forget for trace telemetry
+    end
+
+    def _post(path, payload)
+      body = JSON.generate(payload)
+      sig = _sign(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 = 5
+
+      request = Net::HTTP::Post.new(uri.path)
+      request["Content-Type"] = "application/json"
+      request["X-Signature"] = sig
+      request.body = body
+
+      http.request(request)
+    rescue StandardError
+      # Silently drop on failure (never crash the app)
+    end
+
+    def _sign(body)
+      OpenSSL::HMAC.hexdigest("SHA256", @project_key, body)
+    end
+
+    def _schedule_flush
+      return if @closed
+
+      @timer = Thread.new do
+        loop do
+          sleep @flush_interval
+          break if @closed
+
+          flush
+        end
+      end
+      @timer.abort_on_exception = false
+    end
+  end
+
+  # Represents an LLM trace with spans.
+  class Trace
+    attr_accessor :id, :name, :status, :session_id, :user_id,
+                  :input, :output, :metadata, :prompt_name, :prompt_version
+
+    def initialize(client:, name:, trace_id:, session_id: nil, user_id: nil, prompt_name: nil, prompt_version: nil)
+      @client = client
+      @id = trace_id
+      @name = name
+      @session_id = session_id
+      @user_id = user_id
+      @prompt_name = prompt_name
+      @prompt_version = prompt_version
+      @status = "completed"
+      @input = nil
+      @output = nil
+      @metadata = nil
+      @spans = []
+      @started_at = (Time.now.to_f * 1000).to_i
+      @ended_at = nil
+    end
+
+    # Create a new span within this trace.
+    def span(span_type: "generation", name: "", model: nil, provider: nil, parent_span_id: nil)
+      Span.new(
+        trace: self,
+        span_type: span_type,
+        name: name,
+        model: model,
+        provider: provider,
+        parent_span_id: parent_span_id,
+      )
+    end
+
+    # Add serialized span data to this trace (internal).
+    def _add_span(span_data)
+      @spans << span_data
+    end
+
+    # End the trace and send it to bloop.
+    def end
+      @ended_at = (Time.now.to_f * 1000).to_i
+
+      trace_data = {
+        "id" => @id,
+        "name" => @name,
+        "status" => @status,
+        "started_at" => @started_at,
+        "ended_at" => @ended_at,
+        "spans" => @spans,
+      }
+      trace_data["session_id"] = @session_id if @session_id
+      trace_data["user_id"] = @user_id if @user_id
+      trace_data["input"] = @input unless @input.nil?
+      trace_data["output"] = @output unless @output.nil?
+      trace_data["metadata"] = @metadata unless @metadata.nil?
+      trace_data["prompt_name"] = @prompt_name unless @prompt_name.nil?
+      trace_data["prompt_version"] = @prompt_version unless @prompt_version.nil?
+
+      @client._send_trace(trace_data)
+    end
+  end
+
+  # Represents a single LLM call span.
+  class Span
+    attr_accessor :id, :span_type, :name, :model, :provider, :parent_span_id,
+                  :input_tokens, :output_tokens, :cost, :latency_ms,
+                  :time_to_first_token_ms, :status, :error_message,
+                  :input, :output, :metadata
+
+    def initialize(trace:, span_type: "generation", name: "", model: nil, provider: nil, parent_span_id: nil)
+      @trace = trace
+      @id = SecureRandom.uuid.delete("-")
+      @span_type = span_type
+      @name = name
+      @model = model
+      @provider = provider
+      @parent_span_id = parent_span_id
+      @input_tokens = 0
+      @output_tokens = 0
+      @cost = 0.0
+      @latency_ms = 0
+      @time_to_first_token_ms = nil
+      @status = "ok"
+      @error_message = nil
+      @input = nil
+      @output = nil
+      @metadata = nil
+      @started_at = (Time.now.to_f * 1000).to_i
+    end
+
+    def set_tokens(input_tokens = 0, output_tokens = 0)
+      @input_tokens = input_tokens
+      @output_tokens = output_tokens
+    end
+
+    def set_cost(cost)
+      @cost = cost
+    end
+
+    def set_latency(latency_ms, time_to_first_token_ms = nil)
+      @latency_ms = latency_ms
+      @time_to_first_token_ms = time_to_first_token_ms
+    end
+
+    def set_error(message)
+      @status = "error"
+      @error_message = message
+    end
+
+    # End the span and add it to the parent trace.
+    def end
+      ended_at = (Time.now.to_f * 1000).to_i
+      @latency_ms = ended_at - @started_at if @latency_ms == 0
+
+      span_data = {
+        "id" => @id,
+        "span_type" => @span_type,
+        "name" => @name,
+        "input_tokens" => @input_tokens,
+        "output_tokens" => @output_tokens,
+        "cost" => @cost,
+        "latency_ms" => @latency_ms,
+        "status" => @status,
+        "started_at" => @started_at,
+        "ended_at" => ended_at,
+      }
+      span_data["model"] = @model if @model
+      span_data["provider"] = @provider if @provider
+      span_data["parent_span_id"] = @parent_span_id if @parent_span_id
+      span_data["time_to_first_token_ms"] = @time_to_first_token_ms unless @time_to_first_token_ms.nil?
+      span_data["error_message"] = @error_message if @error_message
+      span_data["input"] = @input unless @input.nil?
+      span_data["output"] = @output unless @output.nil?
+      span_data["metadata"] = @metadata unless @metadata.nil?
+
+      @trace._add_span(span_data)
+    end
+  end
+end

data/lib/bloop/integrations/anthropic.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+# Anthropic auto-instrumentation for bloop LLM tracing.
+#
+# Wraps the Anthropic Ruby client's client.messages(parameters: { ... }) method
+# to automatically capture: model, tokens, latency, TTFT (streaming), errors.
+# Cost is always 0 -- calculated server-side from pricing table.
+
+require "uri"
+
+module Bloop
+  module Integrations
+    module Anthropic
+      # Detect provider from the client's base URL string.
+      def self.detect_provider(base_url)
+        url = base_url.to_s
+        return "anthropic" if url.include?("anthropic.com")
+
+        host = URI.parse(url).host || "anthropic"
+        host.split(".").first
+      rescue StandardError
+        "anthropic"
+      end
+
+      # Wrap an Anthropic client for automatic LLM tracing.
+      #
+      # The anthropic gem exposes:
+      #   client.messages(parameters: { model: "claude-3-5-sonnet", messages: [...] })
+      #   client.messages(parameters: { model: "...", messages: [...], stream: proc { |event| } })
+      #
+      # Returns the wrapped client (patched in-place).
+      def self.wrap(anthropic_client, bloop_client)
+        base_url = if anthropic_client.respond_to?(:base_url)
+                     anthropic_client.base_url
+                   else
+                     "https://api.anthropic.com"
+                   end
+        provider = detect_provider(base_url)
+
+        original_messages = anthropic_client.method(:messages)
+
+        anthropic_client.define_singleton_method(:messages) do |parameters: {}|
+          model = parameters[:model] || parameters["model"] || "unknown"
+          stream_proc = parameters[:stream] || parameters["stream"]
+          start_ms = (Time.now.to_f * 1000).to_i
+
+          trace = bloop_client.trace(name: "#{provider}/#{model}")
+          span = trace.span(
+            span_type: "generation",
+            name: "messages.create",
+            model: model,
+            provider: provider,
+          )
+
+          if stream_proc
+            # Streaming mode: wrap the user's stream proc
+            first_token_seen = false
+            input_tokens = 0
+            output_tokens = 0
+            actual_model = model
+
+            wrapped_stream = proc do |event|
+              event_type = event.is_a?(Hash) ? (event["type"] || event[:type]) : (event.respond_to?(:type) ? event.type : nil)
+
+              # Track TTFT on first content delta
+              if !first_token_seen && event_type == "content_block_delta"
+                first_token_seen = true
+                ttft = (Time.now.to_f * 1000).to_i - start_ms
+                span.time_to_first_token_ms = ttft
+              end
+
+              # Track usage from message_start
+              if event_type == "message_start"
+                msg = event.is_a?(Hash) ? (event["message"] || event[:message]) : (event.respond_to?(:message) ? event.message : nil)
+                if msg
+                  msg_model = msg.is_a?(Hash) ? (msg["model"] || msg[:model]) : (msg.respond_to?(:model) ? msg.model : nil)
+                  actual_model = msg_model if msg_model
+                  usage = msg.is_a?(Hash) ? (msg["usage"] || msg[:usage]) : (msg.respond_to?(:usage) ? msg.usage : nil)
+                  if usage
+                    input_tokens = if usage.is_a?(Hash)
+                                     usage["input_tokens"] || usage[:input_tokens] || 0
+                                   else
+                                     usage.respond_to?(:input_tokens) ? (usage.input_tokens || 0) : 0
+                                   end
+                  end
+                end
+              end
+
+              # Track output tokens from message_delta
+              if event_type == "message_delta"
+                usage = event.is_a?(Hash) ? (event["usage"] || event[:usage]) : (event.respond_to?(:usage) ? event.usage : nil)
+                if usage
+                  output_tokens = if usage.is_a?(Hash)
+                                    usage["output_tokens"] || usage[:output_tokens] || 0
+                                  else
+                                    usage.respond_to?(:output_tokens) ? (usage.output_tokens || 0) : 0
+                                  end
+                end
+              end
+
+              # Forward to user's proc
+              stream_proc.call(event)
+            end
+
+            modified_params = parameters.dup
+            modified_params[:stream] = wrapped_stream
+            modified_params.delete("stream")
+
+            begin
+              result = original_messages.call(parameters: modified_params)
+              end_ms = (Time.now.to_f * 1000).to_i
+              span.set_tokens(input_tokens, output_tokens)
+              span.set_latency(end_ms - start_ms)
+              span.cost = 0.0
+              span.model = actual_model
+              span.end
+              trace.end
+              result
+            rescue StandardError => e
+              end_ms = (Time.now.to_f * 1000).to_i
+              span.set_tokens(input_tokens, output_tokens)
+              span.set_latency(end_ms - start_ms)
+              span.set_error(e.message)
+              span.end
+              trace.status = "error"
+              trace.end
+              raise
+            end
+          else
+            # Non-streaming mode
+            begin
+              response = original_messages.call(parameters: parameters)
+              end_ms = (Time.now.to_f * 1000).to_i
+
+              # Extract usage
+              usage = if response.respond_to?(:usage)
+                        response.usage
+                      elsif response.is_a?(Hash)
+                        response["usage"] || response[:usage]
+                      end
+
+              if usage
+                if usage.is_a?(Hash)
+                  span.set_tokens(
+                    usage["input_tokens"] || usage[:input_tokens] || 0,
+                    usage["output_tokens"] || usage[:output_tokens] || 0,
+                  )
+                else
+                  span.set_tokens(
+                    usage.respond_to?(:input_tokens) ? (usage.input_tokens || 0) : 0,
+                    usage.respond_to?(:output_tokens) ? (usage.output_tokens || 0) : 0,
+                  )
+                end
+              end
+
+              resp_model = if response.respond_to?(:model)
+                             response.model
+                           elsif response.is_a?(Hash)
+                             response["model"] || response[:model]
+                           end
+
+              span.set_latency(end_ms - start_ms)
+              span.cost = 0.0
+              span.model = resp_model || model
+              span.end
+              trace.end
+              response
+
+            rescue StandardError => e
+              end_ms = (Time.now.to_f * 1000).to_i
+              span.set_latency(end_ms - start_ms)
+              span.set_error(e.message)
+              span.end
+              trace.status = "error"
+              trace.end
+              raise
+            end
+          end
+        end
+
+        anthropic_client
+      end
+    end
+  end
+end

data/lib/bloop/integrations/openai.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+# OpenAI auto-instrumentation for bloop LLM tracing.
+#
+# Wraps the ruby-openai gem's client.chat(parameters: { ... }) method
+# to automatically capture: model, tokens, latency, TTFT (streaming), errors.
+# Cost is always 0 -- calculated server-side from pricing table.
+
+require "uri"
+
+module Bloop
+  module Integrations
+    module OpenAI
+      # Provider auto-detection from base URL
+      PROVIDER_MAP = {
+        "api.openai.com" => "openai",
+        "api.minimax.io" => "minimax",
+        "api.moonshot.ai" => "kimi",
+        "generativelanguage.googleapis.com" => "google",
+      }.freeze
+
+      # Detect provider from the client's base URL string.
+      def self.detect_provider(uri_base)
+        base_url = uri_base.to_s
+        PROVIDER_MAP.each do |domain, provider|
+          return provider if base_url.include?(domain)
+        end
+        # Fallback: extract hostname
+        host = URI.parse(base_url).host || "openai"
+        host.split(".").first
+      rescue StandardError
+        "openai"
+      end
+
+      # Wrap an OpenAI-compatible client for automatic LLM tracing.
+      #
+      # The ruby-openai gem exposes:
+      #   client.chat(parameters: { model: "gpt-4o", messages: [...] })
+      #   client.chat(parameters: { model: "gpt-4o", messages: [...], stream: proc { |chunk| } })
+      #
+      # Returns the wrapped client (patched in-place).
+      def self.wrap(openai_client, bloop_client)
+        provider = detect_provider(openai_client.respond_to?(:uri_base) ? openai_client.uri_base : "https://api.openai.com/")
+
+        original_chat = openai_client.method(:chat)
+
+        openai_client.define_singleton_method(:chat) do |parameters: {}|
+          model = parameters[:model] || parameters["model"] || "unknown"
+          stream_proc = parameters[:stream] || parameters["stream"]
+          start_ms = (Time.now.to_f * 1000).to_i
+
+          trace = bloop_client.trace(name: "#{provider}/#{model}")
+          span = trace.span(
+            span_type: "generation",
+            name: "chat.completions.create",
+            model: model,
+            provider: provider,
+          )
+
+          if stream_proc
+            # Streaming mode: wrap the user's stream proc
+            first_token_seen = false
+            input_tokens = 0
+            output_tokens = 0
+            actual_model = model
+
+            wrapped_stream = proc do |chunk|
+              unless first_token_seen
+                first_token_seen = true
+                ttft = (Time.now.to_f * 1000).to_i - start_ms
+                span.time_to_first_token_ms = ttft
+              end
+
+              # Track model from chunk
+              chunk_model = chunk.is_a?(Hash) ? (chunk["model"] || chunk[:model]) : (chunk.respond_to?(:model) ? chunk.model : nil)
+              actual_model = chunk_model if chunk_model
+
+              # Track usage from final chunk
+              usage = chunk.is_a?(Hash) ? (chunk["usage"] || chunk[:usage]) : (chunk.respond_to?(:usage) ? chunk.usage : nil)
+              if usage
+                if usage.is_a?(Hash)
+                  input_tokens = usage["prompt_tokens"] || usage[:prompt_tokens] || 0
+                  output_tokens = usage["completion_tokens"] || usage[:completion_tokens] || 0
+                else
+                  input_tokens = usage.respond_to?(:prompt_tokens) ? (usage.prompt_tokens || 0) : 0
+                  output_tokens = usage.respond_to?(:completion_tokens) ? (usage.completion_tokens || 0) : 0
+                end
+              end
+
+              # Forward to user's proc
+              stream_proc.call(chunk)
+            end
+
+            modified_params = parameters.dup
+            modified_params[:stream] = wrapped_stream
+            modified_params.delete("stream")
+
+            begin
+              result = original_chat.call(parameters: modified_params)
+              end_ms = (Time.now.to_f * 1000).to_i
+              span.set_tokens(input_tokens, output_tokens)
+              span.set_latency(end_ms - start_ms)
+              span.cost = 0.0
+              span.model = actual_model
+              span.end
+              trace.end
+              result
+            rescue StandardError => e
+              end_ms = (Time.now.to_f * 1000).to_i
+              span.set_tokens(input_tokens, output_tokens)
+              span.set_latency(end_ms - start_ms)
+              span.set_error(e.message)
+              span.end
+              trace.status = "error"
+              trace.end
+              raise
+            end
+          else
+            # Non-streaming mode
+            begin
+              response = original_chat.call(parameters: parameters)
+              end_ms = (Time.now.to_f * 1000).to_i
+
+              # Extract usage
+              usage = if response.respond_to?(:usage)
+                        response.usage
+                      elsif response.is_a?(Hash)
+                        response["usage"] || response[:usage]
+                      end
+
+              if usage
+                if usage.is_a?(Hash)
+                  span.set_tokens(
+                    usage["prompt_tokens"] || usage[:prompt_tokens] || 0,
+                    usage["completion_tokens"] || usage[:completion_tokens] || 0,
+                  )
+                else
+                  span.set_tokens(
+                    usage.respond_to?(:prompt_tokens) ? (usage.prompt_tokens || 0) : 0,
+                    usage.respond_to?(:completion_tokens) ? (usage.completion_tokens || 0) : 0,
+                  )
+                end
+              end
+
+              resp_model = if response.respond_to?(:model)
+                             response.model
+                           elsif response.is_a?(Hash)
+                             response["model"] || response[:model]
+                           end
+
+              span.set_latency(end_ms - start_ms)
+              span.cost = 0.0
+              span.model = resp_model || model
+              span.end
+              trace.end
+              response
+
+            rescue StandardError => e
+              end_ms = (Time.now.to_f * 1000).to_i
+              span.set_latency(end_ms - start_ms)
+              span.set_error(e.message)
+              span.end
+              trace.status = "error"
+              trace.end
+              raise
+            end
+          end
+        end
+
+        openai_client
+      end
+    end
+  end
+end

data/lib/bloop/integrations.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "integrations/openai"
+require_relative "integrations/anthropic"

data/lib/bloop.rb

@@ -1,266 +1,8 @@
 # frozen_string_literal: true
 
-require "openssl"
-require "net/http"
-require "json"
-require "uri"
-require "securerandom"
-require_relative "bloop/tracing"
+require_relative "bloop/client"
+require_relative "bloop/integrations"
 
 module Bloop
   VERSION = "0.2.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 = []
-      @trace_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
-
-    # Wrap a block and capture any raised exception, then re-raise.
-    #
-    # @param kwargs [Hash] Extra context passed to capture_exception (e.g. route_or_procedure:, metadata:)
-    # @yield The block to execute
-    # @return The block's return value
-    def with_error_capture(**kwargs, &block)
-      block.call
-    rescue Exception => e
-      capture_exception(e, **kwargs)
-      raise
-    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
-
-    # Start a new LLM trace for observability.
-    #
-    # @param name [String] Trace name (e.g. "chat-completion")
-    # @param session_id [String] Optional session identifier
-    # @param user_id [String] Optional user identifier
-    # @param input [Object] Optional input data
-    # @param metadata [Hash] Optional metadata
-    # @param prompt_name [String] Optional prompt template name
-    # @param prompt_version [String] Optional prompt version
-    # @return [Bloop::Trace]
-    def start_trace(name:, session_id: nil, user_id: nil, input: nil, metadata: nil,
-                    prompt_name: nil, prompt_version: nil)
-      Bloop::Trace.new(client: self, name: name, session_id: session_id,
-                       user_id: user_id, input: input, metadata: metadata,
-                       prompt_name: prompt_name, prompt_version: prompt_version)
-    end
-
-    # Wrap a block in a trace. Auto-finishes on success or error.
-    #
-    # @param name [String] Trace name
-    # @param kwargs [Hash] Extra args passed to start_trace
-    # @yield [Bloop::Trace] The trace object
-    # @return [Bloop::Trace]
-    def with_trace(name, **kwargs)
-      trace = start_trace(name: name, **kwargs)
-      yield trace
-      trace.finish(status: :completed) if trace.status == "running"
-      trace
-    rescue Exception => e
-      trace.finish(status: :error, output: e.message) if trace.status == "running"
-      raise
-    end
-
-    private
-
-    def flush_locked
-      unless @buffer.empty?
-        events = @buffer.dup
-        @buffer.clear
-        Thread.new { send_events(events) }
-      end
-
-      flush_traces_locked
-    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 enqueue_trace(trace)
-      @mutex.synchronize do
-        @trace_buffer << trace.to_h
-        flush_traces_locked if @trace_buffer.size >= @max_buffer_size
-      end
-    end
-
-    def flush_traces_locked
-      return if @trace_buffer.empty?
-
-      traces = @trace_buffer.dup
-      @trace_buffer.clear
-      Thread.new { send_traces(traces) }
-    end
-
-    def send_traces(traces)
-      traces.each_slice(50) do |batch|
-        body = JSON.generate({ traces: batch })
-        signature = OpenSSL::HMAC.hexdigest("SHA256", @project_key, body)
-        uri = URI("#{@endpoint}/v1/traces/batch")
-        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)
-      end
-    rescue StandardError
-      # Fire and forget
-    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
-
-  # Rack middleware that captures unhandled exceptions and reports them to bloop.
-  #
-  # Works with Rails, Sinatra, Grape, and any Rack-compatible framework.
-  #
-  # @example Rails
-  #   # config/application.rb
-  #   config.middleware.use Bloop::RackMiddleware, client: Bloop::Client.new(...)
-  #
-  # @example Sinatra
-  #   use Bloop::RackMiddleware, client: Bloop::Client.new(...)
-  class RackMiddleware
-    # @param app [#call] The Rack application
-    # @param client [Bloop::Client] A configured bloop client instance
-    def initialize(app, client:)
-      @app = app
-      @client = client
-    end
-
-    def call(env)
-      @app.call(env)
-    rescue Exception => e
-      @client.capture_exception(e,
-        route_or_procedure: env["PATH_INFO"],
-        metadata: {
-          method: env["REQUEST_METHOD"],
-          query: env["QUERY_STRING"],
-          remote_ip: env["REMOTE_ADDR"],
-        }
-      )
-      raise
-    end
-  end
 end

metadata

@@ -1,30 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: bloop-sdk
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
-- bloop
-autorequire:
+- Bloop
 bindir: bin
 cert_chain: []
-date: 2026-02-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: Capture and send error events to a bloop server. Zero external dependencies.
-email:
+description: Self-hosted error observability and LLM tracing. Captures errors, deduplicates
+  via fingerprinting, and traces AI/LLM calls (token usage, costs, latency). Zero
+  external runtime dependencies.
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/bloop.rb
-- lib/bloop/tracing.rb
-homepage: https://github.com/your-org/bloop
+- lib/bloop/client.rb
+- lib/bloop/integrations.rb
+- lib/bloop/integrations/anthropic.rb
+- lib/bloop/integrations/openai.rb
+homepage: https://github.com/jaikoo/bloop-ruby
 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:
+  source_code_uri: https://github.com/jaikoo/bloop-ruby
 rdoc_options: []
 require_paths:
 - lib
@@ -39,8 +40,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.7.1
 specification_version: 4
-summary: Ruby SDK for bloop error observability
+summary: Bloop error reporting and LLM tracing SDK for Ruby
 test_files: []

data/lib/bloop/tracing.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-module Bloop
-  class Span
-    attr_reader :id, :parent_span_id, :span_type, :name, :model, :provider,
-                :started_at, :input, :metadata
-    attr_accessor :input_tokens, :output_tokens, :cost, :latency_ms,
-                  :time_to_first_token_ms, :status, :error_message, :output
-
-    def initialize(span_type:, name: "", model: "", provider: "", input: nil,
-                   metadata: nil, parent_span_id: nil)
-      @id = SecureRandom.uuid
-      @parent_span_id = parent_span_id
-      @span_type = span_type.to_s
-      @name = name
-      @model = model
-      @provider = provider
-      @input = input
-      @metadata = metadata
-      @started_at = (Time.now.to_f * 1000).to_i
-    end
-
-    def finish(status: :ok, input_tokens: nil, output_tokens: nil, cost: nil,
-               error_message: nil, output: nil, time_to_first_token_ms: nil)
-      @latency_ms = (Time.now.to_f * 1000).to_i - @started_at
-      @status = status.to_s
-      @input_tokens = input_tokens if input_tokens
-      @output_tokens = output_tokens if output_tokens
-      @cost = cost if cost
-      @error_message = error_message if error_message
-      @output = output if output
-      @time_to_first_token_ms = time_to_first_token_ms if time_to_first_token_ms
-      self
-    end
-
-    def set_usage(input_tokens: nil, output_tokens: nil, cost: nil)
-      @input_tokens = input_tokens if input_tokens
-      @output_tokens = output_tokens if output_tokens
-      @cost = cost if cost
-    end
-
-    def to_h
-      h = {
-        id: @id, span_type: @span_type, name: @name,
-        started_at: @started_at, status: @status || "ok",
-      }
-      h[:parent_span_id] = @parent_span_id if @parent_span_id
-      h[:model] = @model unless @model.empty?
-      h[:provider] = @provider unless @provider.empty?
-      h[:input_tokens] = @input_tokens if @input_tokens
-      h[:output_tokens] = @output_tokens if @output_tokens
-      h[:cost] = @cost if @cost
-      h[:latency_ms] = @latency_ms if @latency_ms
-      h[:time_to_first_token_ms] = @time_to_first_token_ms if @time_to_first_token_ms
-      h[:error_message] = @error_message if @error_message
-      h[:input] = @input if @input
-      h[:output] = @output if @output
-      h[:metadata] = @metadata if @metadata
-      h
-    end
-  end
-
-  class Trace
-    attr_reader :id, :name, :session_id, :user_id, :started_at, :input, :metadata,
-                :prompt_name, :prompt_version, :spans
-    attr_accessor :status, :output, :ended_at
-
-    def initialize(client:, name:, session_id: nil, user_id: nil, input: nil,
-                   metadata: nil, prompt_name: nil, prompt_version: nil)
-      @id = SecureRandom.uuid
-      @client = client
-      @name = name
-      @session_id = session_id
-      @user_id = user_id
-      @status = "running"
-      @input = input
-      @metadata = metadata
-      @prompt_name = prompt_name
-      @prompt_version = prompt_version
-      @started_at = (Time.now.to_f * 1000).to_i
-      @spans = []
-    end
-
-    def start_span(span_type: :custom, name: "", model: "", provider: "",
-                   input: nil, metadata: nil, parent_span_id: nil)
-      span = Span.new(span_type: span_type, name: name, model: model,
-                      provider: provider, input: input, metadata: metadata,
-                      parent_span_id: parent_span_id)
-      @spans << span
-      span
-    end
-
-    def with_generation(model: "", provider: "", name: "", input: nil, metadata: nil)
-      span = start_span(span_type: :generation, name: name, model: model,
-                        provider: provider, input: input, metadata: metadata)
-      yield span
-      span.finish(status: :ok) unless span.status
-      span
-    rescue Exception => e
-      span.finish(status: :error, error_message: e.message) unless span.status
-      raise
-    end
-
-    def finish(status: :completed, output: nil)
-      @ended_at = (Time.now.to_f * 1000).to_i
-      @status = status.to_s
-      @output = output if output
-      @client.send(:enqueue_trace, self)
-    end
-
-    def to_h
-      h = {
-        id: @id, name: @name, status: @status, started_at: @started_at,
-        spans: @spans.map(&:to_h),
-      }
-      h[:session_id] = @session_id if @session_id
-      h[:user_id] = @user_id if @user_id
-      h[:input] = @input if @input
-      h[:output] = @output if @output
-      h[:metadata] = @metadata if @metadata
-      h[:prompt_name] = @prompt_name if @prompt_name
-      h[:prompt_version] = @prompt_version if @prompt_version
-      h[:ended_at] = @ended_at if @ended_at
-      h
-    end
-  end
-end