open_router_usage_tracker 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7a0b0d377d1ceb1cefd29fc39a4c0c59b62abd1693991887df3a3a0d5ee1098
-  data.tar.gz: d3b49c32c40b830a0eb6440555060d3d396d4090452a03f418e6b093e277b46f
+  metadata.gz: 7253067ecf8149856b410df301488651e176e01e7479da73b2a028c97ee65b41
+  data.tar.gz: 8a971201f93f46f4c7b8865c0bf1ae758dbc4b2788e250a6db642cc1f6925f36
 SHA512:
-  metadata.gz: fe1055299e94060dac77b0ef1771f7297efad1ac915b1ec8a28f42a051530d9b5d7104f22bbf4e4b1ce51932d75db47e90220405b27ee221fd203e345fe19110
-  data.tar.gz: eba805cd5aa35646a8df1f44161d6077be70cbcf6fc7c84c5c1919e81280428fc7cfa16b420a3662dc27f4c49f242b264015986ec9dfe157c2e63525461df043
+  metadata.gz: 9a411a62b04519c2a03cf4b81259378a6dce1739f218e432b7cf8656a58b16c511540804a72ac125a2da9606f35cd61b8dbf0db8de74470450acd611d2c8aa2e
+  data.tar.gz: dd5079f38075e63e85761172ac12f97c09f7ce8c19c975f699b93375236da078aeec2ef5885deeb5b2637236c996986701cadafbc1ff36bdc4beb8a9fff6ed4b

data/README.md

@@ -1,42 +1,80 @@
 # OpenRouterUsageTracker
-[![Gem Version](https://badge.fury.io/rb/open_router_usage_tracker.svg)](https://badge.fury.io/rb/open_router_usage_tracker)
 [![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.io](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:
 ```bash
-$ gem install open_router_usage_tracker
+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
     ```
 
-1. **Run the Database Migration**:
+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**:
     ```bash
     bin/rails db:migrate
     ```
 
-1. **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
@@ -46,57 +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)
 ```
 
-### Tracking Usage
-The `Trackable` concern adds powerful querying methods to your user model.
+### Supported Providers
+The gem currently supports the following providers out-of-the-box:
+- `open_router` (default)
+- `open_ai`
+- `google`
+- `anthropic`
+- `x_ai`
 
-The main method is `usage_in_period(range)`, which returns a hash containing the total tokens and cost for a given time range.
+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`.
 
-**Example: Implementing a rate limit**
+#### Providing Your Own Cost
 
-Imagine you want to prevent users from using more than 100,000 tokens in a 24-hour period.
+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
-# somewhere in a controller or before_action
+# Calculate your own cost for an OpenAI call
+openai_response["usage"]["cost"] = your_calculated_cost # e.g., 0.0123
 
-def check_usage_limit
-  usage = current_user.usage_in_last_24_hours
+# The log method will now use your provided cost
+OpenRouterUsageTracker.log(response: openai_response, user: current_user, provider: "open_ai")
+```
+
+### 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.
+
+### 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 `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 token limit for a specific model**
+
+Imagine you want to prevent users from using more than 100,000 tokens per day for a specific model.
 
-  if usage[:tokens] > 100_000
-    render json: { error: "You have exceeded your daily usage limit." }, status: :too_many_requests
+```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.
+  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
 ```
 
-The gem also provides `usage_in_last_24_hours` as a convenience method and you can always get all the data using `usage_logs`.
+### Querying Costs
+
+The `Trackable` concern also provides a powerful method to calculate total costs over a date range by querying the performant `daily_summaries` table.
+
+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.
+
+**Example: Analyzing costs over a period**
+
+```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
+
+  # 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")
+
+  # 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")
+
+  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
+```
+
+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,28 +5,32 @@ module OpenRouterUsageTracker
     extend ActiveSupport::Concern
 
     included do
-      has_many :usage_logs, as: :user, class_name: "OpenRouterUsageTracker::UsageLog", dependent: :destroy
+      has_many :usage_logs, as: :user, class_name: "OpenRouterUsageTracker::UsageLog"
+      has_many :daily_summaries, as: :user, class_name: "OpenRouterUsageTracker::DailySummary"
     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

@@ -0,0 +1,15 @@
+module OpenRouterUsageTracker
+  class DailySummary < ApplicationRecord
+    self.table_name = "open_router_daily_summaries"
+
+    belongs_to :user, polymorphic: true
+
+    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/summary_install_generator.rb

@@ -0,0 +1,19 @@
+require "rails/generators/base"
+
+module OpenRouterUsageTracker
+  module Generators
+    class SummaryInstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      def self.next_migration_number(dir)
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+
+      def create_migration_file
+        migration_template "migration.rb", "db/migrate/create_open_router_daily_summaries.rb"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+class CreateOpenRouterDailySummaries < ActiveRecord::Migration[8.0]
+  def change
+    create_table :open_router_daily_summaries do |t|
+      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, :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.1.1"
+  VERSION = "1.0.0"
 end

data/lib/open_router_usage_tracker.rb

@@ -1,24 +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:)
-      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
+    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.1.1
+  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: []
@@ -35,14 +35,21 @@ files:
 - README.md
 - Rakefile
 - app/models/concerns/open_router_usage_tracker/trackable.rb
+- app/models/open_router_usage_tracker/daily_summary.rb
 - app/models/open_router_usage_tracker/usage_log.rb
 - lib/generators/open_router_usage_tracker/install/install_generator.rb
 - lib/generators/open_router_usage_tracker/install/templates/migration.rb
+- 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
@@ -66,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