open_router_usage_tracker 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f11a0fd8aa29a664ab72f45aa1516974dde22505c9e8f060ca8a051f0558de92
-  data.tar.gz: ad7a682ba71c648dba5dd12d6f47df0cd3ec9fc2590579e8a14bae4e1dd71e5c
+  metadata.gz: 7253067ecf8149856b410df301488651e176e01e7479da73b2a028c97ee65b41
+  data.tar.gz: 8a971201f93f46f4c7b8865c0bf1ae758dbc4b2788e250a6db642cc1f6925f36
 SHA512:
-  metadata.gz: '002058380aa56c5dfde8490cf908f019da6cb752774f6eef197c4c5746b4b5ce99fa45e76eefc0e596a5c19a5f3eee3ea811b04cbf85fb095a024db8ff08a365'
-  data.tar.gz: 9dc836d59bbda52b9974f98aae37da47eafbbe1581e8f260ef5bbe45de5ccb885148865cf0d787c01aa4ae84a0425d6f043aa8d3801a8e95058113c854c5fa64
+  metadata.gz: 9a411a62b04519c2a03cf4b81259378a6dce1739f218e432b7cf8656a58b16c511540804a72ac125a2da9606f35cd61b8dbf0db8de74470450acd611d2c8aa2e
+  data.tar.gz: dd5079f38075e63e85761172ac12f97c09f7ce8c19c975f699b93375236da078aeec2ef5885deeb5b2637236c996986701cadafbc1ff36bdc4beb8a9fff6ed4b

data/README.md

@@ -2,21 +2,54 @@
 [![Build Status](https://github.com/mclpio/open_router_usage_tracker/actions/workflows/ci.yml/badge.svg)](https://github.com/mclpio/open_router_usage_tracker/actions)
 [![Gem Version](https://badge.fury.io/rb/open_router_usage_tracker.svg)](https://badge.fury.io/rb/open_router_usage_tracker)
 
-An effortless Rails engine to track API token usage and cost from [OpenRouter](https://openrouter.ai/), enabling easy rate-limiting and monitoring for your users.
+An effortless Rails engine to track API token usage and cost from multiple LLM providers, including OpenRouter, OpenAI, Google, Anthropic, and xAI. It enables easy rate-limiting and monitoring for your users.
 
 ## Motivation
-Managing Large Language Model (LLM) API costs is crucial for any application that provides AI features to users. This gem provides simple, out-of-the-box tools to log every OpenRouter API call, associate it with a user, and query their usage over time. This allows you to easily implement spending caps, rate limits, or usage-based billing tiers.
+Managing Large Language Model (LLM) API costs is crucial for any application that provides AI features to users. This gem provides simple, out-of-the-box tools to log every API call, associate it with a user, and query their usage over time. This allows you to easily implement spending caps, rate limits, or usage-based billing tiers across different providers.
+
+## Quick Start
+
+1.  **Add the gem to your Gemfile:**
+    ```ruby
+    gem 'open_router_usage_tracker', '~> 1.0.0'
+    ```
+
+2.  **Install and run migrations:**
+    ```bash
+    bundle install
+    bin/rails g open_router_usage_tracker:install
+    bin/rails g open_router_usage_tracker:summary_install
+    bin/rails db:migrate
+    ```
+
+3.  **Add the concern to your User model:**
+    ```ruby
+    # app/models/user.rb
+    class User < ApplicationRecord
+      include OpenRouterUsageTracker::Trackable
+    end
+    ```
+
+4.  **Log a request:**
+    ```ruby
+    # In your controller or service
+    OpenRouterUsageTracker.log(
+      response: a_parsed_json_response_from_your_llm_provider,
+      user: current_user,
+      provider: "open_ai"
+    )
+    ```
 
 ## Installation
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "open_router_usage_tracker"
+gem 'open_router_usage_tracker', '~> 1.0.0'
 ```
 
 And then execute:
 ```bash
-bundle
+bundle install
 ```
 
 Or install it yourself as:
@@ -26,22 +59,22 @@ gem install open_router_usage_tracker
 
 ## Setup
 
-1. **Run the Install Generator**: This will create a migration file in your application to add the `open_router_usage_logs` table.
+1.  **Run the Install Generator**: This will create a migration file in your application to add the `open_router_usage_logs` table.
     ```bash
     bin/rails g open_router_usage_tracker:install
     ```
 
-2. **Run the Summary Table Generator (New in v0.2.0)**: To enable performant daily rate-limiting, generate the migration for the summary table.
+2.  **Run the Summary Table Generator (Required)**: To enable performant daily rate-limiting, generate the migration for the summary table.
     ```bash
     bin/rails g open_router_usage_tracker:summary_install
     ```
 
-3. **Run the Database Migrations**:
+3.  **Run the Database Migrations**:
     ```bash
     bin/rails db:migrate
     ```
 
-4. **Include the `Trackable` Concern**: To add the usage tracking methods (`usage_in_period`, etc.) to your user model, include the concern. This works with any user-like model (e.g., `User`, `Account`).
+4.  **Include the `Trackable` Concern**: To add the usage tracking methods to your user model, include the concern. This works with any user-like model (e.g., `User`, `Account`).
     ```ruby
     # app/models/user.rb
     class User < ApplicationRecord
@@ -51,84 +84,240 @@ gem install open_router_usage_tracker
     end
     ```
 
+5.  **(IMPORTANT) Configure Data Retention**: The `Trackable` concern intentionally does not set a `dependent` option on the `usage_logs` and `daily_summaries` associations. This is a critical design choice to prevent accidental data loss. You must decide what happens to a user's usage data when their account is deleted.
+
+    **To delete all usage data with the user:**
+    ```ruby
+    # app/models/user.rb
+    class User < ApplicationRecord
+      include OpenRouterUsageTracker::Trackable
+
+      has_many :usage_logs, as: :user, class_name: "OpenRouterUsageTracker::UsageLog", dependent: :destroy
+      has_many :daily_summaries, as: :user, class_name: "OpenRouterUsageTracker::DailySummary", dependent: :destroy
+    end
+    ```
+
+    **To keep all usage data:**
+    ```ruby
+    # app/models/user.rb
+    class User < ApplicationRecord
+      include OpenRouterUsageTracker::Trackable
+      # No `dependent` option needed. The records will remain.
+    end
+    ```
+
 ## Usage
 Using the gem involves two parts: logging new requests and tracking existing usage.
 
 ### Logging a Request
-In your application where you receive a successful response from the OpenRouter API, call the `log` method. It's designed to be simple and fail loudly if the data is invalid.
+In your application where you receive a successful response from an LLM API, call the `log` method. It's designed to be simple and fail loudly if the data is invalid.
 
 ```ruby
-# Assume `api_response` is the parsed JSON hash from OpenRouter
+# Assume `api_response` is the parsed JSON hash from the provider
 # and `current_user` is your authenticated user object.
 
-begin
-  OpenRouterUsageTracker.log(response: api_response, user: current_user)
-rescue ActiveRecord::RecordInvalid => e
-  # This can happen if the response hash is missing required keys
-  # (e.g., 'id', 'model', 'usage').
-  logger.error "Failed to log OpenRouter usage: #{e.message}"
-end
+# For OpenRouter (the default provider)
+OpenRouterUsageTracker.log(response: open_router_response, user: current_user)
+
+# For OpenAI
+OpenRouterUsageTracker.log(response: openai_response, user: current_user, provider: "open_ai")
+
+# For Google
+OpenRouterUsageTracker.log(response: google_response, user: current_user, provider: "google")
+
+# You can also prevent storing the raw API response for privacy or storage reasons.
+OpenRouterUsageTracker.log(response: api_response, user: current_user, provider: "anthropic", store_raw_response: false)
+```
+
+### Supported Providers
+The gem currently supports the following providers out-of-the-box:
+- `open_router` (default)
+- `open_ai`
+- `google`
+- `anthropic`
+- `x_ai`
+
+The gem will automatically parse the response from each provider to extract the relevant usage data. If a provider does not return a specific field (like `cost`), it will be saved as `0`.
+
+#### Providing Your Own Cost
+
+For providers that do not return cost information, you can calculate it yourself and add it to the response hash before logging. The gem will automatically detect and use a `cost` key inside the `usage` hash.
+
+```ruby
+# Calculate your own cost for an OpenAI call
+openai_response["usage"]["cost"] = your_calculated_cost # e.g., 0.0123
+
+# The log method will now use your provided cost
+OpenRouterUsageTracker.log(response: openai_response, user: current_user, provider: "open_ai")
 ```
 
-### Daily Usage Tracking and Rate-Limiting (Recommended)
+### Required Keys
+For the `log` method to parse the API response correctly, the `model`, `id`, and `usage` (or similarly named) keys must be present in the response hash. Do not filter them out before logging.
 
-For high-performance rate-limiting, the gem provides helpers that query a daily summary table. This avoids slow `SUM` queries on the main log table.
+### Daily Usage Tracking and Rate-Limiting
+For high-performance rate-limiting, the gem provides methods to query the daily summary table. This avoids slow `SUM` queries on the main log table.
 
-The primary method is `cost_exceeded?(limit:)`, which provides a near-instantaneous check against a user's daily spending.
+The `daily_usage_summary_for(day:, provider:, model:)` method provides a near-instantaneous check of a user's usage for a specific model on a given day.
 
-**Example: Implementing a daily cost limit**
+**Example: Implementing a daily token limit for a specific model**
 
-Imagine you want to prevent users from spending more than $1.00 per day.
+Imagine you want to prevent users from using more than 100,000 tokens per day for a specific model.
 
 ```ruby
 # somewhere in a controller or before_action
-
 def enforce_daily_limit
+  # Be sure to handle timezones correctly for your users.
+  today = Time.zone.today # =>  Wed, 30 Jul 2025
+  
   # This check is extremely fast as it queries the small summary table.
-  if current_user.cost_exceeded?(limit: 1.00)
-    render json: { error: "You have exceeded your daily spending limit." }, status: :too_many_requests
+  summary = current_user.daily_usage_summary_for(
+    day: today,
+    provider: "open_ai",
+    model: "gpt-4o"
+  )
+
+  if summary && summary.total_tokens > 100_000
+    render json: { error: "You have exceeded your daily token limit for this model." }, status: :too_many_requests
     return
   end
 end
 ```
 
-You can also retrieve the full summary for the current day (UTC):
+### Querying Costs
 
-```ruby
-summary = current_user.usage_today
-# => <OpenRouterUsageTracker::DailySummary id: 1, user_id: 1, day: "2025-06-28", total_tokens: 1500, cost: 0.025, ...>
+The `Trackable` concern also provides a powerful method to calculate total costs over a date range by querying the performant `daily_summaries` table.
 
-summary.cost
-# => 0.025
+The `total_cost_in_range(range, provider:, model: nil)` method allows you to easily calculate costs for a specific provider or a specific model over any period.
 
-summary.total_tokens
-# => 1500
-```
+**Example: Analyzing costs over a period**
 
-### Historical Usage Tracking
-
-The `Trackable` concern also adds methods for querying historical usage from the main log table.
+```ruby
+# In a reporting or analytics service
+def generate_cost_report(user)
+  # Get the date range for the last 30 days.
+  last_30_days = (30.days.ago.to_date)..Date.current
 
-The main method is `usage_in_period(range)`, which returns a hash containing the total tokens and cost for a given time range.
+  # Calculate the total cost for all OpenRouter models in the last 30 days.
+  # This is meaningful because OpenRouter provides direct cost data.
+  open_router_cost = user.total_cost_in_range(last_30_days, provider: "open_router")
 
-**Example: Checking usage for the current month**
+  # For providers that don't return cost, this will correctly be 0.
+  openai_cost = user.total_cost_in_range(last_30_days, provider: "open_ai")
 
-```ruby
-range = Time.current.beginning_of_month..Time.current
-usage = current_user.usage_in_period(range)
-# => { tokens: 50000, cost: 1.25 }
+  puts "Total OpenRouter cost in the last 30 days: $#{open_router_cost.round(2)}"
+  puts "Total OpenAI cost in the last 30 days: $#{openai_cost.round(2)}" # Will be $0.00
+end
 ```
 
-**DEPRECATED for rate-limiting**: The `usage_in_last_24_hours` method is still available but is **not recommended** for implementing rate limits due to its performance implications. Use `cost_exceeded?` instead for a more robust and scalable solution.
+Note that different LLM models have different costs, so it often makes sense to enforce limits on a per-provider and per-model basis. You can always run your own queries on the `OpenRouterUsageTracker::DailySummary` table for more complex logic.
 
 ## Contributing
-Open an issue first.
+Open an issue first to discuss.
 
 1. Fork the repository.
 1. Create your feature branch (git checkout -b my-new-feature).
 1. Commit your changes (git commit -am 'Add some feature').
 1. Push to the branch (git push origin my-new-feature).
-1. Create a new Pull Request.
+1. Create a new Pull Request using your fork
 
 ## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Architecture Diagrams
+
+### Gem Components
+
+```mermaid
+graph TD
+    subgraph A[Rails Host App]
+        U[User Model]
+        C[Controller/Service]
+    end
+
+    subgraph B[OpenRouterUsageTracker Gem]
+        T{Trackable Concern}
+        L[Log Method]
+        AD(Adapter)
+        P[Parsers]
+        UL[UsageLog Model]
+        DS[DailySummary Model]
+    end
+
+    subgraph D[Database]
+        T1(open_router_usage_logs Table)
+        T2(open_router_daily_summaries Table)
+    end
+
+    C -- Calls --> L
+    U -- Includes --> T
+    T -- has_many --> UL
+    T -- has_many --> DS
+
+    L -- Uses --> AD
+    AD -- Selects --> P
+    P -- Creates --> UL
+    AD -- Updates --> DS
+
+    UL -- Persisted in --> T1
+    DS -- Persisted in --> T2
+
+    style B fill:#f9f,stroke:#333,stroke-width:2px
+    style A fill:#ccf,stroke:#333,stroke-width:2px
+```
+
+### Logging Sequence
+
+```mermaid
+sequenceDiagram
+    participant App as Rails Host App
+    participant Gem as OpenRouterUsageTracker
+    participant DB as Database
+
+    App->>+Gem: OpenRouterUsageTracker.log(response: ..., user: ..., provider: 'open_ai')
+    Gem->>Gem: Select 'OpenAi' Parser
+    Gem->>+DB: BEGIN TRANSACTION
+    Gem->>DB: CREATE UsageLog record
+    Gem->>DB: FIND OR INITIALIZE DailySummary for today
+    Gem->>DB: INCREMENT and SAVE DailySummary record
+    DB-->>-Gem: COMMIT TRANSACTION
+    Gem-->>-App: return UsageLog object
+```
+
+### Database Schema (ERD)
+
+```mermaid
+erDiagram
+    USER ||--o{ USAGE_LOG : "has_many"
+    USER ||--o{ DAILY_SUMMARY : "has_many"
+
+    USER {
+        string name
+        string email
+    }
+
+    USAGE_LOG {
+        string user_type
+        bigint user_id
+        string provider
+        string model
+        string request_id
+        integer prompt_tokens
+        integer completion_tokens
+        integer total_tokens
+        decimal cost
+        json raw_usage_response
+    }
+
+    DAILY_SUMMARY {
+        string user_type
+        bigint user_id
+        date day
+        string provider
+        string model
+        integer total_tokens
+        integer prompt_tokens
+        integer completion_tokens
+        decimal cost
+    }
+
+```

data/app/models/concerns/open_router_usage_tracker/trackable.rb

@@ -5,42 +5,32 @@ module OpenRouterUsageTracker
     extend ActiveSupport::Concern
 
     included do
-      has_many :usage_logs, as: :user, class_name: "OpenRouterUsageTracker::UsageLog", dependent: :destroy
-      has_many :daily_summaries, as: :user, class_name: "OpenRouterUsageTracker::DailySummary", dependent: :destroy
+      has_many :usage_logs, as: :user, class_name: "OpenRouterUsageTracker::UsageLog"
+      has_many :daily_summaries, as: :user, class_name: "OpenRouterUsageTracker::DailySummary"
     end
 
-    def usage_today
-      daily_summaries.find_by(day: Date.current)
-    end
-
-    def cost_exceeded?(limit:, period: :daily)
-      case period
-      when :daily
-        usage_today&.cost.to_d > limit
-      else
-        raise ArgumentError, "Unsupported period: #{period}"
-      end
-    end
-
-    # A flexible method to query usage within any time period.
+    # Finds a specific daily summary for a given day, provider, and model.
+    # This is the primary, high-performance method for usage checks.
     #
-    # Example:
-    #   user.usage_in_period(24.hours.ago..Time.current)
-    #   => { tokens: 1500, cost: 0.025 }
-    #
-    def usage_in_period(range)
-      logs_in_range = self.usage_logs.where(created_at: range)
-
-      # Use .to_i and .to_d to handle cases where there are no logs (sum returns nil)
-      total_tokens = logs_in_range.sum(:total_tokens).to_i
-      total_cost = logs_in_range.sum(:cost).to_d
-
-      { tokens: total_tokens, cost: total_cost }
+    # @param day [Date] The date to check. Pass `Time.zone.today` to be timezone-aware.
+    # @param provider [String] The provider name (e.g., 'open_router').
+    # @param model [String] The model name (e.g., 'openai/gpt-4o').
+    # @return [OpenRouterUsageTracker::DailySummary, nil]
+    def daily_usage_summary_for(day:, provider:, model:)
+      daily_summaries.find_by(day: day, provider: provider, model: model)
     end
 
-    # A convenience method for checking the last 24 hours.
-    def usage_in_last_24_hours
-      usage_in_period(24.hours.ago..Time.current)
+    # Calculates the total cost from the daily summaries within a given date range.
+    # It can be filtered by provider and, optionally, by model.
+    #
+    # @param range [Range<Date>] The date range to query (e.g., 1.month.ago.to_date..Date.current).
+    # @param provider [String] The provider name (e.g., 'open_ai').
+    # @param model [String, nil] The optional model name.
+    # @return [BigDecimal] The total cost.
+    def total_cost_in_range(range, provider:, model: nil)
+      summaries = daily_summaries.where(day: range, provider: provider)
+      summaries = summaries.where(model: model) if model
+      summaries.sum(:cost)
     end
   end
 end

data/app/models/open_router_usage_tracker/daily_summary.rb

@@ -6,6 +6,10 @@ module OpenRouterUsageTracker
 
     validates :day, presence: true
     validates :total_tokens, presence: true, numericality: { greater_than_or_equal_to: 0 }
+    validates :prompt_tokens, presence: true, numericality: { greater_than_or_equal_to: 0 }
+    validates :completion_tokens, presence: true, numericality: { greater_than_or_equal_to: 0 }
     validates :cost, presence: true, numericality: { greater_than_or_equal_to: 0 }
+    validates :model, presence: true
+    validates :provider, presence: true
   end
 end

data/app/models/open_router_usage_tracker/usage_log.rb

@@ -6,12 +6,11 @@ module OpenRouterUsageTracker
     belongs_to :user, polymorphic: true
 
     validates :model, presence: true
-    validates :prompt_tokens, presence: true
-    validates :completion_tokens, presence: true
-    validates :total_tokens, presence: true
-    validates :cost, presence: true
-    validates :raw_usage_response, presence: true
-
-    validates :request_id, presence: true, uniqueness: true
+    validates :prompt_tokens, numericality: { greater_than_or_equal_to: 0 }
+    validates :completion_tokens, numericality: { greater_than_or_equal_to: 0 }
+    validates :total_tokens, numericality: { greater_than_or_equal_to: 0 }
+    validates :cost, numericality: { greater_than_or_equal_to: 0 }
+    validates :provider, presence: true
+    validates :request_id, presence: true, uniqueness: { scope: :provider }
   end
 end

data/lib/generators/open_router_usage_tracker/install/templates/migration.rb

@@ -2,12 +2,13 @@ class CreateOpenRouterUsageLogs < ActiveRecord::Migration[8.0]
   def change
     create_table :open_router_usage_logs do |t|
       t.string :model, null: false
-      t.integer :prompt_tokens, null: false
-      t.integer :completion_tokens, null: false
-      t.integer :total_tokens, null: false
-      t.decimal :cost, precision: 10, scale: 5, null: false
+      t.integer :prompt_tokens, null: false, default: 0
+      t.integer :completion_tokens, null: false, default: 0
+      t.integer :total_tokens, null: false, default: 0
+      t.decimal :cost, precision: 10, scale: 5, null: false, default: 0.0
       t.references :user, null: false, polymorphic: true
       t.string :request_id, null: false
+      t.string :provider, null: false, default: "open_router"
 
       # Storing the raw API response is recommended for auditing and future-proofing.
       # If you are using PostgreSQL, you can change `t.json` to `t.jsonb` for
@@ -17,6 +18,6 @@ class CreateOpenRouterUsageLogs < ActiveRecord::Migration[8.0]
       t.timestamps
     end
 
-    add_index :open_router_usage_logs, :request_id, unique: true
+    add_index :open_router_usage_logs, [ :provider, :request_id ], unique: true
   end
 end

data/lib/generators/open_router_usage_tracker/summary_install/templates/migration.rb

@@ -4,10 +4,14 @@ class CreateOpenRouterDailySummaries < ActiveRecord::Migration[8.0]
       t.references :user, null: false, polymorphic: true
       t.date :day, null: false
       t.integer :total_tokens, null: false, default: 0
+      t.integer :prompt_tokens, null: false, default: 0
+      t.integer :completion_tokens, null: false, default: 0
       t.decimal :cost, precision: 10, scale: 5, null: false, default: 0.0
+      t.string :provider, null: false, default: "open_router"
+      t.string :model, null: false
       t.timestamps
     end
 
-    add_index :open_router_daily_summaries, [ :user_type, :user_id, :day ], unique: true, name: "index_daily_summaries_on_user_and_day"
+    add_index :open_router_daily_summaries, [ :user_type, :user_id, :day, :provider, :model ], unique: true, name: "index_daily_summaries_on_user_and_day_and_provider_and_model"
   end
 end

data/lib/open_router_usage_tracker/adapter/base.rb

@@ -0,0 +1,65 @@
+module OpenRouterUsageTracker
+  require "open_router_usage_tracker/parsers/open_ai"
+  require "open_router_usage_tracker/parsers/open_router"
+  require "open_router_usage_tracker/parsers/google"
+  require "open_router_usage_tracker/parsers/anthropic"
+  require "open_router_usage_tracker/parsers/x_ai"
+
+  module Adapter
+    module Base
+      SUPPORTED_PROVIDERS = [ "open_ai", "open_router", "google", "anthropic", "x_ai" ].freeze
+
+      # Logs an API usage event, creating a UsageLog and updating the DailySummary.
+      # This is the primary method for recording usage data.
+      #
+      # @param response [Hash] The raw response hash from the API provider.
+      # @param user [ApplicationRecord] The user object (e.g., User, Account) associated with the API call.
+      # @param provider [String] The name of the API provider (e.g., 'open_router', 'open_ai').
+      #   Defaults to 'open_router'.
+      # @param store_raw_response [Boolean] If false, an empty hash will be stored in the
+      #   raw_usage_response column. Defaults to true.
+      #
+      # @return [OpenRouterUsageTracker::UsageLog] The newly created usage log record.
+      #
+      # @example Log a call and store the raw response
+      #   OpenRouterUsageTracker.log(response: api_response, user: current_user)
+      #
+      # @example Log a call without storing the raw response
+      #   OpenRouterUsageTracker.log(response: api_response, user: current_user, store_raw_response: false)
+      #
+      def log(response:, user:, provider: "open_router", store_raw_response: true)
+        unless SUPPORTED_PROVIDERS.include?(provider)
+          raise ArgumentError.new("Unsupported provider: #{provider}. Supported providers are: #{SUPPORTED_PROVIDERS.join(', ')}")
+        end
+
+        parser_class = "OpenRouterUsageTracker::Parsers::#{provider.camelize}".constantize
+        attributes = parser_class.parse(response)
+        attributes[:user] = user
+        attributes[:raw_usage_response] = {} unless store_raw_response
+        attributes[:provider] = provider
+
+        ApplicationRecord.transaction do
+          usage_log = OpenRouterUsageTracker::UsageLog.create!(attributes)
+          update_daily_summary(usage_log)
+          usage_log
+        end
+      end
+
+      private
+
+      def update_daily_summary(usage_log)
+        summary = OpenRouterUsageTracker::DailySummary.find_or_initialize_by(
+          user: usage_log.user,
+          day: Date.current,
+          provider: usage_log.provider,
+          model: usage_log.model
+        )
+        summary.total_tokens += usage_log.total_tokens
+        summary.cost += usage_log.cost
+        summary.prompt_tokens += usage_log.prompt_tokens
+        summary.completion_tokens += usage_log.completion_tokens
+        summary.save!
+      end
+    end
+  end
+end

data/lib/open_router_usage_tracker/parsers/anthropic.rb

@@ -0,0 +1,21 @@
+module OpenRouterUsageTracker
+  module Parsers
+    class Anthropic
+      def self.parse(response)
+        input_tokens = response.dig("usage", "input_tokens").to_i
+        output_tokens = response.dig("usage", "output_tokens").to_i
+        total_tokens = input_tokens + output_tokens
+
+        {
+          model: response.dig("model"),
+          prompt_tokens: input_tokens,
+          completion_tokens: output_tokens,
+          total_tokens: total_tokens,
+          cost: response.dig("usage", "cost").to_f,
+          request_id: response["id"],
+          raw_usage_response: response
+        }
+      end
+    end
+  end
+end

data/lib/open_router_usage_tracker/parsers/google.rb

@@ -0,0 +1,17 @@
+module OpenRouterUsageTracker
+  module Parsers
+    class Google
+      def self.parse(response)
+        {
+          model: response.dig("model"),
+          prompt_tokens: response.dig("usageMetadata", "promptTokenCount").to_i,
+          completion_tokens: response.dig("usageMetadata", "candidatesTokenCount").to_i,
+          total_tokens: response.dig("usageMetadata", "totalTokenCount").to_i,
+          cost: response.dig("usage", "cost").to_f,
+          request_id: response["responseId"],
+          raw_usage_response: response
+        }
+      end
+    end
+  end
+end

data/lib/open_router_usage_tracker/parsers/open_ai.rb

@@ -0,0 +1,17 @@
+module OpenRouterUsageTracker
+  module Parsers
+    class OpenAi
+      def self.parse(response)
+        {
+          model: response.dig("model"),
+          prompt_tokens: response.dig("usage", "input_tokens").to_i,
+          completion_tokens: response.dig("usage", "output_tokens").to_i,
+          total_tokens: response.dig("usage", "total_tokens").to_i,
+          cost: response.dig("usage", "cost").to_f,
+          request_id: response["id"],
+          raw_usage_response: response
+        }
+      end
+    end
+  end
+end

data/lib/open_router_usage_tracker/parsers/open_router.rb

@@ -0,0 +1,17 @@
+module OpenRouterUsageTracker
+  module Parsers
+    class OpenRouter
+      def self.parse(response)
+        {
+          model: response.dig("model"),
+          prompt_tokens: response.dig("usage", "prompt_tokens").to_i,
+          completion_tokens: response.dig("usage", "completion_tokens").to_i,
+          total_tokens: response.dig("usage", "total_tokens").to_i,
+          cost: response.dig("usage", "cost").to_f,
+          request_id: response.dig("id"),
+          raw_usage_response: response
+        }
+      end
+    end
+  end
+end

data/lib/open_router_usage_tracker/parsers/x_ai.rb

@@ -0,0 +1,17 @@
+module OpenRouterUsageTracker
+  module Parsers
+    class XAi
+      def self.parse(response)
+        {
+          model: response.dig("model"),
+          prompt_tokens: response.dig("usage", "prompt_tokens").to_i,
+          completion_tokens: response.dig("usage", "completion_tokens").to_i,
+          total_tokens: response.dig("usage", "total_tokens").to_i,
+          cost: response.dig("usage", "cost").to_f,
+          request_id: response["id"],
+          raw_usage_response: response
+        }
+      end
+    end
+  end
+end

data/lib/open_router_usage_tracker/version.rb

@@ -1,3 +1,3 @@
 module OpenRouterUsageTracker
-  VERSION = "0.2.0"
+  VERSION = "1.0.0"
 end

data/lib/open_router_usage_tracker.rb

@@ -1,43 +1,11 @@
 require "open_router_usage_tracker/version"
-require "open_router_usage_tracker/railtie"
 require "open_router_usage_tracker/engine"
+require "open_router_usage_tracker/adapter/base"
 
 module OpenRouterUsageTracker
   class << self
     attr_writer :configuration
 
-    def log(response:, user:)
-      ApplicationRecord.transaction do
-        usage_log = create_usage_log(response, user)
-        update_daily_summary(usage_log)
-        usage_log
-      end
-    end
-
-    private
-
-    def create_usage_log(response, user)
-      attributes = {
-        model: response["model"],
-        prompt_tokens: response.dig("usage", "prompt_tokens"),
-        completion_tokens: response.dig("usage", "completion_tokens"),
-        total_tokens: response.dig("usage", "total_tokens"),
-        cost: response.dig("usage", "cost"),
-        request_id: response["id"],
-        raw_usage_response: response,
-        user: user
-      }
-      OpenRouterUsageTracker::UsageLog.create!(attributes)
-    end
-
-    def update_daily_summary(usage_log)
-      summary = OpenRouterUsageTracker::DailySummary.find_or_initialize_by(
-        user: usage_log.user,
-        day: Date.current
-      )
-      summary.total_tokens += usage_log.total_tokens
-      summary.cost += usage_log.cost
-      summary.save!
-    end
+    include Adapter::Base
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: open_router_usage_tracker
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - MclPio
@@ -23,8 +23,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 8.0.2
-description: A simple Rails engine to log OpenRouter API usage and provide methods
-  for tracking user consumption over time, enabling easy rate-limiting.
+description: A simple Rails engine to log API usage from multiple LLM providers and
+  provide methods for tracking user consumption over time, enabling easy rate-limiting.
 email:
 - mclpious@gmail.com
 executables: []
@@ -42,10 +42,14 @@ files:
 - lib/generators/open_router_usage_tracker/summary_install/summary_install_generator.rb
 - lib/generators/open_router_usage_tracker/summary_install/templates/migration.rb
 - lib/open_router_usage_tracker.rb
+- lib/open_router_usage_tracker/adapter/base.rb
 - lib/open_router_usage_tracker/engine.rb
-- lib/open_router_usage_tracker/railtie.rb
+- lib/open_router_usage_tracker/parsers/anthropic.rb
+- lib/open_router_usage_tracker/parsers/google.rb
+- lib/open_router_usage_tracker/parsers/open_ai.rb
+- lib/open_router_usage_tracker/parsers/open_router.rb
+- lib/open_router_usage_tracker/parsers/x_ai.rb
 - lib/open_router_usage_tracker/version.rb
-- lib/tasks/open_router_usage_tracker_tasks.rake
 homepage: https://github.com/MclPio/open_router_usage_tracker
 licenses:
 - MIT
@@ -69,5 +73,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Track API token usage and cost from OpenRouter
+summary: Track API token usage and cost from multiple LLM providers like OpenRouter,
+  OpenAI, Google, and more.
 test_files: []

data/lib/open_router_usage_tracker/railtie.rb

@@ -1,4 +0,0 @@
-module OpenRouterUsageTracker
-  class Railtie < ::Rails::Railtie
-  end
-end

data/lib/tasks/open_router_usage_tracker_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :open_router_usage_tracker do
-#   # Task goes here
-# end