amlexia 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d25d8c8ded5e08e6a76090728c11816ba7267fdd2cc05de42ca538561f57c171
+  data.tar.gz: 4cbe93f9d3d9a7cb0b1f6204f218a7ae099a53f44cfa33d5404e6a7e48e5ad4c
+SHA512:
+  metadata.gz: 55e69475ca93b746803e3d25affdade613e51b67b09debce0a75020ece7353b9318f71aa183331410b9813b60a6467b9eab93a9c2f5bc32bc1790edf24301ffc
+  data.tar.gz: aa4acd6b0c9d2dc8576a63f2a29375f5b855331f4c3e1de8a64918dd3c497a9a7379e29e78e5446fca63d87c0235c15ca64eeaf5fad1065580f01e05de55743b

data/LICENSE

@@ -0,0 +1,38 @@
+Amlexia Software License Agreement (SDK)
+
+Copyright (c) 2026 Amlexia. All rights reserved.
+
+IMPORTANT: This software is proprietary and is NOT open source. You may not
+use, copy, modify, merge, publish, distribute, sublicense, or sell copies of
+this software except as expressly permitted below.
+
+1. Grant
+   Amlexia grants you a limited, non-exclusive, non-transferable, revocable
+   license to install and use this SDK solely to send telemetry to and integrate
+   with the Amlexia service (https://amlexia.com) in accordance with the
+   Amlexia Terms of Service (https://amlexia.com/terms).
+
+2. Restrictions
+   You may not:
+   (a) use the SDK except with an active Amlexia account and valid credentials;
+   (b) remove or alter proprietary notices;
+   (c) reverse engineer, decompile, or disassemble the SDK except where law
+       expressly permits and cannot be waived;
+   (d) redistribute, sublicense, or make the SDK available to third parties as
+       a standalone product or competing service;
+   (e) use the SDK to build a product that substitutes for Amlexia.
+
+3. Ownership
+   Amlexia and its licensors retain all rights, title, and interest in the SDK.
+
+4. Termination
+   This license terminates automatically if you breach these terms or your
+   Amlexia account is terminated. Upon termination, you must cease use and
+   destroy copies in your possession.
+
+5. Disclaimer
+   THE SDK IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. SEE
+   https://amlexia.com/terms FOR LIMITATION OF LIABILITY.
+
+6. Contact
+   Support: support@amlexia.com

data/README.md

@@ -0,0 +1,23 @@
+# Amlexia Ruby SDK
+
+```ruby
+require "amlexia"
+
+client = Amlexia::Client.from_env
+
+client.track(
+  endpoint: "/v1/chat/completions",
+  method: "POST",
+  status_code: 200,
+  latency_ms: 340,
+  provider: "openai",
+  model_name: "gpt-4o-mini",
+  tokens_input: 120,
+  tokens_output: 45
+)
+
+Amlexia::OpenAI.track_openai_completion(client, model: "gpt-4o-mini", status_code: 200, latency_ms: 340, usage: { prompt_tokens: 120, completion_tokens: 45 })
+Amlexia::Health.check_ingest_health
+```
+
+CLI: `bundle exec amlexia health`

data/amlexia.gemspec

@@ -0,0 +1,21 @@
+require_relative "lib/amlexia/version"
+
+Gem::Specification.new do |s|
+  s.name        = "amlexia"
+  s.version     = Amlexia::VERSION
+  s.summary     = "Official Amlexia Ruby SDK — API, AI, and infrastructure observability"
+  s.description = "Track HTTP APIs, LLM providers, payments, and webhooks with traces, latency, and cost fields."
+  s.authors     = ["Amlexia"]
+  s.email       = "support@amlexia.com"
+  s.files       = Dir["lib/**/*.rb", "exe/amlexia", "README.md", "LICENSE"] + ["amlexia.gemspec"]
+  s.executables = ["amlexia"]
+  s.bindir      = "exe"
+  s.homepage    = "https://amlexia.com"
+  s.metadata    = {
+    "source_code_uri" => "https://github.com/Amlexia/Amlexia",
+    "documentation_uri" => "https://docs.amlexia.com/sdk/ruby",
+    "changelog_uri" => "https://docs.amlexia.com/changelog"
+  }
+  s.license     = "Nonstandard"
+  s.required_ruby_version = ">= 3.0"
+end

data/exe/amlexia

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+require_relative "../lib/amlexia"
+
+ingest = ENV.fetch("AMLEXIA_INGEST_URL", Amlexia::Client::DEFAULT_INGEST_URL)
+cmd = ARGV[0] || "health"
+
+case cmd
+when "version"
+  puts Amlexia::VERSION
+when "health"
+  result = Amlexia::Health.check_ingest_health(ingest_url: ingest)
+  puts JSON.pretty_generate({ ingestUrl: ingest, **result })
+  exit(result[:ok] ? 0 : 1)
+else
+  warn "Usage: amlexia [health|version]"
+  exit 1
+end

data/lib/amlexia/anthropic.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Amlexia
+  module Anthropic
+    module_function
+
+    def track_anthropic_message(client, model:, status_code:, latency_ms:, usage: {}, cost_usd: nil, **kwargs)
+      event = Cost.enrich_event(
+        cost_usd: cost_usd,
+        model_name: model,
+        provider: "anthropic",
+        tokens_input: usage[:input_tokens],
+        tokens_output: usage[:output_tokens]
+      )
+      client.track(
+        endpoint: "/v1/messages",
+        method: "POST",
+        status_code: status_code,
+        latency_ms: latency_ms,
+        provider: "anthropic",
+        model_name: model,
+        tokens_input: usage[:input_tokens],
+        tokens_output: usage[:output_tokens],
+        cost_usd: event[:cost_usd],
+        **kwargs
+      )
+    end
+  end
+end

data/lib/amlexia/client.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+require "thread"
+
+module Amlexia
+  class Client
+    DEFAULT_INGEST_URL = "https://ingest.amlexia.com"
+    DEFAULT_FLUSH_SECONDS = 5
+    DEFAULT_BATCH_SIZE = 50
+    DEFAULT_MAX_RETRIES = 5
+
+    attr_reader :diagnostic
+
+    def initialize(
+      sdk_key:,
+      ingest_url: DEFAULT_INGEST_URL,
+      flush_interval_seconds: DEFAULT_FLUSH_SECONDS,
+      max_batch_size: DEFAULT_BATCH_SIZE,
+      max_retries: DEFAULT_MAX_RETRIES,
+      environment: nil,
+      release_version: nil,
+      default_session_id: nil,
+      sample_rate: 1.0,
+      diagnostic: false
+    )
+      @sdk_key = sdk_key
+      @ingest_url = ingest_url.chomp("/")
+      @flush_interval = flush_interval_seconds
+      @max_batch_size = max_batch_size
+      @max_retries = max_retries
+      @environment = environment
+      @release_version = release_version
+      @default_session_id = default_session_id
+      @sample_rate = sample_rate
+      @diagnostic = DiagnosticState.new(enabled: diagnostic, events_buffered: 0)
+      @buffer = []
+      @mutex = Mutex.new
+      @flushing = false
+      @stop = false
+      @flush_thread = Thread.new { flush_loop }
+    end
+
+    def self.from_env
+      new(
+        sdk_key: ENV.fetch("AMLEXIA_SDK_KEY"),
+        ingest_url: ENV.fetch("AMLEXIA_INGEST_URL", DEFAULT_INGEST_URL),
+        environment: ENV["AMLEXIA_ENVIRONMENT"],
+        release_version: ENV["AMLEXIA_RELEASE"]
+      )
+    end
+
+    def track(**event)
+      return unless Sampling.should_sample(@sample_rate)
+
+      event = Cost.enrich_event(event)
+      event[:timestamp] ||= Time.now.to_i
+      event[:environment] ||= @environment
+      event[:release_version] ||= @release_version
+      event[:session_id] ||= @default_session_id
+      event[:method] = event[:method].to_s.upcase
+
+      should_flush = false
+      @mutex.synchronize do
+        @buffer << event
+        should_flush = @buffer.length >= @max_batch_size
+      end
+      flush if should_flush
+    end
+
+    def get_diagnostic_snapshot
+      @mutex.synchronize do
+        @diagnostic.events_buffered = @buffer.length
+        DiagnosticState.new(
+          enabled: @diagnostic.enabled,
+          events_buffered: @diagnostic.events_buffered,
+          last_flush_at: @diagnostic.last_flush_at,
+          last_error: @diagnostic.last_error
+        )
+      end
+    end
+
+    def flush
+      events = nil
+      @mutex.synchronize do
+        return if @flushing || @buffer.empty?
+
+        @flushing = true
+        events = @buffer.shift(@max_batch_size)
+      end
+      post_events(events)
+    ensure
+      @mutex.synchronize { @flushing = false }
+    end
+
+    def shutdown
+      @stop = true
+      @flush_thread.join
+      flush until @mutex.synchronize { @buffer.empty? }
+    end
+
+    private
+
+    def flush_loop
+      until @stop
+        sleep @flush_interval
+        flush
+      rescue StandardError
+        nil
+      end
+    end
+
+    def post_events(events)
+      post("/v1/events", { sdk_key: @sdk_key, events: events })
+      @diagnostic.last_flush_at = (Time.now.to_f * 1000).to_i
+      @diagnostic.last_error = nil
+      warn "[amlexia] flushed #{events.length} events" if @diagnostic.enabled
+    rescue StandardError => e
+      @diagnostic.last_error = e.message
+      warn "[amlexia] flush failed: #{e.message}" if @diagnostic.enabled
+      @mutex.synchronize { @buffer = events + @buffer }
+      raise
+    end
+
+    def post(path, body)
+      uri = URI("#{@ingest_url}#{path}")
+      data = JSON.generate(body)
+      attempt = 0
+      last_error = nil
+      while attempt < @max_retries
+        begin
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          req = Net::HTTP::Post.new(uri)
+          req["Content-Type"] = "application/json"
+          req.body = data
+          res = http.request(req)
+          return true if res.is_a?(Net::HTTPSuccess)
+          raise "Invalid SDK key" if res.code.to_i == 401
+          raise "Usage limit exceeded" if res.code.to_i == 402
+          raise "Ingest failed: #{res.code} #{res.body}" if res.code.to_i >= 400 && res.code.to_i < 500
+
+          last_error = "HTTP #{res.code}"
+        rescue StandardError => e
+          last_error = e.message
+          raise e if attempt >= @max_retries - 1
+        end
+        sleep([2**attempt, 30].min)
+        attempt += 1
+      end
+      raise last_error || "Failed to send events after retries"
+    end
+  end
+end

data/lib/amlexia/cost.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Amlexia
+  MODEL_PRICES = {
+    "gpt-4o-mini" => { input: 0.15, output: 0.6 },
+    "gpt-4o" => { input: 2.5, output: 10 },
+    "claude-3-5-haiku" => { input: 0.8, output: 4 },
+    "claude-3-5-sonnet" => { input: 3, output: 15 },
+    "gemini-2.0-flash" => { input: 0.1, output: 0.4 }
+  }.freeze
+
+  PROVIDER_DEFAULT_MODEL = {
+    "openai" => "gpt-4o-mini",
+    "anthropic" => "claude-3-5-haiku",
+    "google" => "gemini-2.0-flash"
+  }.freeze
+
+  module Cost
+    module_function
+
+    def estimate_cost_usd(cost_usd:, model_name: nil, provider: nil, tokens_input: nil, tokens_output: nil, total_tokens: nil)
+      return [cost_usd, "reported"] if cost_usd && cost_usd.positive?
+
+      key = (model_name || "").downcase
+      price = MODEL_PRICES[key]
+      price ||= MODEL_PRICES[PROVIDER_DEFAULT_MODEL[(provider || "").downcase]] if provider
+      return [cost_usd, nil] unless price
+
+      inp = tokens_input || 0
+      out = tokens_output || 0
+      if inp.zero? && out.zero?
+        return [cost_usd, nil] unless total_tokens&.positive?
+
+        blended = (price[:input] + price[:output]) / 2.0
+        return [(total_tokens / 1_000_000.0) * blended, "estimated"]
+      end
+
+      est = (inp / 1_000_000.0) * price[:input] + (out / 1_000_000.0) * price[:output]
+      [est.round(8), "estimated"]
+    end
+
+    def enrich_event(event)
+      cost, = estimate_cost_usd(
+        cost_usd: event[:cost_usd],
+        model_name: event[:model_name],
+        provider: event[:provider] || event[:provider_name],
+        tokens_input: event[:tokens_input],
+        tokens_output: event[:tokens_output],
+        total_tokens: event[:total_tokens]
+      )
+      event[:cost_usd] = cost if cost
+      event
+    end
+  end
+end

data/lib/amlexia/diagnostic.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Amlexia
+  DiagnosticState = Struct.new(:enabled, :events_buffered, :last_flush_at, :last_error, keyword_init: true)
+end

data/lib/amlexia/health.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module Amlexia
+  module Health
+    module_function
+
+    def check_ingest_health(ingest_url: Client::DEFAULT_INGEST_URL, timeout: 5)
+      uri = URI("#{ingest_url.to_s.chomp('/')}/health")
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+      res = http.get(uri.path)
+      latency = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).to_i
+      { ok: res.is_a?(Net::HTTPSuccess), status: res.code.to_i, latency_ms: latency }
+    rescue StandardError
+      latency = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).to_i
+      { ok: false, status: 0, latency_ms: latency }
+    end
+  end
+end

data/lib/amlexia/http_wrap.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module Amlexia
+  module HttpWrap
+    module_function
+
+    def provider_from_url(url)
+      return "openai" if url.include?("openai")
+      return "anthropic" if url.include?("anthropic")
+      return "stripe" if url.include?("stripe")
+
+      nil
+    end
+
+    def wrap_net_http(client)
+      Net::HTTP.class_eval do
+        alias_method :amlexia_original_request, :request unless method_defined?(:amlexia_original_request)
+
+        define_method(:request) do |req, body = nil, &block|
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          status = 500
+          err = nil
+          begin
+            res = amlexia_original_request(req, body, &block)
+            status = res.code.to_i
+            res
+          rescue StandardError => e
+            err = e.message
+            raise
+          ensure
+            latency = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).to_i
+            client.track(
+              endpoint: req.uri.to_s,
+              method: req.method,
+              status_code: status,
+              latency_ms: latency,
+              provider: Amlexia::HttpWrap.provider_from_url(req.uri.to_s),
+              error_message: err
+            )
+          end
+        end
+      end
+    end
+
+    def track_http_call(client, **event)
+      client.track(**event)
+    end
+  end
+end

data/lib/amlexia/openai.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Amlexia
+  module OpenAI
+    module_function
+
+    def track_openai_completion(client, model:, status_code:, latency_ms:, usage: {}, cost_usd: nil, endpoint: "/v1/chat/completions", **kwargs)
+      event = Cost.enrich_event(
+        cost_usd: cost_usd,
+        model_name: model,
+        provider: "openai",
+        tokens_input: usage[:prompt_tokens],
+        tokens_output: usage[:completion_tokens],
+        total_tokens: usage[:total_tokens]
+      )
+      client.track(
+        endpoint: endpoint,
+        method: "POST",
+        status_code: status_code,
+        latency_ms: latency_ms,
+        provider: "openai",
+        model_name: model,
+        tokens_input: usage[:prompt_tokens],
+        tokens_output: usage[:completion_tokens],
+        cost_usd: event[:cost_usd],
+        **kwargs
+      )
+    end
+  end
+end

data/lib/amlexia/sampling.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Amlexia
+  module Sampling
+    module_function
+
+    def should_sample(rate)
+      return true if rate >= 1.0
+      return false if rate <= 0.0
+
+      rand < rate
+    end
+  end
+end

data/lib/amlexia/tracing.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Amlexia
+  TraceContext = Struct.new(
+    :trace_id, :span_id, :parent_span_id, :session_id, :user_id, :environment, :release_version,
+    keyword_init: true
+  )
+
+  module Tracing
+    module_function
+
+    def create_trace_context(**kwargs)
+      TraceContext.new(
+        trace_id: kwargs[:trace_id] || SecureRandom.hex(16),
+        span_id: kwargs[:span_id] || SecureRandom.hex(8),
+        parent_span_id: kwargs[:parent_span_id],
+        session_id: kwargs[:session_id],
+        user_id: kwargs[:user_id],
+        environment: kwargs[:environment],
+        release_version: kwargs[:release_version]
+      )
+    end
+
+    def child_span(parent)
+      TraceContext.new(
+        trace_id: parent.trace_id,
+        span_id: SecureRandom.hex(8),
+        parent_span_id: parent.span_id,
+        session_id: parent.session_id,
+        user_id: parent.user_id,
+        environment: parent.environment,
+        release_version: parent.release_version
+      )
+    end
+  end
+end

data/lib/amlexia/version.rb

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

data/lib/amlexia.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "amlexia/version"
+require_relative "amlexia/cost"
+require_relative "amlexia/sampling"
+require_relative "amlexia/diagnostic"
+require_relative "amlexia/health"
+require_relative "amlexia/tracing"
+require_relative "amlexia/http_wrap"
+require_relative "amlexia/openai"
+require_relative "amlexia/anthropic"
+require_relative "amlexia/client"
+
+module Amlexia
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: amlexia
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- Amlexia
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-05-19 00:00:00.000000000 Z
+dependencies: []
+description: Track HTTP APIs, LLM providers, payments, and webhooks with traces, latency,
+  and cost fields.
+email: support@amlexia.com
+executables:
+- amlexia
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- amlexia.gemspec
+- exe/amlexia
+- lib/amlexia.rb
+- lib/amlexia/anthropic.rb
+- lib/amlexia/client.rb
+- lib/amlexia/cost.rb
+- lib/amlexia/diagnostic.rb
+- lib/amlexia/health.rb
+- lib/amlexia/http_wrap.rb
+- lib/amlexia/openai.rb
+- lib/amlexia/sampling.rb
+- lib/amlexia/tracing.rb
+- lib/amlexia/version.rb
+homepage: https://amlexia.com
+licenses:
+- Nonstandard
+metadata:
+  source_code_uri: https://github.com/Amlexia/Amlexia
+  documentation_uri: https://docs.amlexia.com/sdk/ruby
+  changelog_uri: https://docs.amlexia.com/changelog
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Official Amlexia Ruby SDK — API, AI, and infrastructure observability
+test_files: []