tinymonrb 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fb61a62ef1e259893c449ab46dbbbe6ba67f300a45551cb093e4598adeac193
-  data.tar.gz: 12f762661bba46acbbce593f7558e5dbc38ed1a2b181c9ed14e334bacc47a3de
+  metadata.gz: 721bdc7f477b8281a78914201aadf4367fe02206248735b91dc6c564459c4050
+  data.tar.gz: 5b119d9cd4b65d8cef7648b779be6a84f93ffca1c78c7fd0560e63529ca31560
 SHA512:
-  metadata.gz: 53ef44902a951ef0f01c463f94d8ebe841b35718b9a40ffe071e8ed559e34c939a6012e05e7a7b78aab0fcda7704a35aed814ffd982283a22a61633335ff97e4
-  data.tar.gz: cf09570386509420ff6952856d6366aa15d304699fc6b8d4692a877acb74f59d49933ca4d5d5154a7db24632c857f09272828324ad8dae40c8fb893b2f2ed9e7
+  metadata.gz: 911fac08481f040b354966c3baf7d14db96d9a5deab26b86bd077b432c430eca3dcda7c9dc84e0fc600efd344c4c8354c31137651e3b22cada233e976b142a47
+  data.tar.gz: b3cf2caffb694ba16700b9f69d758d2f025d87bae3a4c1849bc10d0899118905a096082b79a29aa87f23b786b69ed48f82fb7231c419c3b2d02bf40e8ef032a2

data/lib/tinymon/client.rb

@@ -37,7 +37,7 @@ module Tinymon
       return if rand > @sample_rate
       event = _prepare(exception)
       return if event.nil?
-      @transport.enqueue(event)
+      @transport.send_event(event)
     rescue StandardError
       # SWALLOW. The SDK must never throw into the host app.
       nil
@@ -48,22 +48,44 @@ module Tinymon
       return if event.nil?
       event["level"] = level
       event["exception"]["type"] = "Message"
-      @transport.enqueue(event)
+      @transport.send_event(event)
+    rescue StandardError
+      nil
+    end
+
+    # Per-event context capture. Use from Rack middleware; do NOT use
+    # Tinymon.set_user/set_tag for per-request data — they race under
+    # concurrency.
+    def capture_exception_with_context(exception, request: nil, user: nil, tags: nil)
+      return if rand > @sample_rate
+      event = _prepare(exception, ctx: { request: request, user: user, tags: tags })
+      return if event.nil?
+      @transport.send_event(event)
+    rescue StandardError
+      nil
+    end
+
+    # Block until queued events are delivered (or timeout). Call before a
+    # short-lived process exits so events aren't dropped.
+    def flush(timeout = 2.0)
+      @transport.flush(timeout)
     rescue StandardError
       nil
     end
 
     private
 
-    def _prepare(exception)
+    def _prepare(exception, ctx: nil)
       snap = SCOPE.snapshot
+      ctx ||= {}
       event = EventBuilder.build(
         exception,
         release: @release,
         environment: @environment,
-        user: snap[:user],
-        tags: snap[:tags],
+        user: ctx[:user] || snap[:user],
+        tags: ctx[:tags] || snap[:tags],
         breadcrumbs: snap[:breadcrumbs],
+        request: ctx[:request],
       )
       # Default scrub BEFORE before_send.
       Scrub.scrub_event(event, scrub_url_query: @scrub_url_query, scrub_patterns: @scrub_patterns)

data/lib/tinymon/event_builder.rb

@@ -12,7 +12,7 @@ module Tinymon
 
     SENSITIVE = /password|token|secret|auth|card|cvv|ssn/i.freeze
 
-    def build(exception, release: nil, environment: nil, user: nil, tags: nil, breadcrumbs: nil, url: nil)
+    def build(exception, release: nil, environment: nil, user: nil, tags: nil, breadcrumbs: nil, url: nil, request: nil)
       event = {
         "event_id"  => SecureRandom.uuid,
         "timestamp" => Time.now.to_f,
@@ -30,7 +30,16 @@ module Tinymon
       }
       event["release"] = release if release
       event["environment"] = environment if environment
-      event["request"] = { "url" => url } if url
+      if request && (request[:method] || request["method"] || request[:url] || request["url"])
+        req = {}
+        m = request[:method] || request["method"]
+        u = request[:url] || request["url"]
+        req["method"] = m if m
+        req["url"] = u if u
+        event["request"] = req
+      elsif url
+        event["request"] = { "url" => url }
+      end
       event
     end
 

data/lib/tinymon/rack.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Rack middleware. Insert into ANY Rack app (Rails, Sinatra, Hanami,
+# plain Rack) to capture in-request exceptions. Captures with per-event
+# request context (method + URL) and RE-RAISES so the framework's own
+# error handling still fires.
+#
+# Manual insert:
+#   require "tinymonrb"
+#   use Tinymon::Rack          # Sinatra / plain Rack
+#   # Rails:
+#   config.middleware.use Tinymon::Rack
+#
+# Or use the Railtie for auto-insert in Rails apps (loaded automatically
+# when Rails is detected at runtime).
+
+module Tinymon
+  class Rack
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue StandardError, ScriptError => e
+      capture(e, env)
+      raise
+    end
+
+    private
+
+    def capture(exc, env)
+      mod = ::Tinymon
+      client = mod.instance_variable_get(:@client)
+      return unless client
+
+      url = build_url(env)
+      method = env["REQUEST_METHOD"]
+      client.capture_exception_with_context(
+        exc,
+        request: { method: method, url: url }
+      )
+    rescue StandardError
+      # never let the SDK break the request
+      nil
+    end
+
+    def build_url(env)
+      scheme = env["rack.url_scheme"] || "http"
+      host = env["HTTP_HOST"] || env["SERVER_NAME"] || ""
+      path = env["REQUEST_URI"] ||
+             "#{env['SCRIPT_NAME']}#{env['PATH_INFO']}#{env['QUERY_STRING'] && !env['QUERY_STRING'].empty? ? "?#{env['QUERY_STRING']}" : ''}"
+      host.empty? ? path : "#{scheme}://#{host}#{path}"
+    end
+  end
+end

data/lib/tinymon/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Auto-insert Tinymon::Rack into the Rails middleware stack. Loaded only
+# when Rails is present at require time — no hard Rails dependency.
+require_relative "rack"
+
+module Tinymon
+  class Railtie < ::Rails::Railtie
+    initializer "tinymon.middleware" do |app|
+      app.middleware.use Tinymon::Rack
+    end
+  end
+end

data/lib/tinymon/transport.rb

@@ -5,46 +5,55 @@ require "net/http"
 require "uri"
 
 module Tinymon
-  # Batched HTTP transport. stdlib-only. A background thread flushes every
-  # 5 seconds; at_exit drains the queue on shutdown.
+  # HTTP transport. stdlib-only. Sends each event immediately on a background
+  # worker thread; events are only queued when the network fails, and that
+  # retry queue is drained with exponential backoff. This matches how
+  # production error SDKs behave — the error lands in the dashboard now, not
+  # on a 5-second timer. at_exit drains anything still pending on shutdown.
   class Transport
-    FLUSH_INTERVAL = 5.0  # seconds
-    MAX_BATCH = 10
-    MAX_QUEUE = 30
-    REQUEST_TIMEOUT = 5  # seconds
+    MAX_QUEUE = 30          # cap on retry buffer (dead-network memory guard)
+    REQUEST_TIMEOUT = 5     # seconds
+    BACKOFF_START = 1.0     # seconds
+    BACKOFF_MAX = 30.0      # seconds
 
     def initialize(endpoint, dsn)
       @endpoint = endpoint
       @dsn = dsn
-      @queue = []
+      @pending = []         # fresh events — sent immediately
+      @retry = []           # failed events — retried with backoff
       @mutex = Mutex.new
+      @cond = ConditionVariable.new
+      @backoff = BACKOFF_START
       @stop = false
       @thread = Thread.new { run_loop }
       @thread.name = "tinymon-transport" if @thread.respond_to?(:name=)
       at_exit { shutdown }
     end
 
-    def enqueue(event)
-      should_flush = false
+    # Queue for immediate send on the worker thread (non-blocking).
+    def send_event(event)
       @mutex.synchronize do
-        @queue.shift while @queue.length >= MAX_QUEUE
-        @queue.push(event)
-        should_flush = @queue.length >= MAX_BATCH
+        @pending.push(event)
+        @cond.signal
       end
-      flush if should_flush
     end
 
-    def flush
-      batch = nil
-      @mutex.synchronize do
-        batch = @queue.shift(MAX_BATCH)
+    # Block until pending + retry events are sent, or timeout elapses.
+    def flush(timeout = 2.0)
+      deadline = monotonic + timeout
+      loop do
+        empty = @mutex.synchronize { @pending.empty? && @retry.empty? }
+        return if empty
+        break if monotonic >= deadline
+        @mutex.synchronize { @cond.signal }
+        sleep(0.02)
       end
-      return if batch.nil? || batch.empty?
-      batch.each { |event| send_one(event) }
     end
 
     private
 
+    # Returns true on success OR an unrecoverable 4xx (retrying a client bug
+    # won't help); false on 5xx / network failure.
     def send_one(event)
       uri = URI.parse(@endpoint)
       http = Net::HTTP.new(uri.host, uri.port)
@@ -57,33 +66,89 @@ module Tinymon
       })
       req.body = JSON.dump(event)
       begin
-        http.request(req)
+        res = http.request(req)
+        code = res.code.to_i
+        return true if code >= 200 && code < 300
+        return true if code >= 400 && code < 500 # client bug — drop, don't retry
+        false
       rescue StandardError
-        # Network failed — re-enqueue if there's room.
-        @mutex.synchronize do
-          @queue.unshift(event) if @queue.length < MAX_QUEUE
-        end
+        false
       end
     end
 
     def run_loop
       until @stop
-        sleep(FLUSH_INTERVAL)
-        begin
-          flush
-        rescue StandardError
-          # swallow — never crash the host app
+        event = next_pending
+        if event
+          queue_retry(event) unless send_one(event)
+          next
+        end
+
+        next if drain_retry
+
+        # Idle — wait for new work or the next retry window.
+        @mutex.synchronize do
+          wait = @retry.empty? ? nil : @backoff
+          @cond.wait(@mutex, wait) unless @stop
+        end
+      end
+    end
+
+    def next_pending
+      @mutex.synchronize { @pending.shift }
+    end
+
+    def queue_retry(event)
+      @mutex.synchronize do
+        @retry.shift while @retry.length >= MAX_QUEUE
+        @retry.push(event)
+      end
+    end
+
+    def drain_retry
+      batch = @mutex.synchronize do
+        next nil if @retry.empty?
+        b = @retry.dup
+        @retry.clear
+        b
+      end
+      return false if batch.nil?
+
+      any_failed = false
+      batch.each do |event|
+        unless send_one(event)
+          any_failed = true
+          queue_retry(event)
         end
       end
+      if any_failed
+        @backoff = [@backoff * 2, BACKOFF_MAX].min
+        sleep(@backoff)
+      else
+        @backoff = BACKOFF_START
+      end
+      true
     end
 
     def shutdown
-      @stop = true
-      begin
-        flush
-      rescue StandardError
-        nil
+      # Best-effort: deliver anything still pending before exit.
+      deadline = monotonic + 2.0
+      while monotonic < deadline
+        event = next_pending
+        event ||= @mutex.synchronize { @retry.shift }
+        break if event.nil?
+        send_one(event)
+      end
+      @mutex.synchronize do
+        @stop = true
+        @cond.broadcast
       end
+    rescue StandardError
+      nil
+    end
+
+    def monotonic
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
   end
 end

data/lib/tinymon/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Tinymon
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
   SDK_NAME = "tinymon.ruby"
 end

data/lib/tinymon.rb

@@ -1,64 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "tinymon/version"
-require_relative "tinymon/stacktrace"
-require_relative "tinymon/event_builder"
-require_relative "tinymon/scope"
-require_relative "tinymon/transport"
-require_relative "tinymon/client"
-require_relative "tinymon/integrations"
-
-# Public API:
-#
-#   require "tinymon"
-#   Tinymon.init(dsn: "tm_pub_xxx", environment: "production", release: "1.0.0")
-#
-#   begin
-#     risky_thing
-#   rescue => e
-#     Tinymon.capture_exception(e)
-#   end
-#
-module Tinymon
-  @client = nil
-
-  class << self
-    def init(dsn:, endpoint: nil, environment: nil, release: nil, sample_rate: 1.0, before_send: nil)
-      @client = Client.new(
-        dsn: dsn,
-        endpoint: endpoint,
-        environment: environment,
-        release: release,
-        sample_rate: sample_rate,
-        before_send: before_send,
-      )
-      Integrations.install(@client)
-      @client
-    end
-
-    def capture_exception(exception)
-      @client&.capture_exception(exception)
-    end
-
-    def capture_message(message, level: "info")
-      @client&.capture_message(message, level: level)
-    end
-
-    def set_user(user)
-      SCOPE.set_user(user)
-    end
-
-    def set_tag(key, value)
-      SCOPE.set_tag(key, value)
-    end
-
-    def add_breadcrumb(crumb)
-      SCOPE.add_breadcrumb(crumb)
-    end
-
-    # Exposed for the cross-language contract test in test/test_contract.rb.
-    def _build_event(exception, **kwargs)
-      EventBuilder.build(exception, **kwargs)
-    end
-  end
-end
+# Back-compat shim. The gem is published as `tinymonrb`, so the canonical
+# entry point is `require "tinymonrb"`. This file only exists so that older
+# code doing `require "tinymon"` keeps working — it loads the full SDK
+# (context capture, Rack middleware, Rails railtie) rather than a partial copy.
+require_relative "tinymonrb"

data/lib/tinymonrb.rb

@@ -7,6 +7,9 @@ require_relative "tinymon/scope"
 require_relative "tinymon/transport"
 require_relative "tinymon/client"
 require_relative "tinymon/integrations"
+require_relative "tinymon/rack"
+# Rails auto-insert — only loaded when Rails is present at require time.
+require_relative "tinymon/railtie" if defined?(::Rails::Railtie)
 
 # Public API:
 #
@@ -53,10 +56,22 @@ module Tinymon
       @client&.capture_exception(exception)
     end
 
+    # Per-event context capture. Use from Rack middleware; do NOT use
+    # set_user/set_tag for per-request data (they race under concurrency).
+    def capture_exception_with_context(exception, request: nil, user: nil, tags: nil)
+      @client&.capture_exception_with_context(exception, request: request, user: user, tags: tags)
+    end
+
     def capture_message(message, level: "info")
       @client&.capture_message(message, level: level)
     end
 
+    # Block until queued events are delivered (or timeout). Call before a
+    # short-lived process exits so events aren't dropped.
+    def flush(timeout = 2.0)
+      @client&.flush(timeout)
+    end
+
     def set_user(user)
       SCOPE.set_user(user)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tinymonrb
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - tinymon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-09 00:00:00.000000000 Z
+date: 2026-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json_schemer
@@ -48,6 +48,8 @@ files:
 - lib/tinymon/client.rb
 - lib/tinymon/event_builder.rb
 - lib/tinymon/integrations.rb
+- lib/tinymon/rack.rb
+- lib/tinymon/railtie.rb
 - lib/tinymon/scope.rb
 - lib/tinymon/scrub.rb
 - lib/tinymon/stacktrace.rb