doow_track 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: be141768a653090f70f87d0970d3e5bfbfbfcb58379b98ac45e90c144ee77eb9
+  data.tar.gz: d8582db5050a500a37fa1e747b2d84a72ac832b3e97e1ade7146081637639365
+SHA512:
+  metadata.gz: c2781c02faae7ee84799985834197da9c84fbe0bae637b8dc326e038d79d7d6938348a7b2db94bf8f1453c645fdc8d905049c6d46f31cfc30c7d627683aafa5a
+  data.tar.gz: 076d1ff26f3214a496ec16b5ce764e72a362582487d8fa7971b3f6dda9f306eae5509310b7eb18013bd7e35d3eebb98fddffc1673cd2af4a267b4d272544e7ad

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Doow
+
+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,150 @@
+# Doow Track Ruby SDK
+
+[![Gem Version](https://badge.fury.io/rb/doow_track.svg)](https://rubygems.org/gems/doow_track)
+[![Ruby](https://img.shields.io/badge/Ruby-3.0+-red)](https://www.ruby-lang.org/)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+Official Ruby SDK for [Doow](https://doow.co) usage telemetry and management.
+
+## Features
+
+| Feature | Description |
+|---------|-------------|
+| **Ruby 3.0+** | Modern Ruby with pattern matching and endless methods |
+| **Batching** | Events queued and sent in configurable batches |
+| **Compression** | Automatic gzip for payloads >1KB |
+| **Retries** | Exponential backoff with configurable retry count |
+| **Type Safety** | Struct-based models |
+| **Sidecar** | Executable for stdin/file/tcp input modes |
+
+---
+
+## Installation
+
+```ruby
+gem 'doow_track'
+```
+
+Or install directly:
+
+```bash
+gem install doow_track
+```
+
+---
+
+## Quick Start
+
+### Track Usage Events
+
+```ruby
+require 'doow_track'
+
+tracker = DoowTrack::Tracker.new('dk_your_api_key')
+
+# Simple event
+tracker.track(DoowTrack::TrackEvent.new(
+  metric: 'api_calls',
+  quantity: 1,
+  license_id: 'lic_abc123'
+))
+
+# Rich event with metadata
+tracker.track(DoowTrack::TrackEvent.new(
+  metric: 'tokens_generated',
+  quantity: 1500,
+  license_id: 'lic_abc123',
+  unit: 'tokens',
+  attribution: { model: 'gpt-4', region: 'us-east-1' },
+  metadata: { request_id: 'req_xyz' }
+))
+
+tracker.shutdown
+```
+
+### Management API
+
+```ruby
+require 'doow_track'
+
+mgmt = DoowTrack::Management.new('dk_your_api_key')
+
+# Create an app
+app = mgmt.apps.create(
+  name: 'My SaaS Platform',
+  description: 'Usage-based billing'
+)
+puts "Created app: #{app.id}"
+
+# Create a contract with license
+contract = mgmt.contracts.create(app.id,
+  title: 'Enterprise Plan',
+  contract_type: DoowTrack::ContractType::PAY_AS_YOU_GO,
+  licenses: [
+    { name: 'API Usage', license_type: DoowTrack::LicenseType::USAGE_BASED }
+  ]
+)
+
+license_id = contract.licenses.first.id
+
+# Create a metric
+metric = mgmt.metrics.create(license_id, metric_type: 'api_calls')
+puts "Created metric: #{metric.id}"
+```
+
+---
+
+## Configuration
+
+### Tracker Options
+
+```ruby
+tracker = DoowTrack::Tracker.new('dk_your_api_key',
+  endpoint: 'https://api.doow.co',
+  enabled: true,
+  debug: true,
+  flush_at: 20,
+  flush_interval: 10,
+  max_queue_size: 10_000,
+  timeout: 10,
+  retry_count: 3,
+  disable_compression: false,
+  attribution: { service: 'api-gateway' },
+  on_error: ->(e) { Rails.logger.error("Tracker error: #{e.message}") }
+)
+```
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `DOOW_TRACK_API_KEY` | API key (overrides constructor) | — |
+| `DOOW_TRACK_ENDPOINT` | Custom API endpoint | `https://api.doow.co` |
+| `DOOW_TRACK_DISABLED` | Set `true` to disable tracking | `false` |
+| `DOOW_TRACK_DEBUG` | Set `true` for debug logs | `false` |
+
+---
+
+## Error Handling
+
+```ruby
+begin
+  app = mgmt.apps.get('invalid_id')
+rescue DoowTrack::Error => e
+  if e.not_found?
+    puts "App not found"
+  elsif e.unauthorized?
+    puts "Invalid API key"
+  elsif e.rate_limited?
+    puts "Rate limited"
+  else
+    puts "Error: #{e.message}"
+  end
+end
+```
+
+---
+
+## License
+
+MIT

data/lib/doow_track/error.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module DoowTrack
+  class Error < StandardError
+    attr_reader :status_code, :error_class
+
+    def initialize(message, status_code: 0, error_class: nil)
+      super(message)
+      @status_code = status_code
+      @error_class = error_class
+    end
+
+    def not_found?
+      status_code == 404
+    end
+
+    def unauthorized?
+      status_code == 401
+    end
+
+    def forbidden?
+      status_code == 403
+    end
+
+    def rate_limited?
+      status_code == 429
+    end
+
+    def server_error?
+      status_code >= 500
+    end
+  end
+end

data/lib/doow_track/management.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module DoowTrack
+  class Management
+    DEFAULT_OPTIONS = {
+      endpoint: "https://api.doow.co",
+      timeout: 30,
+      retry_count: 3,
+      debug: false
+    }.freeze
+
+    def initialize(api_key, **options)
+      @api_key = ENV["DOOW_TRACK_API_KEY"] || api_key
+      @options = DEFAULT_OPTIONS.merge(options)
+      @options[:endpoint] = ENV["DOOW_TRACK_ENDPOINT"] if ENV["DOOW_TRACK_ENDPOINT"]
+      @options[:debug] = true if ENV["DOOW_TRACK_DEBUG"] == "true"
+
+      raise Error, "Invalid API key format. Must start with 'dk_'." unless @api_key&.start_with?("dk_")
+    end
+
+    def apps
+      AppsResource.new(self)
+    end
+
+    def contracts
+      ContractsResource.new(self)
+    end
+
+    def licenses
+      LicensesResource.new(self)
+    end
+
+    def metrics
+      MetricsResource.new(self)
+    end
+
+    def expenses
+      ExpensesResource.new(self)
+    end
+
+    def request(method, path, body: nil)
+      url = URI("#{@options[:endpoint].chomp('/')}/sdk#{path}")
+      log("[doow/management] #{method.upcase} #{path}")
+
+      (@options[:retry_count] + 1).times do |attempt|
+        begin
+          http = Net::HTTP.new(url.host, url.port)
+          http.use_ssl = url.scheme == "https"
+          http.open_timeout = @options[:timeout]
+          http.read_timeout = @options[:timeout]
+
+          request = case method
+                    when :get then Net::HTTP::Get.new(url)
+                    when :post then Net::HTTP::Post.new(url)
+                    when :patch then Net::HTTP::Patch.new(url)
+                    when :delete then Net::HTTP::Delete.new(url)
+                    end
+
+          request["Authorization"] = "Bearer #{@api_key}"
+          request["Content-Type"] = "application/json"
+          request.body = body.to_json if body
+
+          response = http.request(request)
+
+          if response.code.to_i >= 200 && response.code.to_i < 300
+            return nil if response.body.nil? || response.body.empty?
+            return JSON.parse(response.body, symbolize_names: true)
+          end
+
+          if response.code.to_i >= 500 && attempt < @options[:retry_count]
+            sleep(2**attempt)
+            next
+          end
+
+          raise Error.new("API error: #{response.body}", status_code: response.code.to_i)
+        rescue StandardError => e
+          raise if e.is_a?(Error)
+          if attempt < @options[:retry_count]
+            sleep(2**attempt)
+            next
+          end
+          raise Error.new("Request failed: #{e.message}")
+        end
+      end
+    end
+
+    private
+
+    def log(message)
+      $stderr.puts(message) if @options[:debug]
+    end
+  end
+
+  class AppsResource
+    def initialize(mgmt)
+      @mgmt = mgmt
+    end
+
+    def list(cursor: nil, limit: 50)
+      path = "/apps?limit=#{limit}"
+      path += "&cursor=#{cursor}" if cursor
+      data = @mgmt.request(:get, path)
+      parse_paginated(data, App)
+    end
+
+    def get(id)
+      data = @mgmt.request(:get, "/apps/#{id}")
+      App.new(**data)
+    end
+
+    def create(name:, **attrs)
+      data = @mgmt.request(:post, "/apps", body: { name: name, **attrs })
+      App.new(**data)
+    end
+
+    def update(id, **attrs)
+      data = @mgmt.request(:patch, "/apps/#{id}", body: attrs)
+      App.new(**data)
+    end
+
+    def delete(id)
+      @mgmt.request(:delete, "/apps/#{id}")
+    end
+
+    private
+
+    def parse_paginated(data, klass)
+      PaginatedResponse.new(
+        data: data[:data].map { |d| klass.new(**d) },
+        next_cursor: data[:next_cursor],
+        has_more: data[:has_more]
+      )
+    end
+  end
+
+  class ContractsResource
+    def initialize(mgmt)
+      @mgmt = mgmt
+    end
+
+    def list_by_app(app_id, cursor: nil, limit: 50)
+      path = "/apps/#{app_id}/contracts?limit=#{limit}"
+      path += "&cursor=#{cursor}" if cursor
+      data = @mgmt.request(:get, path)
+      parse_paginated(data)
+    end
+
+    def get(id)
+      data = @mgmt.request(:get, "/contracts/#{id}")
+      parse_contract(data)
+    end
+
+    def create(app_id, title:, contract_type: ContractType::PAY_AS_YOU_GO, licenses: [])
+      data = @mgmt.request(:post, "/apps/#{app_id}/contracts", body: {
+        title: title,
+        contract_type: contract_type,
+        licenses: licenses
+      })
+      parse_contract(data)
+    end
+
+    def delete(id)
+      @mgmt.request(:delete, "/contracts/#{id}")
+    end
+
+    private
+
+    def parse_contract(data)
+      licenses = (data[:licenses] || []).map { |l| License.new(**l) }
+      Contract.new(**data.merge(licenses: licenses))
+    end
+
+    def parse_paginated(data)
+      PaginatedResponse.new(
+        data: data[:data].map { |d| parse_contract(d) },
+        next_cursor: data[:next_cursor],
+        has_more: data[:has_more]
+      )
+    end
+  end
+
+  class LicensesResource
+    def initialize(mgmt)
+      @mgmt = mgmt
+    end
+
+    def list(cursor: nil, limit: 50)
+      path = "/licenses?limit=#{limit}"
+      path += "&cursor=#{cursor}" if cursor
+      data = @mgmt.request(:get, path)
+      PaginatedResponse.new(
+        data: data[:data].map { |d| License.new(**d) },
+        next_cursor: data[:next_cursor],
+        has_more: data[:has_more]
+      )
+    end
+
+    def get(id)
+      data = @mgmt.request(:get, "/licenses/#{id}")
+      License.new(**data)
+    end
+  end
+
+  class MetricsResource
+    def initialize(mgmt)
+      @mgmt = mgmt
+    end
+
+    def list_by_license(license_id, cursor: nil, limit: 50)
+      path = "/licenses/#{license_id}/metrics?limit=#{limit}"
+      path += "&cursor=#{cursor}" if cursor
+      data = @mgmt.request(:get, path)
+      PaginatedResponse.new(
+        data: data[:data].map { |d| Metric.new(**d) },
+        next_cursor: data[:next_cursor],
+        has_more: data[:has_more]
+      )
+    end
+
+    def get(id)
+      data = @mgmt.request(:get, "/metrics/#{id}")
+      Metric.new(**data)
+    end
+
+    def create(license_id, metric_type:, **attrs)
+      data = @mgmt.request(:post, "/licenses/#{license_id}/metrics", body: { metric_type: metric_type, **attrs })
+      Metric.new(**data)
+    end
+
+    def delete(id)
+      @mgmt.request(:delete, "/metrics/#{id}")
+    end
+  end
+
+  class ExpensesResource
+    def initialize(mgmt)
+      @mgmt = mgmt
+    end
+
+    def list_by_app(app_id, cursor: nil, limit: 50)
+      path = "/apps/#{app_id}/expenses?limit=#{limit}"
+      path += "&cursor=#{cursor}" if cursor
+      data = @mgmt.request(:get, path)
+      PaginatedResponse.new(
+        data: data[:data].map { |d| Expense.new(**d) },
+        next_cursor: data[:next_cursor],
+        has_more: data[:has_more]
+      )
+    end
+  end
+end

data/lib/doow_track/tracker.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "zlib"
+require "uri"
+
+module DoowTrack
+  class Tracker
+    DEFAULT_OPTIONS = {
+      endpoint: "https://api.doow.co",
+      enabled: true,
+      debug: false,
+      flush_at: 20,
+      flush_interval: 10,
+      max_queue_size: 10_000,
+      timeout: 10,
+      retry_count: 3,
+      disable_compression: false,
+      attribution: nil,
+      on_error: nil
+    }.freeze
+
+    def initialize(api_key, **options)
+      @api_key = ENV["DOOW_TRACK_API_KEY"] || api_key
+      @options = DEFAULT_OPTIONS.merge(options)
+      @options[:endpoint] = ENV["DOOW_TRACK_ENDPOINT"] if ENV["DOOW_TRACK_ENDPOINT"]
+      @options[:enabled] = false if ENV["DOOW_TRACK_DISABLED"] == "true"
+      @options[:debug] = true if ENV["DOOW_TRACK_DEBUG"] == "true"
+
+      raise Error, "Invalid API key format. Must start with 'dk_'." unless @api_key&.start_with?("dk_")
+
+      @buffer = []
+      @mutex = Mutex.new
+      @flusher = start_flusher
+    end
+
+    def track(event)
+      return unless @options[:enabled]
+
+      final_event = event.is_a?(Hash) ? TrackEvent.new(**event) : event
+      final_event = TrackEvent.new(
+        **final_event.to_h.merge(
+          timestamp: final_event.timestamp || Time.now.utc,
+          attribution: merge_attribution(final_event.attribution)
+        )
+      )
+
+      @mutex.synchronize do
+        if @buffer.size >= @options[:max_queue_size]
+          log("[doow-track] Queue full, dropping event")
+          return
+        end
+        @buffer << final_event
+        flush_async if @buffer.size >= @options[:flush_at]
+      end
+    end
+
+    def flush
+      batch = nil
+      @mutex.synchronize do
+        return if @buffer.empty?
+        batch = @buffer.dup
+        @buffer.clear
+      end
+      send_batch(batch) if batch
+    end
+
+    def shutdown
+      @flusher&.kill
+      flush
+    end
+
+    private
+
+    def start_flusher
+      return nil if @options[:flush_interval] <= 0
+
+      Thread.new do
+        loop do
+          sleep @options[:flush_interval]
+          flush
+        end
+      end
+    end
+
+    def flush_async
+      Thread.new { flush }
+    end
+
+    def send_batch(batch)
+      url = URI("#{@options[:endpoint].chomp('/')}/telemetry/events")
+      payload = { events: batch.map(&:to_h) }
+      json = payload.to_json
+
+      (@options[:retry_count] + 1).times do |attempt|
+        begin
+          http = Net::HTTP.new(url.host, url.port)
+          http.use_ssl = url.scheme == "https"
+          http.open_timeout = @options[:timeout]
+          http.read_timeout = @options[:timeout]
+
+          request = Net::HTTP::Post.new(url)
+          request["Authorization"] = "Bearer #{@api_key}"
+          request["Content-Type"] = "application/json"
+
+          body = json
+          if !@options[:disable_compression] && json.bytesize > 1024
+            body = Zlib::Deflate.deflate(json, Zlib::DEFAULT_COMPRESSION)
+            request["Content-Encoding"] = "gzip"
+          end
+          request.body = body
+
+          response = http.request(request)
+
+          if response.code.to_i >= 200 && response.code.to_i < 300
+            log("[doow-track] Flushed #{batch.size} events")
+            return
+          end
+
+          if response.code.to_i >= 500 && attempt < @options[:retry_count]
+            sleep(2**attempt)
+            next
+          end
+
+          raise Error.new("API error: #{response.body}", status_code: response.code.to_i)
+        rescue StandardError => e
+          if attempt < @options[:retry_count]
+            sleep(2**attempt)
+            next
+          end
+          @options[:on_error]&.call(e)
+          log("[doow-track] Error: #{e.message}")
+        end
+      end
+    end
+
+    def merge_attribution(event_attribution)
+      return event_attribution if @options[:attribution].nil?
+      return @options[:attribution] if event_attribution.nil?
+      @options[:attribution].merge(event_attribution)
+    end
+
+    def log(message)
+      $stderr.puts(message) if @options[:debug]
+    end
+  end
+end

data/lib/doow_track/types.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module DoowTrack
+  module EventKind
+    USAGE = "USAGE"
+    ADJUSTMENT = "ADJUSTMENT"
+  end
+
+  module ContractType
+    PAY_AS_YOU_GO = "PAY_AS_YOU_GO"
+    ENTERPRISE = "ENTERPRISE"
+    UNKNOWN = "UNKNOWN"
+  end
+
+  # License types for SDK creation. SDK only supports USAGE_BASED.
+  module LicenseType
+    USAGE_BASED = "USAGE_BASED"
+  end
+
+  # All license types (for responses that may include UI-created licenses)
+  module AllLicenseType
+    USAGE_BASED = "USAGE_BASED"
+    SEAT_BASED = "SEAT_BASED"
+    PREPAID_CREDITS = "PREPAID_CREDITS"
+    FLAT_RATE = "FLAT_RATE"
+  end
+
+  module UsageAggregationType
+    SUM = "SUM"
+    MAX = "MAX"
+    CUMULATIVE = "CUMULATIVE"
+  end
+
+  module RateKind
+    PER_UNIT = "PER_UNIT"
+    FLAT_FEE = "FLAT_FEE"
+    PER_SEAT = "PER_SEAT"
+    TIERED = "TIERED"
+    VOLUME = "VOLUME"
+  end
+
+  module EntitlementPeriod
+    MONTHLY = "MONTHLY"
+    YEARLY = "YEARLY"
+    QUARTERLY = "QUARTERLY"
+    WEEKLY = "WEEKLY"
+    DAILY = "DAILY"
+    ONE_TIME = "ONE_TIME"
+  end
+
+  module CarryoverPolicy
+    EXPIRE_AT_PERIOD_END = "EXPIRE_AT_PERIOD_END"
+    ROLLOVER = "ROLLOVER"
+    ROLLOVER_CAPPED = "ROLLOVER_CAPPED"
+  end
+
+  module CostAmortization
+    PRORATA = "PRORATA"
+    MONTHS = "MONTHS"
+    QUARTER = "QUARTER"
+    YEARS = "YEARS"
+  end
+
+  MetricTupleHint = Struct.new(:app_name, :license_name, :metric_name, keyword_init: true) do
+    def to_h
+      { app_name: app_name, license_name: license_name, metric_name: metric_name }.compact
+    end
+  end
+
+  TrackEvent = Struct.new(
+    :metric, :quantity, :license_id, :unit, :kind,
+    :timestamp, :source_system, :metric_tuple_hint,
+    :attribution, :metadata,
+    keyword_init: true
+  ) do
+    def to_h
+      {
+        metric: metric,
+        quantity: quantity,
+        license_id: license_id,
+        unit: unit,
+        kind: kind || EventKind::USAGE,
+        timestamp: timestamp&.iso8601 || Time.now.utc.iso8601,
+        source_system: source_system,
+        metric_tuple_hint: metric_tuple_hint&.to_h,
+        attribution: attribution,
+        metadata: metadata
+      }.compact
+    end
+  end
+
+  class App
+    attr_accessor :id, :name, :description, :logo_url, :website, :categories, :saas_application_id, :created_at, :updated_at
+
+    def initialize(**attrs)
+      attrs.each { |k, v| send("#{k}=", v) if respond_to?("#{k}=") }
+    end
+  end
+
+  class License
+    attr_accessor :id, :name, :license_type, :contract_id, :seats, :price_per_seat, :total_cost,
+                  :discount, :discount_amount, :discounted_cost, :original_cost, :tenure,
+                  :seats_included_in_base_plan, :created_at, :updated_at
+
+    def initialize(**attrs)
+      attrs.each { |k, v| send("#{k}=", v) if respond_to?("#{k}=") }
+    end
+  end
+
+  class Expense
+    attr_accessor :id, :app_id, :contract_id, :license_id, :total, :date, :month, :year,
+                  :description, :transaction_id, :vendor, :payment_channel, :currency,
+                  :created_at, :updated_at
+
+    def initialize(**attrs)
+      @currency = "USD"
+      attrs.each { |k, v| send("#{k}=", v) if respond_to?("#{k}=") }
+    end
+  end
+
+  class Contract
+    attr_accessor :id, :app_id, :title, :contract_type, :start_date, :end_date, :currency,
+                  :cost, :cost_break_down, :cost_amortization, :add_ons, :add_ons_total_cost,
+                  :total_contract_cost, :total_discount_amount, :total_original_cost,
+                  :licenses, :expenses, :created_at, :updated_at
+
+    def initialize(**attrs)
+      @licenses = []
+      @expenses = []
+      attrs.each { |k, v| send("#{k}=", v) if respond_to?("#{k}=") }
+    end
+  end
+
+  class Metric
+    attr_accessor :id, :license_id, :metric_type, :usage_aggregation_type, :rate_kind,
+                  :entitlement_period, :carryover_policy, :usage_rate, :usage_limit,
+                  :usage_included, :per_unit_cap, :usage_rate_is_estimated,
+                  :usage_custom_unit_label, :expected_emission_interval_minutes,
+                  :created_at, :updated_at
+
+    def initialize(**attrs)
+      attrs.each { |k, v| send("#{k}=", v) if respond_to?("#{k}=") }
+    end
+  end
+
+  class PaginatedResponse
+    attr_accessor :data, :cursor, :has_more
+
+    def initialize(**attrs)
+      attrs.each { |k, v| send("#{k}=", v) if respond_to?("#{k}=") }
+    end
+  end
+end

data/lib/doow_track/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DoowTrack
+  VERSION = "0.1.0"
+end

data/lib/doow_track.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "doow_track/version"
+require_relative "doow_track/error"
+require_relative "doow_track/types"
+require_relative "doow_track/tracker"
+require_relative "doow_track/management"
+
+module DoowTrack
+  class << self
+    attr_accessor :api_key, :endpoint, :debug
+
+    def configure
+      yield self
+    end
+  end
+
+  self.endpoint = "https://api.doow.co"
+  self.debug = false
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: doow_track
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Doow
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-09-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+description: Track usage events and manage apps, contracts, licenses, and metrics
+  with the Doow API
+email:
+- dev@doow.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/doow_track.rb
+- lib/doow_track/error.rb
+- lib/doow_track/management.rb
+- lib/doow_track/tracker.rb
+- lib/doow_track/types.rb
+- lib/doow_track/version.rb
+homepage: https://github.com/Doow-Dev/doow-track-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Doow-Dev/doow-track-ruby
+  source_code_uri: https://github.com/Doow-Dev/doow-track-ruby
+  changelog_uri: https://github.com/Doow-Dev/doow-track-ruby/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Official Ruby SDK for Doow usage telemetry and management
+test_files: []