tinymonrb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c33d3e807a92d0f19e975e8d384e2a6a9e78ed22e62c4f2fdf5a5c2e3ff953c7
+  data.tar.gz: 667a99ab8a3b6d3e08780c56e99ccbadbf0c748cd3c2524dfd8ecc78e8911b6b
+SHA512:
+  metadata.gz: '085fdbe62bc6c876ee0c15d40de22f7645141064d7f12cd9035789d2684bfcf3f19f7c1eeb0e0a830311df6eaaa219d3018997b0a0fb96576147a63fe0cd455d'
+  data.tar.gz: 13543ba9734ac10fc3a9ccda8b9c456d7d39e57314449f7583ab4dc48572c9d40051d0bd8f4cfe62d3660f74b23b3dcef5834fac20a464c709685eefd2f9af78

data/lib/tinymon/client.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "event_builder"
+require_relative "scope"
+require_relative "transport"
+
+module Tinymon
+  class Client
+    DEFAULT_ENDPOINT = "https://console.tinymon.dev/api/ingest"
+
+    def initialize(dsn:, endpoint: nil, environment: nil, release: nil, sample_rate: 1.0, before_send: nil)
+      @dsn = dsn
+      @endpoint = endpoint || DEFAULT_ENDPOINT
+      @environment = environment
+      @release = release
+      @sample_rate = sample_rate
+      @before_send = before_send
+      @transport = Transport.new(@endpoint, dsn)
+    end
+
+    def capture_exception(exception)
+      return if rand > @sample_rate
+      snap = SCOPE.snapshot
+      event = EventBuilder.build(
+        exception,
+        release: @release,
+        environment: @environment,
+        user: snap[:user],
+        tags: snap[:tags],
+        breadcrumbs: snap[:breadcrumbs],
+      )
+      if @before_send
+        event = @before_send.call(event)
+        return if event.nil?
+      end
+      @transport.enqueue(event)
+    rescue StandardError
+      # SWALLOW. The SDK must never throw into the host app.
+      nil
+    end
+
+    def capture_message(message, level: "info")
+      synthetic = StandardError.new(message)
+      snap = SCOPE.snapshot
+      event = EventBuilder.build(
+        synthetic,
+        release: @release,
+        environment: @environment,
+        user: snap[:user],
+        tags: snap[:tags],
+        breadcrumbs: snap[:breadcrumbs],
+      )
+      event["level"] = level
+      event["exception"]["type"] = "Message"
+      @transport.enqueue(event)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/tinymon/event_builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "version"
+require_relative "stacktrace"
+
+module Tinymon
+  # Pure construction of a wire-format event from a Ruby Exception.
+  # Mirrors packages/browser/src/eventBuilder.ts and packages/python/.../event_builder.py.
+  module EventBuilder
+    module_function
+
+    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)
+      event = {
+        "event_id"  => SecureRandom.uuid,
+        "timestamp" => Time.now.to_f,
+        "platform"  => "ruby",
+        "level"     => "error",
+        "sdk"       => { "name" => SDK_NAME, "version" => VERSION },
+        "exception" => {
+          "type"       => exception.class.name.to_s,
+          "value"      => exception.message.to_s,
+          "stacktrace" => { "frames" => Stacktrace.parse(exception) },
+        },
+        "breadcrumbs" => (breadcrumbs || []).dup,
+        "user"        => (user || {}).dup,
+        "tags"        => scrub(tags || {}),
+      }
+      event["release"] = release if release
+      event["environment"] = environment if environment
+      event["request"] = { "url" => url } if url
+      event
+    end
+
+    def scrub(tags)
+      tags.each_with_object({}) do |(k, v), out|
+        out[k.to_s] = SENSITIVE.match?(k.to_s) ? "[redacted]" : v
+      end
+    end
+  end
+end

data/lib/tinymon/integrations.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Tinymon
+  # Capture unhandled exceptions at process exit. Ruby doesn't have a true
+  # global "uncaught exception" hook the way Python (sys.excepthook) or Java
+  # (Thread.setDefaultUncaughtExceptionHandler) do — the closest equivalent is
+  # checking $! inside an at_exit block, which fires after a fatal exception
+  # has propagated out of `main`.
+  module Integrations
+    module_function
+
+    def install(client)
+      at_exit do
+        exc = $! # rubocop:disable Style/SpecialGlobalVars
+        # SystemExit is normal program exit; ignore it.
+        if exc && !exc.is_a?(SystemExit)
+          begin
+            client.capture_exception(exc)
+          rescue StandardError
+            # swallow
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tinymon/scope.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Tinymon
+  # Process-wide user/tags/breadcrumbs that ride along with every event.
+  class Scope
+    MAX_BREADCRUMBS = 50
+
+    attr_reader :user, :tags, :breadcrumbs
+
+    def initialize
+      @mutex = Mutex.new
+      @user = {}
+      @tags = {}
+      @breadcrumbs = []
+    end
+
+    def set_user(user)
+      @mutex.synchronize { @user = user.dup }
+    end
+
+    def set_tag(key, value)
+      @mutex.synchronize { @tags[key.to_s] = value }
+    end
+
+    def add_breadcrumb(crumb)
+      @mutex.synchronize do
+        @breadcrumbs.push(crumb)
+        @breadcrumbs.shift if @breadcrumbs.length > MAX_BREADCRUMBS
+      end
+    end
+
+    def snapshot
+      @mutex.synchronize do
+        {
+          user: @user.dup,
+          tags: @tags.dup,
+          breadcrumbs: @breadcrumbs.dup,
+        }
+      end
+    end
+  end
+
+  # Singleton instance — mirrors the JS/Python SDKs' module-level scope.
+  SCOPE = Scope.new
+end

data/lib/tinymon/stacktrace.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Tinymon
+  # Convert a Ruby Exception's backtrace into wire-format stack frames.
+  #
+  # Wire format wants frames ordered deepest-LAST. Ruby's #backtrace returns
+  # them deepest-FIRST (raise site first, then callers), so we reverse.
+  module Stacktrace
+    module_function
+
+    # Falsy heuristic: a frame is NOT in_app if its path lives inside a gem
+    # directory, the Ruby stdlib, or is a built-in (`<internal:...>`).
+    GEM_MARKER = "/gems/"
+    INTERNAL_PREFIX = "<"
+    STDLIB_PATH = RbConfig::CONFIG["rubylibdir"].to_s
+
+    def parse(exception)
+      return [] unless exception
+
+      locations = nil
+      begin
+        locations = exception.backtrace_locations
+      rescue StandardError
+        locations = nil
+      end
+
+      if locations && !locations.empty?
+        frames = locations.map { |loc| from_location(loc) }
+      else
+        bt = exception.backtrace || []
+        frames = bt.map { |line| parse_string(line) }.compact
+      end
+
+      # Ruby gives deepest-first; wire format wants deepest-LAST.
+      frames.reverse
+    end
+
+    def from_location(loc)
+      path = loc.path.to_s
+      {
+        "filename" => path,
+        "function" => (loc.base_label || loc.label || "<anonymous>").to_s,
+        "lineno"   => loc.lineno.to_i,
+        "colno"    => 0,
+        "in_app"   => in_app?(path),
+      }
+    end
+
+    # Match strings like:
+    #   "path/to/file.rb:123:in `method_name'"
+    #   "path/to/file.rb:123:in 'method_name'"
+    BT_LINE = /\A(.+?):(\d+)(?::in [`'](.+?)')?\z/.freeze
+
+    def parse_string(line)
+      m = BT_LINE.match(line.to_s)
+      return nil unless m
+      filename = m[1]
+      {
+        "filename" => filename,
+        "function" => (m[3] || "<anonymous>"),
+        "lineno"   => m[2].to_i,
+        "colno"    => 0,
+        "in_app"   => in_app?(filename),
+      }
+    end
+
+    def in_app?(path)
+      return false if path.nil? || path.empty?
+      return false if path.start_with?(INTERNAL_PREFIX)
+      return false if path.include?(GEM_MARKER)
+      return false if !STDLIB_PATH.empty? && path.start_with?(STDLIB_PATH)
+      true
+    end
+  end
+end

data/lib/tinymon/transport.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "json"
+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.
+  class Transport
+    FLUSH_INTERVAL = 5.0  # seconds
+    MAX_BATCH = 10
+    MAX_QUEUE = 30
+    REQUEST_TIMEOUT = 5  # seconds
+
+    def initialize(endpoint, dsn)
+      @endpoint = endpoint
+      @dsn = dsn
+      @queue = []
+      @mutex = Mutex.new
+      @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
+      @mutex.synchronize do
+        @queue.shift while @queue.length >= MAX_QUEUE
+        @queue.push(event)
+        should_flush = @queue.length >= MAX_BATCH
+      end
+      flush if should_flush
+    end
+
+    def flush
+      batch = nil
+      @mutex.synchronize do
+        batch = @queue.shift(MAX_BATCH)
+      end
+      return if batch.nil? || batch.empty?
+      batch.each { |event| send_one(event) }
+    end
+
+    private
+
+    def send_one(event)
+      uri = URI.parse(@endpoint)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.open_timeout = REQUEST_TIMEOUT
+      http.read_timeout = REQUEST_TIMEOUT
+      req = Net::HTTP::Post.new(uri.request_uri, {
+        "Content-Type" => "application/json",
+        "X-Tinymon-Key" => @dsn,
+      })
+      req.body = JSON.dump(event)
+      begin
+        http.request(req)
+      rescue StandardError
+        # Network failed — re-enqueue if there's room.
+        @mutex.synchronize do
+          @queue.unshift(event) if @queue.length < MAX_QUEUE
+        end
+      end
+    end
+
+    def run_loop
+      until @stop
+        sleep(FLUSH_INTERVAL)
+        begin
+          flush
+        rescue StandardError
+          # swallow — never crash the host app
+        end
+      end
+    end
+
+    def shutdown
+      @stop = true
+      begin
+        flush
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/tinymon/version.rb

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

data/lib/tinymon.rb

@@ -0,0 +1,64 @@
+# 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

data/lib/tinymonrb.rb

@@ -0,0 +1,64 @@
+# 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

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: tinymonrb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- tinymon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json_schemer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Captures unhandled exceptions and ships them to a tinymon ingest endpoint.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/tinymon.rb
+- lib/tinymon/client.rb
+- lib/tinymon/event_builder.rb
+- lib/tinymon/integrations.rb
+- lib/tinymon/scope.rb
+- lib/tinymon/stacktrace.rb
+- lib/tinymon/transport.rb
+- lib/tinymon/version.rb
+- lib/tinymonrb.rb
+homepage: https://tinymon.dev
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://tinymon.dev
+  documentation_uri: https://tinymon.dev/docs/ruby.html
+  source_code_uri: https://github.com/tinymon/tinymon
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Tiny error monitoring SDK for Ruby.
+test_files: []