watchforge-ruby-sdk 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6d1d05cc1cbefe1dcac7416fe8487041e18009bc9df6ae09d4c10a8cdbec425b
+  data.tar.gz: dcd0fcee33796a40c4e5a5d55cf8490bbd002f10d47b70d3caaef8584b833280
+SHA512:
+  metadata.gz: 76caafd0ca6e1d1b38fc69aac06cf838c7bc0f27d28b4fa3e1a227047acf1f44c4e79e3965be2c259a0fde73052f8db755b8e5027ccb2e0ffd35d81050d9fd29
+  data.tar.gz: 2ec8d79857a2c587c3e356d2fd0eb0e370ff93a6f943a99a9722fc810436f5183648b6f9cb1dec609e117ff60c046fbb3a4cf15bd4a02315cef249df349ec52f

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WatchForge
+
+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,104 @@
+# WatchForge Ruby SDK (`watchforge-ruby-sdk`)
+
+Ruby SDK for WatchForge — errors, cron monitors, distributed tracing, and management APIs. Aligned with `watchforge-sdk` (Python) and `@watchforge/browser` (JavaScript).
+
+## Install
+
+```bash
+gem install watchforge-ruby-sdk
+```
+
+Or in your `Gemfile`:
+
+```ruby
+gem "watchforge-ruby-sdk", "~> 0.1.0"
+```
+
+```bash
+bundle install
+```
+
+## Quick start
+
+```ruby
+require "watchforge"
+
+Watchforge.init(
+  dsn: "https://PUBLIC_KEY@dev.watchforges.com/PROJECT_ID",
+  environment: "production"
+)
+
+Watchforge.context.add_breadcrumb("boot", "service started")
+Watchforge.capture_message("hello", level: "info")
+Watchforge.capture_exception(StandardError.new("boom"))
+```
+
+## Feature support
+
+| Feature | API |
+| --- | --- |
+| Issues (ingestion) | `capture_exception`, `capture_message` |
+| Context | `context.add_breadcrumb`, `set_user`, `set_tags` |
+| Cron monitors | `capture_check_in` |
+| Tracing | `start_transaction`, `start_span`, `finish_transaction` |
+| Management API | `Watchforge::API::Client` |
+
+## Cron monitor
+
+```ruby
+check_in_id = Watchforge.capture_check_in(
+  monitor_slug: "nightly-job",
+  status: "in_progress",
+  monitor_config: {
+    schedule: { type: "crontab", value: "0 * * * *" },
+    timezone: "UTC",
+    check_margin: 5,
+    max_runtime: 30
+  }
+)
+
+Watchforge.capture_check_in(
+  monitor_slug: "nightly-job",
+  status: "ok",
+  check_in_id: check_in_id,
+  monitor_config: monitor_config
+)
+```
+
+## Tracing
+
+```ruby
+txn = Watchforge.start_transaction("GET /health", "Health Check")
+span = txn.start_span("db.query", "SELECT 1")
+span.finish
+Watchforge.finish_transaction
+```
+
+## Management API (Bearer token)
+
+```ruby
+api = Watchforge::API::Client.new("https://dev.watchforges.com", ENV["WATCHFORGE_TOKEN"])
+api.list_issues(project_id, range: "7d", status: "unresolved")
+api.dashboard_summary(project_id: project_id, range: "24h")
+api.query_dashboard_widget(widget_payload)
+```
+
+## Package naming (WatchForge SDK family)
+
+| Language | Package | Install |
+| --- | --- | --- |
+| Python | `watchforge-sdk` | `pip install watchforge-sdk` |
+| JavaScript | `@watchforge/browser` | `npm install @watchforge/browser` |
+| Go | `watchforge-go-sdk` | `go get github.com/watchforges/watchforge-go-sdk/watchforge` |
+| **Ruby** | `watchforge-ruby-sdk` | `gem install watchforge-ruby-sdk` |
+| PHP | `watchforge-php-sdk` | `composer require watchforges/watchforge-php-sdk` |
+| Flutter | `watchforge_flutter_sdk` | `flutter pub add watchforge_flutter_sdk` |
+| React Native | `@watchforge/react-native` | `npm install @watchforge/react-native` |
+
+## Publishing (maintainers)
+
+See [PUBLISHING.md](./PUBLISHING.md).
+
+## License
+
+MIT

data/lib/watchforge/api/client.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Watchforge
+  module API
+    class Client
+      def initialize(base_url, token)
+        @base_url = base_url.to_s.chomp("/")
+        @base_url += "/api" unless @base_url.end_with?("/api")
+        @token = token
+      end
+
+      def get(path, params = {})
+        request(:get, path, params: params)
+      end
+
+      def post(path, body = {})
+        request(:post, path, body: body)
+      end
+
+      def patch(path, body = {})
+        request(:patch, path, body: body)
+      end
+
+      def delete(path)
+        request(:delete, path)
+      end
+
+      private
+
+      def request(method, path, params: nil, body: nil)
+        uri = URI.parse("#{@base_url}/#{path.delete_prefix('/')}")
+        uri.query = URI.encode_www_form(params) if params && !params.empty?
+
+        klass = {
+          get: Net::HTTP::Get,
+          post: Net::HTTP::Post,
+          patch: Net::HTTP::Patch,
+          delete: Net::HTTP::Delete
+        }[method]
+        request = klass.new(uri)
+        request["Authorization"] = "Bearer #{@token}"
+        request["Content-Type"] = "application/json"
+        request.body = JSON.generate(body) if body
+
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.request(request)
+        end
+        raise "watchforge api failed: #{response.code} #{response.body}" if response.code.to_i >= 400
+        return nil if response.body.nil? || response.body.empty?
+
+        JSON.parse(response.body)
+      end
+    end
+  end
+end

data/lib/watchforge/api/dashboard.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Watchforge
+  module API
+    module Dashboard
+      def dashboard_summary(params = {})
+        get("dashboard/", params)
+      end
+
+      def dashboard_analytics(params = {})
+        get("dashboard/analytics/", params)
+      end
+
+      def dashboard_reports(params = {})
+        get("dashboard/reports/", params)
+      end
+
+      def query_dashboard_widget(payload)
+        post("dashboard/custom/widgets/query/", payload)
+      end
+
+      def list_custom_dashboards(params = {})
+        get("dashboard/custom/", params)
+      end
+
+      def project_dashboard(project_id, params = {})
+        get("projects/#{project_id}/dashboard/", params)
+      end
+    end
+  end
+end
+
+Watchforge::API::Client.include Watchforge::API::Dashboard

data/lib/watchforge/api/issues.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Watchforge
+  module API
+    module Issues
+      def list_issues(project_id, params = {})
+        get("issues/", params.merge(project_id: project_id))
+      end
+
+      def get_issue(issue_id)
+        get("issues/#{issue_id}/")
+      end
+
+      def resolve_issue(issue_id)
+        post("issues/#{issue_id}/resolve/")
+      end
+
+      def ignore_issue(issue_id)
+        post("issues/#{issue_id}/ignore/")
+      end
+
+      def update_issue(issue_id, payload)
+        patch("issues/#{issue_id}/update/", payload)
+      end
+
+      def issue_stats(issue_id, params = {})
+        get("issues/#{issue_id}/stats/", params)
+      end
+    end
+  end
+end
+
+Watchforge::API::Client.include Watchforge::API::Issues

data/lib/watchforge/api/monitors.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Watchforge
+  module API
+    module Monitors
+      def list_monitors(project_id)
+        get("monitors/projects/#{project_id}/monitors/")
+      end
+
+      def get_monitor(monitor_id)
+        get("monitors/monitors/#{monitor_id}/")
+      end
+
+      def create_monitor(project_id, payload)
+        post("monitors/projects/#{project_id}/monitors/", payload)
+      end
+
+      def update_monitor(monitor_id, payload)
+        patch("monitors/monitors/#{monitor_id}/", payload)
+      end
+
+      def delete_monitor(monitor_id)
+        delete("monitors/monitors/#{monitor_id}/")
+      end
+
+      def list_monitor_check_ins(monitor_id, params = {})
+        get("monitors/monitors/#{monitor_id}/checkins/", params)
+      end
+    end
+  end
+end
+
+Watchforge::API::Client.include Watchforge::API::Monitors

data/lib/watchforge/api/traces.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Watchforge
+  module API
+    module Traces
+      def list_traces(project_id, params = {})
+        get("traces/", params.merge(project_id: project_id))
+      end
+
+      def get_trace(trace_id)
+        get("traces/#{trace_id}/")
+      end
+
+      def list_trace_spans(trace_id)
+        get("traces/#{trace_id}/spans/")
+      end
+
+      def trace_performance(project_id, params = {})
+        get("traces/performance/", params.merge(project_id: project_id))
+      end
+    end
+  end
+end
+
+Watchforge::API::Client.include Watchforge::API::Traces

data/lib/watchforge/client.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+
+module Watchforge
+  class Client
+    attr_reader :context
+
+    def initialize(dsn:, environment: "production", release: nil, debug: false)
+      @dsn = dsn
+      @environment = environment
+      @release = release
+      @debug = debug
+      @transport = Transport.new(dsn, debug: debug)
+      @context = Context.new
+    end
+
+    def capture_exception(error, extra: nil)
+      payload = base_event("error", error.message)
+      payload[:exception_type] = error.class.name
+      payload[:exception_value] = error.message
+      payload[:stacktrace] = { frames: [{ filename: "unknown", function: error.class.name, lineno: 0, in_app: true }] }
+      merge_extra(payload, extra)
+      @transport.send_event(payload)
+    end
+
+    def capture_message(message, level: "info", extra: nil)
+      payload = base_event(level, message)
+      merge_extra(payload, extra)
+      @transport.send_event(payload)
+    end
+
+    def capture_check_in(monitor_slug:, status: "ok", monitor_config: nil, check_in_id: nil, environment: nil)
+      check_in_id ||= SecureRandom.uuid if status == "in_progress"
+      payload = {
+        monitor_slug: monitor_slug,
+        status: status,
+        environment: environment || @environment
+      }
+      payload[:monitor_config] = monitor_config if monitor_config
+      payload[:check_in_id] = check_in_id if check_in_id
+      @transport.send_monitor_check_in(payload)
+      check_in_id
+    end
+
+    private
+
+    def base_event(level, message)
+      user, tags, extra, request, breadcrumbs = @context.snapshot
+      payload = {
+        event_id: SecureRandom.uuid,
+        level: level,
+        environment: @environment,
+        message: message,
+        platform: "ruby",
+        timestamp: Time.now.utc.iso8601,
+        sdk: { name: SDK_NAME, version: VERSION },
+        data: {},
+        contexts: { runtime: { name: "ruby", version: RUBY_VERSION } }
+      }
+      payload[:release] = @release if @release
+      payload[:user] = user if user
+      payload[:request] = request if request
+      payload[:tags] = tags unless tags.empty?
+      payload[:data].merge!(extra) unless extra.empty?
+      payload[:breadcrumbs] = breadcrumbs unless breadcrumbs.empty?
+      payload
+    end
+
+    def merge_extra(payload, extra)
+      return unless extra
+
+      payload[:data].merge!(extra)
+    end
+  end
+end

data/lib/watchforge/context.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+
+module Watchforge
+  class Context
+    def initialize
+      @mutex = Mutex.new
+      @user = nil
+      @tags = {}
+      @extra = {}
+      @request = nil
+      @breadcrumbs = []
+    end
+
+    def set_user(user) = synchronize { @user = user }
+    def set_tags(tags) = synchronize { @tags.merge!(tags) }
+    def set_extra(extra) = synchronize { @extra.merge!(extra) }
+    def set_request(request) = synchronize { @request = request }
+
+    def add_breadcrumb(category, message, data = nil)
+      synchronize do
+        @breadcrumbs << {
+          category: category,
+          message: message,
+          level: "info",
+          timestamp: Time.now.utc.iso8601,
+          data: data
+        }
+        @breadcrumbs = @breadcrumbs.last(100)
+      end
+    end
+
+    def snapshot
+      synchronize do
+        [@user, @tags.dup, @extra.dup, @request, @breadcrumbs.dup]
+      end
+    end
+
+    private
+
+    def synchronize(&block)
+      @mutex.synchronize(&block)
+    end
+  end
+end

data/lib/watchforge/dsn.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Watchforge
+  ParsedDSN = Struct.new(:scheme, :public_key, :host, :port, :project_id, :dsn, keyword_init: true) do
+    def events_url
+      ingestion_url("events/")
+    end
+
+    def trace_url
+      ingestion_url("trace/")
+    end
+
+    def monitor_url
+      ingestion_url("monitors/checkins/")
+    end
+
+    private
+
+    def ingestion_url(path)
+      host = port && !port.empty? ? "#{self.host}:#{port}" : self.host
+      "#{scheme}://#{host}/api/ingestion/#{path}"
+    end
+  end
+
+  module DSN
+    module_function
+
+    def parse(dsn)
+      uri = URI.parse(dsn)
+      raise ArgumentError, "invalid watchforge dsn" if uri.user.nil? || uri.host.nil? || uri.path.nil? || uri.path == "/"
+
+      scheme = %w[localhost 127.0.0.1].include?(uri.host) ? "http" : uri.scheme
+      ParsedDSN.new(
+        scheme: scheme,
+        public_key: uri.user,
+        host: uri.host,
+        port: uri.port,
+        project_id: uri.path.delete_prefix("/"),
+        dsn: dsn
+      )
+    end
+  end
+end

data/lib/watchforge/tracing.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+
+module Watchforge
+  class Span
+    attr_reader :span_id, :op, :description, :parent_span_id, :data, :tags
+    attr_accessor :status, :status_code, :finish_timestamp, :duration_ms
+
+    def initialize(op, description = "", parent_span_id: nil, data: nil)
+      @span_id = SecureRandom.uuid
+      @op = op
+      @description = description
+      @parent_span_id = parent_span_id
+      @data = data || {}
+      @tags = {}
+      @start_timestamp = (Time.now.to_f * 1000).to_i
+      @status = "ok"
+    end
+
+    def finish(status = "ok", status_code: nil)
+      @status = status
+      @status_code = status_code
+      @finish_timestamp = (Time.now.to_f * 1000).to_i
+      @duration_ms = @finish_timestamp - @start_timestamp
+    end
+
+    def to_h
+      {
+        span_id: span_id,
+        parent_span_id: parent_span_id,
+        op: op,
+        description: description,
+        start_timestamp: Time.at(@start_timestamp / 1000.0).utc.iso8601,
+        finish_timestamp: finish_timestamp ? Time.at(finish_timestamp / 1000.0).utc.iso8601 : nil,
+        duration_ms: duration_ms,
+        status: status,
+        status_code: status_code,
+        data: data,
+        tags: tags,
+        timestamp: Time.at(@start_timestamp / 1000.0).utc.iso8601
+      }
+    end
+  end
+
+  class Transaction
+    attr_reader :trace_id, :transaction, :transaction_name, :op, :spans, :tags
+
+    def initialize(client, transaction, transaction_name, op)
+      @client = client
+      @trace_id = SecureRandom.uuid
+      @transaction = transaction
+      @transaction_name = transaction_name || transaction
+      @op = op || "http.server"
+      @spans = []
+      @tags = {}
+      @start_timestamp = (Time.now.to_f * 1000).to_i
+      @status = "ok"
+    end
+
+    def start_span(op, description = "", data: nil)
+      parent = spans.last&.span_id
+      span = Span.new(op, description, parent_span_id: parent, data: data)
+      spans << span
+      span
+    end
+
+    def finish(status = "ok")
+      @status = status
+      finish_timestamp = (Time.now.to_f * 1000).to_i
+      spans.each { |span| span.finish if span.finish_timestamp.nil? }
+      payload = {
+        trace_id: trace_id,
+        transaction: transaction,
+        transaction_name: transaction_name,
+        op: op,
+        start_timestamp: Time.at(@start_timestamp / 1000.0).utc.iso8601,
+        finish_timestamp: Time.at(finish_timestamp / 1000.0).utc.iso8601,
+        duration_ms: finish_timestamp - @start_timestamp,
+        status: @status,
+        environment: @client.instance_variable_get(:@environment),
+        platform: "ruby",
+        sdk_name: SDK_NAME,
+        sdk_version: VERSION,
+        tags: tags,
+        spans: spans.map(&:to_h)
+      }
+      @client.instance_variable_get(:@transport).send_trace(payload)
+    end
+  end
+
+  module Tracing
+    @stack = []
+
+    class << self
+      def start_transaction(transaction, transaction_name = nil, op = "http.server")
+        client = Watchforge.client
+        return nil unless client
+
+        txn = Transaction.new(client, transaction, transaction_name, op)
+        @stack << txn
+        txn
+      end
+
+      def current_transaction
+        @stack.last
+      end
+
+      def finish_transaction(status = "ok")
+        txn = @stack.pop
+        txn&.finish(status)
+      end
+    end
+  end
+end

data/lib/watchforge/transport.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Watchforge
+  class Transport
+    def initialize(dsn, debug: false)
+      @dsn = dsn
+      @parsed = DSN.parse(dsn)
+      @debug = debug
+    end
+
+    def send_event(payload)
+      post(@parsed.events_url, payload)
+    end
+
+    def send_trace(payload)
+      post(@parsed.trace_url, payload)
+    end
+
+    def send_monitor_check_in(payload)
+      post(@parsed.monitor_url, payload)
+    end
+
+    private
+
+    def post(url, payload)
+      override = ENV["WATCHFORGE_API_URL"]
+      url = override if override && url == @parsed.events_url
+
+      uri = URI.parse(url)
+      request = Net::HTTP::Post.new(uri)
+      request["Authorization"] = "DSN #{@dsn}"
+      request["Content-Type"] = "application/json"
+      request.body = JSON.generate(payload)
+
+      puts "[#{SDK_NAME}] POST #{url}" if @debug
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+        response = http.request(request)
+        raise "watchforge ingestion failed: #{response.code}" if response.code.to_i >= 400
+      end
+    end
+  end
+end

data/lib/watchforge/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Watchforge
+  VERSION = "0.1.1"
+  SDK_NAME = "watchforge-ruby-sdk"
+end

data/lib/watchforge.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "watchforge/version"
+require "watchforge/dsn"
+require "watchforge/transport"
+require "watchforge/context"
+require "watchforge/client"
+require "watchforge/tracing"
+require "watchforge/api/client"
+require "watchforge/api/issues"
+require "watchforge/api/monitors"
+require "watchforge/api/traces"
+require "watchforge/api/dashboard"
+
+module Watchforge
+  class << self
+    def init(dsn:, environment: "production", release: nil, debug: false)
+      @client = Client.new(dsn: dsn, environment: environment, release: release, debug: debug)
+    end
+
+    def client
+      @client
+    end
+
+    def capture_exception(error, extra: nil)
+      client&.capture_exception(error, extra: extra)
+    end
+
+    def capture_message(message, level: "info", extra: nil)
+      client&.capture_message(message, level: level, extra: extra)
+    end
+
+    def capture_check_in(monitor_slug:, status: "ok", monitor_config: nil, check_in_id: nil, environment: nil)
+      client&.capture_check_in(
+        monitor_slug: monitor_slug,
+        status: status,
+        monitor_config: monitor_config,
+        check_in_id: check_in_id,
+        environment: environment
+      )
+    end
+
+    def start_transaction(transaction, transaction_name = nil, op = "http.server")
+      Tracing.start_transaction(transaction, transaction_name, op)
+    end
+
+    def get_current_transaction
+      Tracing.current_transaction
+    end
+
+    def finish_transaction(status = "ok")
+      Tracing.finish_transaction(status)
+    end
+
+    def context
+      client&.context || Context.new
+    end
+  end
+end

data/watchforge-ruby-sdk.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "lib/watchforge/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "watchforge-ruby-sdk"
+  spec.version       = ::Watchforge::VERSION
+  spec.authors       = ["WatchForge"]
+  spec.email         = ["support@watchforges.com"]
+  spec.summary       = "WatchForge Ruby SDK for errors, traces, cron monitors, and management APIs"
+  spec.description   = spec.summary
+  spec.homepage      = "https://watchforges.com"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata = {
+    "source_code_uri" => "https://github.com/watchforges/watchforge-ruby-sdk",
+    "rubygems_mfa_required" => "true"
+  }
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject { |f| f.start_with?("examples/") }
+  rescue StandardError
+    Dir["lib/**/*.rb", "README.md", "LICENSE", "PUBLISHING.md"]
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "json", "~> 2.6"
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: watchforge-ruby-sdk
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- WatchForge
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-06-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: WatchForge Ruby SDK for errors, traces, cron monitors, and management
+  APIs
+email:
+- support@watchforges.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/watchforge.rb
+- lib/watchforge/api/client.rb
+- lib/watchforge/api/dashboard.rb
+- lib/watchforge/api/issues.rb
+- lib/watchforge/api/monitors.rb
+- lib/watchforge/api/traces.rb
+- lib/watchforge/client.rb
+- lib/watchforge/context.rb
+- lib/watchforge/dsn.rb
+- lib/watchforge/tracing.rb
+- lib/watchforge/transport.rb
+- lib/watchforge/version.rb
+- watchforge-ruby-sdk.gemspec
+homepage: https://watchforges.com
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/watchforges/watchforge-ruby-sdk
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+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: WatchForge Ruby SDK for errors, traces, cron monitors, and management APIs
+test_files: []