optiaudit-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 44ee00e821c324db9b3aba699c39e04eff9b471b1d1dfd5779deae13c6b2f293
+  data.tar.gz: cc49b0ca5595307c1461067dc06467a1f056c998b8e795a35beb29510aeb44d7
+SHA512:
+  metadata.gz: 3b50e99331b77e089addca33877bf5ba22c38b7f37f3303fb911593382c48200b74b36eaeb321ace3baa748e1a47ac9f5c7c622e98609656f6b067d54bb38e10
+  data.tar.gz: 8559093f201881f42ab2482949b5128c9778f095e0e394fa74187df8b1d6ff48120d8a0093b4032f03feefd47a24d3fbc76552a5bd103f839dac1f301cf032a9

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-22
+
+Primera versión: el equivalente para Rails de `@theoptimalpartner/nestjs-optiaudit` 0.1.8 (SC25-2703).
+
+### Added
+
+- **Macros de controller** `optiaudit_page_view` y `optiaudit_event`, equivalentes a `@TrackPageView` y `@TrackEvent`. Corren en un `after_action`, sólo si la acción no lanzó excepción y la respuesta es 2xx o 3xx. Aceptan `only`/`except`/`if`/`unless` y `metadata` como hash o lambda.
+- **`Optiaudit.track`** para tracking manual y **`optiaudit_track`** dentro de una acción, que completa actor y datos del request.
+- **Actor** desde `current_user` (`id`, `email`, `organization_id`), configurable con `config.actor`. Sin actor no se envía nada, como en la 0.1.7 de la librería JS.
+- **IP real del cliente** con `request.remote_ip`, que salta los proxies de confianza (rangos privados) igual que el `extractClientIp` de la 0.1.8 de la JS. Si Rails detecta spoofing (`IpSpoofAttackError`), cae en `request.ip` y deja un warning.
+- **`session_id` hasheado con SHA-256**: el id crudo de la sesión nunca sale de la app. **`X-Request-ID`** del request en `metadata.request_id` y en el header del POST.
+- **Saneo antes de enviar.** OptiAudit rechaza el evento entero (y en un batch, el batch entero) ante un campo inválido, así que la gema trunca los strings a los largos del API, omite un `actor_email` que no es email y un `organization_id` que no es entero, y descarta con warning los `event_type` fuera del catálogo (configurable con `config.event_types`).
+- **Adaptadores de entrega**: `:sidekiq` (default si Sidekiq está cargado; un job por evento, reintentos sólo en 5xx/429/timeout/conexión), `:thread` (batches a `/events/batch` desde un thread en segundo plano, seguro con fork) e `:inline`. Ningún error llega al request.
+- **`Optiaudit::Testing`** para que las apps verifiquen sus eventos en tests sin HTTP.
+- Compatibilidad probada en CI: Ruby 2.7 + Rails 5.2 + Sidekiq 6.3, Ruby 3.0 + Rails 6.1 + Sidekiq 6.5 y Ruby 3.2 + Rails 7.0 + Sidekiq 7.2.
+
+[Unreleased]: https://bitbucket.org/RoutingUC/optiaudit-rails/branches/compare/main%0Dv0.1.0
+[0.1.0]: https://bitbucket.org/RoutingUC/optiaudit-rails/src/v0.1.0/

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 The Optimal Partner
+
+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,319 @@
+# optiaudit-rails
+
+Rails client for OptiAudit event tracking. The Ruby counterpart of
+[`@theoptimalpartner/nestjs-optiaudit`](https://www.npmjs.com/package/@theoptimalpartner/nestjs-optiaudit):
+same conventions, same events, so a Rails app and a NestJS app report to OptiAudit the same way.
+
+Integrating an app is adding the gem, two environment variables and one line per action you want to audit.
+
+## Features
+
+- **Zero-config**: Reads `OPTIAUDIT_URL` and `OPTIAUDIT_WRITE_KEY` from the environment
+- **Controller macros**: `optiaudit_page_view` and `optiaudit_event`, the equivalent of `@TrackPageView()` and `@TrackEvent()`
+- **Auto context extraction**: actor from `current_user`, client IP, user agent, path, request id and a hashed session id
+- **Never breaks the request**: delivery runs in Sidekiq or a background thread, and every error is logged as a warning
+- **No lost events on deploy**: with Sidekiq, events survive restarts and are retried on 5xx, 429 and timeouts
+- **Valid payloads**: fields that would make OptiAudit reject the whole event are fixed or dropped before sending
+- **Silent fallback**: Disabled automatically in tests or when env vars are missing
+- **Test mode**: `Optiaudit::Testing` records events in memory so apps can assert on them
+
+## Installation
+
+```ruby
+# Gemfile
+gem "optiaudit-rails"
+```
+
+```bash
+bundle install
+```
+
+The only runtime dependency is `railties`. HTTP goes through `Net::HTTP`, so the gem does not pull or
+constrain Faraday, HTTParty or any other client your app already uses.
+
+## Quick Start
+
+### 1. Environment Variables
+
+```bash
+OPTIAUDIT_URL=https://optiaudit-api.theoptimalpartner.com/api/v1
+OPTIAUDIT_WRITE_KEY=oat-12-your_write_key
+```
+
+The write key belongs to one OptiAudit source system. Use one source system per deployment of your app:
+the same `organization_id` in two deployments is two different organizations.
+
+### 2. Sidekiq queue
+
+If the app runs Sidekiq, events go through the `optiaudit` queue. Add it to the queues your workers process:
+
+```yaml
+# config/sidekiq.yml
+:queues:
+  - default
+  - optiaudit
+```
+
+Apps without Sidekiq need nothing: the gem uses a background thread (see [Delivery](#delivery)).
+
+### 3. Use the Macros
+
+```ruby
+class RoutesController < ApplicationController
+  optiaudit_page_view :routes, only: %i[index show]
+
+  optiaudit_event :update, :routes, only: :update
+  optiaudit_event :delete, :routes, only: :destroy,
+                  metadata: ->(controller) { { action: "delete_route", route_id: controller.params[:id] } }
+
+  def index
+    # ...
+  end
+end
+```
+
+`optiaudit_page_view :routes` is `optiaudit_event :page_view, :routes`. The second argument is the
+module, sent as `metadata.module`, which is how OptiAudit reports group events.
+
+Events are tracked after the action, and only when:
+
+- the action did not raise, and the response is 2xx or 3xx (a redirect after a create counts);
+- there is an actor (see [Context Extraction](#context-extraction)).
+
+Both macros accept the usual callback options (`only`, `except`, `if`, `unless`) and `metadata`, as a
+hash or as a lambda that receives the controller.
+
+### Event types
+
+OptiAudit only accepts the event types registered in its catalog and rejects any other with
+`422 EVENT_TYPE_NOT_FOUND`:
+
+`page_view`, `login`, `login_failed`, `logout`, `create`, `update`, `delete`, `export`, `config_change`
+
+Use these generic types and put the specific action in the metadata:
+
+```ruby
+optiaudit_event :update, :routes, only: :reschedule, metadata: { action: "reschedule_route" }
+```
+
+The gem drops events with an unknown type (with a warning) instead of sending them. If your OptiAudit
+instance registers more types, add them with `config.event_types`.
+
+## Manual Tracking
+
+Inside a controller, `optiaudit_track` fills in the actor and the request data, like the macros:
+
+```ruby
+def export
+  report = Reports::Routes.new(params).to_xlsx
+  optiaudit_track(:export, :reports, resource_type: "report", resource_id: report.id,
+                                     metadata: { action: "export_routes", rows: report.size })
+  send_data report.data
+end
+```
+
+Anywhere else (jobs, services, rake tasks) use `Optiaudit.track` with the fields you have:
+
+```ruby
+Optiaudit.track(
+  event_type: "config_change",
+  actor_id: user.id,
+  actor_email: user.email,
+  organization_id: user.organization_id,
+  resource_type: "organization",
+  resource_id: organization.id,
+  metadata: { module: "settings", action: "toggle_flag", flag: "auto_dispatch" }
+)
+```
+
+`Optiaudit.track` returns `true` when the event was handed to the delivery adapter and `false` when it
+was skipped or failed. It never raises.
+
+## Context Extraction
+
+The macros take the actor from `current_user`:
+
+| `current_user` | Event field |
+|----------------|-------------|
+| `id` | `actor_id` (required: without it nothing is sent) |
+| `email` | `actor_email` (omitted if it is not a valid email) |
+| `organization_id` | `organization_id` (omitted if it is not an integer) |
+
+`actor_type` is `"user"`.
+
+If the actor lives somewhere else (impersonation, an API client, a different method name), configure it.
+The block receives the controller and returns a user-like object, a hash, or `nil` to skip the event:
+
+```ruby
+# config/initializers/optiaudit.rb
+Optiaudit.configure do |config|
+  # Audit the admin behind an impersonated session, not the impersonated user.
+  config.actor { |controller| controller.send(:true_user) }
+
+  # Or build the actor yourself.
+  config.actor do |controller|
+    client = controller.instance_variable_get(:@api_client)
+    client && { id: client.id, type: "api_client", organization_id: client.organization_id }
+  end
+end
+```
+
+Request data, also filled in by `optiaudit_track`:
+
+| Field | Source |
+|-------|--------|
+| `resource_path` | `request.path` |
+| `ip_address` | `request.remote_ip` (see below) |
+| `user_agent` | `request.user_agent` |
+| `session_id` | SHA-256 of the session id. The raw id is a credential and never leaves the app. Only sent when the action already loaded the session. |
+| `metadata.request_id` | `request.request_id` (`X-Request-ID`), also sent as the `X-Request-ID` header to OptiAudit |
+| `metadata.module` | the module given to the macro |
+
+## Client IP Resolution
+
+Behind an ALB, ingress or reverse proxy, `request.ip` is the internal hop (e.g. `10.x.x.x`), not the user.
+The gem uses `request.remote_ip`, which walks `X-Forwarded-For` from right to left and skips trusted
+proxies (loopback and private ranges by default), returning the client's public IP. This is the same
+rule as the NestJS package since `v0.1.8`: values a client injects on the left are ignored.
+
+If your proxies use public addresses (a CDN in front of the load balancer), add them to
+`config.action_dispatch.trusted_proxies`, or `remote_ip` will return the proxy.
+
+In Rails 5.2, `remote_ip` raises `IpSpoofAttackError` when `Client-IP` and `X-Forwarded-For` disagree.
+The gem then logs a warning and uses `request.ip`, so the event is still sent and the request is not affected.
+
+## Delivery
+
+| Adapter | When | How |
+|---------|------|-----|
+| `:sidekiq` | Default when Sidekiq is loaded | One job per event in the `optiaudit` queue. Survives deploys. Retried with Sidekiq's backoff (5 times by default) on 5xx, 429, timeouts and connection errors. Other 4xx are dropped with a warning: retrying would not fix them. |
+| `:thread` | Default without Sidekiq | In-memory buffer sent to `POST /events/batch` (up to 100 events) every 5 seconds or when full, from a background thread. Works with forking servers (Puma, Unicorn): each process starts its own thread. Pending events are flushed at exit. Events still in memory are lost if the process is killed, and failed batches are not retried. |
+| `:inline` | Console, scripts, debugging | Synchronous `POST /events` in the caller's thread. Adds up to `timeout` seconds to a request. |
+
+Sidekiq jobs receive the event as a hash of string keys and JSON values, so they work with Sidekiq 7's
+`strict_args` (the default) without configuration.
+
+## Compatibility
+
+| Dependency | Versions | Tested in CI |
+|------------|----------|--------------|
+| Ruby | >= 2.7 | 2.7, 3.0, 3.2 |
+| Rails (`railties`) | >= 5.2 | 5.2, 6.1, 7.0 |
+| Sidekiq (optional) | >= 6.3 | 6.3, 6.5, 7.2 |
+
+The CI matrix follows the apps that use the gem: Llegando (Ruby 2.7, Rails 5.2, Sidekiq 6.3),
+Sonic (Ruby 3.0, Rails 6.1, Sidekiq 6.5) and SIR Web (Ruby 3.2, Rails 7.0, Sidekiq 7.2).
+
+> **Note**: If your project uses a version outside this table, add it to `gemfiles/` and to
+> `bitbucket-pipelines.yml` in a PR, or report an issue.
+
+## Advanced Configuration
+
+```ruby
+# config/initializers/optiaudit.rb
+Optiaudit.configure do |config|
+  config.url = "https://custom-url.com/api/v1" # Override env var
+  config.write_key = "oat-12-custom-key"        # Override env var
+  config.timeout = 5                            # Open/read timeout in seconds (default: 3)
+  config.enabled = false                        # Force disable (true forces enable, e.g. in staging tests)
+  config.log_errors = false                     # Disable warning logs on failure
+  config.logger = Logger.new($stdout)           # Default: Rails.logger
+
+  config.adapter = :thread                      # :sidekiq, :thread or :inline
+  config.queue = "low"                          # Sidekiq queue (default: "optiaudit")
+  config.max_retries = 3                        # Sidekiq retries (default: 5)
+  config.batch_size = 50                        # :thread, events per batch (default and max: 100)
+  config.flush_interval = 10                    # :thread, seconds between batches (default: 5)
+  config.max_queue_size = 5_000                 # :thread, events in memory before dropping (default: 10_000)
+
+  config.event_types += %w[approve]             # Types registered in your OptiAudit instance
+  config.actor { |controller| controller.send(:true_user) }
+end
+```
+
+## Testing your app
+
+Tracking is disabled in the test environment. To assert on events, switch to test mode: events are
+built and validated as in production but kept in memory.
+
+```ruby
+# spec/rails_helper.rb
+require "optiaudit/testing"
+
+RSpec.configure do |config|
+  config.before { Optiaudit::Testing.fake! }
+  config.after  { Optiaudit::Testing.disable! }
+end
+
+# spec/requests/routes_spec.rb
+it "audits the update" do
+  patch route_path(route), params: { route: { name: "Norte" } }
+
+  expect(Optiaudit::Testing.events.last).to include(
+    "event_type" => "update",
+    "actor_id" => user.id.to_s,
+    "metadata" => include("module" => "routes")
+  )
+end
+```
+
+## Track Params
+
+Fields accepted by `Optiaudit.track` and `optiaudit_track`, with the limits of OptiAudit's API:
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `event_type` | string | Required. One of the [event types](#event-types). |
+| `actor_id` | string | Required. Integers are converted. Truncated to 100. |
+| `actor_type` | string | Default `"user"`. Truncated to 20. |
+| `actor_email` | string | Omitted if it is not a valid email. |
+| `organization_id` | integer | Omitted if it is not an integer (digit strings are converted). |
+| `resource_type` | string | Truncated to 100. |
+| `resource_id` | string | Truncated to 100. |
+| `resource_path` | string | Truncated to 500. |
+| `ip_address` | string | Truncated to 45. |
+| `user_agent` | string | |
+| `session_id` | string | Truncated to 255. `optiaudit_track` sends a SHA-256. |
+| `metadata` | hash | Free-form. Converted to JSON types. |
+| `client_timestamp` | Time or ISO 8601 string | Default: when `track` is called, not when the event is sent. |
+
+OptiAudit rejects the whole event when one field is invalid, and in a batch, the whole batch. That is why
+the gem truncates or omits fields instead of sending them as they are.
+
+## Behavior
+
+| Condition | Behavior |
+|-----------|----------|
+| No env vars | Silently disabled |
+| `RAILS_ENV=test` | Silently disabled (unless `enabled = true` or `Optiaudit::Testing.fake!`) |
+| No actor | Event not sent |
+| Action raised or response 4xx/5xx | Event not sent |
+| Unknown `event_type` | Event not sent, logs warning |
+| Invalid `actor_email` / `organization_id` | Field omitted, event sent |
+| HTTP 5xx, 429, timeout (3s), connection error | Logs warning, doesn't raise. Sidekiq retries. |
+| HTTP 4xx (other) | Logs warning, doesn't raise, no retry |
+| HTTP 207 on a batch | Logs warning with the rejected events |
+| Redis down when enqueueing | Logs warning, doesn't raise |
+
+## Contributing
+
+1. Clone the repository and create your branch (`git checkout -b feature/amazing-feature`)
+2. Run the tests for each supported Rails version:
+   ```bash
+   BUNDLE_GEMFILE=gemfiles/rails_5_2.gemfile bundle install && BUNDLE_GEMFILE=gemfiles/rails_5_2.gemfile bundle exec rspec
+   ```
+3. Update `CHANGELOG.md` and, for a release, `lib/optiaudit/version.rb`
+4. Push the branch and open a Pull Request
+
+To try the gem end to end against a real OptiAudit (e.g. development), `examples/smoke.rb` sends a
+`page_view` through the full Rails stack:
+
+```bash
+OPTIAUDIT_URL=https://... OPTIAUDIT_WRITE_KEY=oat-... bundle exec ruby examples/smoke.rb
+```
+
+Releases are published to rubygems.org from Bitbucket Pipelines with the manual `custom: publish` pipeline.
+
+## License
+
+MIT. See [LICENSE.txt](LICENSE.txt).

data/lib/optiaudit/actor.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Optiaudit
+  # Finds who performed the action, as the NestJS package does with the request
+  # user: id, email and organization. Without an id there is no event.
+  module Actor
+    module_function
+
+    # Returns the actor fields for Optiaudit.track, or nil.
+    def resolve(controller, config)
+      source = config.actor ? config.actor.call(controller) : current_user(controller)
+      return if source.nil?
+
+      fields = source.is_a?(Hash) ? from_hash(source) : from_object(source)
+      Util.blank?(fields[:actor_id]) ? nil : fields
+    end
+
+    def current_user(controller)
+      controller.send(:current_user) if controller.respond_to?(:current_user, true)
+    end
+
+    def from_hash(hash)
+      hash = Util.stringify_keys(hash)
+      {
+        actor_id: hash["id"],
+        actor_email: hash["email"],
+        actor_type: hash["type"],
+        organization_id: hash["organization_id"]
+      }.compact
+    end
+
+    def from_object(user)
+      {
+        actor_id: read(user, :id),
+        actor_email: read(user, :email),
+        organization_id: read(user, :organization_id)
+      }.compact
+    end
+
+    def read(object, attribute)
+      object.public_send(attribute) if object.respond_to?(attribute)
+    end
+  end
+end

data/lib/optiaudit/adapters/inline.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Optiaudit
+  module Adapters
+    # Sends the event synchronously, in the caller's thread. Meant for the
+    # console, scripts and debugging: in a request it adds up to `timeout`
+    # seconds of latency.
+    class Inline
+      def initialize(config)
+        @client = Client.new(config)
+      end
+
+      def deliver(event)
+        @client.send_event(event)
+      end
+    end
+  end
+end

data/lib/optiaudit/adapters/sidekiq.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "optiaudit/sidekiq_job"
+
+module Optiaudit
+  module Adapters
+    # Enqueues one Sidekiq job per event. The event survives deploys and
+    # restarts, and failures that can succeed later are retried with Sidekiq's
+    # backoff (see Optiaudit::SidekiqJob).
+    class Sidekiq
+      def initialize(config)
+        @config = config
+      end
+
+      def deliver(event)
+        Optiaudit::SidekiqJob.set(queue: @config.queue, retry: @config.max_retries).perform_async(event)
+      end
+    end
+  end
+end

data/lib/optiaudit/adapters/threaded.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Optiaudit
+  module Adapters
+    # Keeps events in memory and sends them from a background thread to
+    # POST /events/batch, every `flush_interval` seconds or as soon as
+    # `batch_size` events are waiting.
+    #
+    # The thread starts with the first event of each process, so it also works
+    # in forked servers (Puma, Unicorn): a child process notices the pid change
+    # and starts its own buffer and thread. Pending events are flushed at exit.
+    #
+    # Events in memory are lost if the process is killed, and failed batches are
+    # not retried. When that matters, use the :sidekiq adapter.
+    class Threaded
+      def initialize(config)
+        @config = config
+        @client = Client.new(config)
+        @start_lock = Mutex.new
+        @pid = nil
+      end
+
+      def deliver(event)
+        start_for_current_process
+        @mutex.synchronize do
+          if @buffer.size >= @config.max_queue_size
+            Optiaudit.log_warning("event #{event['event_type']} dropped: #{@buffer.size} events waiting")
+            return
+          end
+          @buffer << event
+          @wakeup.signal if @buffer.size >= @config.batch_size
+        end
+      end
+
+      def flush
+        return unless started_in_this_process?
+
+        events = @mutex.synchronize { @buffer.slice!(0..-1) }
+        events.each_slice(@config.batch_size) { |batch| @client.send_batch(batch) }
+      end
+
+      def shutdown(timeout = @config.timeout + 1)
+        return unless started_in_this_process?
+
+        @stopping = true
+        @mutex.synchronize { @wakeup.signal }
+        @thread.join(timeout)
+        flush
+      end
+
+      private
+
+      def started_in_this_process?
+        @pid == Process.pid
+      end
+
+      def start_for_current_process
+        return if started_in_this_process?
+
+        @start_lock.synchronize do
+          next if started_in_this_process?
+
+          # A forked child inherits the parent's buffer and a mutex whose owner
+          # thread does not exist here: start from scratch.
+          @mutex = Mutex.new
+          @wakeup = ConditionVariable.new
+          @buffer = []
+          @stopping = false
+          @thread = Thread.new { run }
+          @pid = Process.pid
+          at_exit { shutdown }
+        end
+      end
+
+      def run
+        until @stopping
+          @mutex.synchronize do
+            @wakeup.wait(@mutex, @config.flush_interval) if @buffer.size < @config.batch_size && !@stopping
+          end
+          begin
+            flush
+          rescue StandardError => e
+            Optiaudit.log_warning("batch not sent: #{e.class}: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/optiaudit/adapters.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "optiaudit/adapters/inline"
+require "optiaudit/adapters/threaded"
+
+module Optiaudit
+  # Delivery adapters. Each one answers `deliver(event)`; :thread also `flush`
+  # and `shutdown`, because it is the only one that keeps events in memory.
+  module Adapters
+    # name => [file, class name]. The Sidekiq adapter loads on demand: it needs Sidekiq.
+    REGISTRY = {
+      sidekiq: ["optiaudit/adapters/sidekiq", "Sidekiq"],
+      thread: ["optiaudit/adapters/threaded", "Threaded"],
+      inline: ["optiaudit/adapters/inline", "Inline"]
+    }.freeze
+
+    def self.build(name, config)
+      file, class_name = REGISTRY.fetch(name)
+      require file
+      const_get(class_name).new(config)
+    end
+  end
+end

data/lib/optiaudit/client.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Optiaudit
+  # Sends events to the OptiAudit API with Net::HTTP. Never raises: every
+  # outcome, including timeouts and connection errors, comes back as a Response.
+  class Client
+    class Response
+      attr_reader :status, :body, :error
+
+      def initialize(status: nil, body: nil, error: nil)
+        @status = status
+        @body = body
+        @error = error
+      end
+
+      def success?
+        !status.nil? && status >= 200 && status < 300
+      end
+
+      # 5xx, 429 and network errors can succeed later. Any other 4xx means the
+      # event (or the key) is invalid and sending it again changes nothing.
+      def retryable?
+        !error.nil? || status == 429 || status >= 500
+      end
+
+      def to_s
+        error ? "#{error.class}: #{error.message}" : "HTTP #{status} #{body}".strip
+      end
+    end
+
+    def initialize(config)
+      @config = config
+    end
+
+    def send_event(event)
+      request_id = event["metadata"] && event["metadata"]["request_id"]
+      response = post("/events", event, request_id)
+      warn_failure("event #{event['event_type']} not sent", response)
+      response
+    end
+
+    # OptiAudit answers 202 when every event was queued, 207 when some failed
+    # validation (their indexes come in `errors`) and 422 when all of them did.
+    def send_batch(events)
+      response = post("/events/batch", { "events" => events }, nil)
+      if response.status == 207
+        Optiaudit.log_warning("batch partially rejected: #{response.body}")
+      else
+        warn_failure("batch of #{events.size} events not sent", response)
+      end
+      response
+    end
+
+    private
+
+    def post(path, payload, request_id)
+      uri = URI.parse("#{@config.url.to_s.chomp('/')}#{path}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = @config.timeout
+      http.read_timeout = @config.timeout
+      http.write_timeout = @config.timeout if http.respond_to?(:write_timeout=)
+
+      request = Net::HTTP::Post.new(uri.request_uri, headers(request_id))
+      request.body = JSON.generate(payload)
+      response = http.request(request)
+      Response.new(status: response.code.to_i, body: response.body)
+    rescue StandardError => e
+      Response.new(error: e)
+    end
+
+    def headers(request_id)
+      headers = {
+        "Content-Type" => "application/json",
+        "X-API-Key" => @config.write_key.to_s,
+        "User-Agent" => "optiaudit-rails/#{Optiaudit::VERSION}"
+      }
+      headers["X-Request-ID"] = request_id if request_id
+      headers
+    end
+
+    def warn_failure(message, response)
+      Optiaudit.log_warning("#{message}: #{response}") unless response.success?
+    end
+  end
+end

data/lib/optiaudit/configuration.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Optiaudit
+  class Configuration
+    # Event types seeded in OptiAudit. Any other type is rejected by the API with
+    # 422 EVENT_TYPE_NOT_FOUND, so the gem drops it before sending.
+    DEFAULT_EVENT_TYPES = %w[
+      page_view login login_failed logout create update delete export config_change
+    ].freeze
+
+    DEFAULT_QUEUE = "optiaudit"
+    DEFAULT_MAX_RETRIES = 5
+
+    # url            - OptiAudit API base URL, including /api/v1 (default: ENV["OPTIAUDIT_URL"])
+    # write_key      - source system write key (default: ENV["OPTIAUDIT_WRITE_KEY"])
+    # timeout        - HTTP open/read timeout in seconds (default: 3)
+    # enabled        - nil decides from url, write_key and environment; true/false forces it
+    # log_errors     - log a warning when an event cannot be sent (default: true)
+    # logger         - defaults to Rails.logger
+    # adapter        - :sidekiq, :thread or :inline (default: :sidekiq if Sidekiq is loaded, else :thread)
+    # queue          - Sidekiq queue (default: "optiaudit")
+    # max_retries    - Sidekiq retries on 5xx, 429, timeout or connection errors (default: 5)
+    # batch_size     - :thread adapter, events per POST /events/batch (default and API maximum: 100)
+    # flush_interval - :thread adapter, seconds between flushes (default: 5)
+    # max_queue_size - :thread adapter, events kept in memory before dropping new ones (default: 10_000)
+    # event_types    - event types accepted by the OptiAudit instance (default: DEFAULT_EVENT_TYPES)
+    attr_accessor :url, :write_key, :timeout, :enabled, :log_errors, :logger,
+                  :adapter, :queue, :max_retries,
+                  :batch_size, :flush_interval, :max_queue_size,
+                  :event_types
+
+    def initialize
+      @url = ENV["OPTIAUDIT_URL"]
+      @write_key = ENV["OPTIAUDIT_WRITE_KEY"]
+      @timeout = 3
+      @enabled = nil
+      @log_errors = true
+      @logger = nil
+      @adapter = nil
+      @queue = DEFAULT_QUEUE
+      @max_retries = DEFAULT_MAX_RETRIES
+      @batch_size = 100
+      @flush_interval = 5
+      @max_queue_size = 10_000
+      @event_types = DEFAULT_EVENT_TYPES.dup
+      @actor_resolver = nil
+    end
+
+    # Sets how the controller macros find the actor. The block receives the controller
+    # and returns a user-like object (id, email, organization_id) or a hash with
+    # :id, :email, :organization_id and :type. Returning nil skips the event.
+    #
+    #   config.actor { |controller| controller.send(:true_user) }
+    def actor(&block)
+      @actor_resolver = block if block
+      @actor_resolver
+    end
+
+    # Disabled without url or write_key. Otherwise enabled outside the test
+    # environment, unless `enabled` forces it.
+    def enabled?
+      return false if @enabled == false
+      return false if Util.blank?(url) || Util.blank?(write_key)
+
+      @enabled == true || !test_environment?
+    end
+
+    def adapter_name
+      name = adapter ? adapter.to_sym : default_adapter
+      return name if Adapters::REGISTRY.key?(name)
+
+      raise ArgumentError, "unknown Optiaudit adapter #{adapter.inspect} (use one of #{Adapters::REGISTRY.keys.join(', ')})"
+    end
+
+    private
+
+    def default_adapter
+      defined?(::Sidekiq) ? :sidekiq : :thread
+    end
+
+    def test_environment?
+      rails_env = ::Rails.env if defined?(::Rails) && ::Rails.respond_to?(:env)
+      (rails_env || ENV["RAILS_ENV"] || ENV["RACK_ENV"]).to_s == "test"
+    end
+  end
+end

data/lib/optiaudit/controller.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Optiaudit
+  # Controller macros, included in every controller by the Railtie.
+  #
+  #   class RoutesController < ApplicationController
+  #     optiaudit_page_view :routes, only: :index
+  #     optiaudit_event :update, :routes, only: :update,
+  #                     metadata: ->(controller) { { action: "reschedule", route_id: controller.params[:id] } }
+  #   end
+  #
+  # Events are tracked in an after_action, so they are only sent when the action
+  # did not raise, and only for 2xx and 3xx responses. Without an actor (no
+  # current_user, or the `actor` block returns nil) nothing is sent.
+  module Controller
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def optiaudit_page_view(module_name, **options)
+        optiaudit_event(:page_view, module_name, **options)
+      end
+
+      # Options: `metadata` (a hash, or a lambda that receives the controller and
+      # returns one) plus any after_action option (`only`, `except`, `if`, `unless`).
+      def optiaudit_event(event_type, module_name, metadata: nil, **callback_options)
+        after_action(**callback_options) do |controller|
+          controller.send(:optiaudit_track_action, event_type, module_name, metadata)
+        end
+      end
+    end
+
+    private
+
+    # Tracks an event with the actor and request data of this controller.
+    # `params` accepts every field of Optiaudit.track and overrides the defaults;
+    # `metadata` may also be a lambda that receives the controller.
+    #
+    #   optiaudit_track(:export, :reports, metadata: { action: "export_routes" })
+    def optiaudit_track(event_type, module_name, params = {})
+      return false unless Optiaudit.enabled?
+
+      actor = Actor.resolve(self, Optiaudit.configuration)
+      return false unless actor
+
+      Optiaudit.track(
+        actor.merge(RequestData.from(request))
+             .merge(params)
+             .merge(event_type: event_type.to_s, metadata: optiaudit_metadata(module_name, params[:metadata]))
+      )
+    rescue StandardError => e
+      Optiaudit.log_warning("could not track #{event_type} in #{self.class.name}##{action_name}: #{e.class}: #{e.message}")
+      false
+    end
+
+    def optiaudit_track_action(event_type, module_name, metadata)
+      return unless response.status >= 200 && response.status < 400
+
+      optiaudit_track(event_type, module_name, metadata: metadata)
+    end
+
+    def optiaudit_metadata(module_name, extra)
+      extra = extra.call(self) if extra.respond_to?(:call)
+      metadata = { "module" => module_name.to_s }
+      metadata["request_id"] = request.request_id if request.request_id
+      metadata.merge(Util.stringify_keys(extra || {}))
+    end
+  end
+end

data/lib/optiaudit/event.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module Optiaudit
+  # Builds the payload of POST /events from the params of Optiaudit.track.
+  #
+  # OptiAudit validates every field and rejects the whole event (and, in a batch,
+  # the whole batch) when one is invalid. So instead of sending something that
+  # will come back as 400/422, fields are fixed here: strings are truncated to
+  # the API limits, an invalid actor_email is omitted and a non-integer
+  # organization_id is omitted.
+  module Event
+    # Limits from OptiAudit's CreateEventDto.
+    MAX_LENGTHS = {
+      "event_type" => 50,
+      "actor_id" => 100,
+      "actor_type" => 20,
+      "actor_email" => 255,
+      "resource_type" => 100,
+      "resource_id" => 100,
+      "resource_path" => 500,
+      "ip_address" => 45,
+      "session_id" => 255
+    }.freeze
+
+    STRING_FIELDS = (MAX_LENGTHS.keys + ["user_agent"]).freeze
+
+    LOCAL_ATOM = %r{\A[\p{L}\p{N}!#$%&'*+\-/=?^_`{|}~]+\z}.freeze
+    QUOTED_LOCAL_PART = /\A"[^"\\]*"\z/.freeze
+    DOMAIN_LABEL = /\A[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,61}[\p{L}\p{N}])?\z/.freeze
+    TOP_LEVEL_DOMAIN = /\A(?:\p{L}{2,}|xn--[a-z0-9-]+)\z/i.freeze
+
+    DEFAULT_ACTOR_TYPE = "user"
+
+    module_function
+
+    # Returns the event as a hash of string keys and JSON types (safe as a
+    # Sidekiq argument), or nil when it must not be sent.
+    def build(params, config)
+      params = Util.stringify_keys(params || {})
+      event_type = params["event_type"].to_s
+      actor_id = params["actor_id"].to_s
+
+      if Util.blank?(event_type) || Util.blank?(actor_id)
+        Optiaudit.log_warning("event skipped: event_type and actor_id are required")
+        return nil
+      end
+      unless config.event_types.map(&:to_s).include?(event_type)
+        Optiaudit.log_warning("event skipped: unknown event_type #{event_type.inspect}")
+        return nil
+      end
+
+      event = {}
+      STRING_FIELDS.each do |field|
+        value = params[field]
+        event[field] = truncate(value.to_s, MAX_LENGTHS[field]) unless Util.blank?(value)
+      end
+      event["actor_type"] ||= DEFAULT_ACTOR_TYPE
+      event.delete("actor_email") unless email?(event["actor_email"])
+
+      organization_id = integer(params["organization_id"])
+      event["organization_id"] = organization_id if organization_id
+      event["metadata"] = params["metadata"] if params["metadata"].is_a?(Hash) && !params["metadata"].empty?
+      event["client_timestamp"] = timestamp(params["client_timestamp"])
+
+      # Round trip through JSON: symbols, times and nested objects in metadata
+      # end up as JSON types, which Sidekiq 7 requires for job arguments.
+      JSON.parse(JSON.generate(event))
+    end
+
+    def truncate(value, max_length)
+      max_length && value.length > max_length ? value[0, max_length] : value
+    end
+
+    # Same rule as class-validator's IsEmail (validator.js isEmail with its
+    # defaults): local part of dot-separated atoms or a quoted string, up to 64
+    # characters; a domain of valid labels ending in an alphabetic TLD of 2 or
+    # more characters. "a@b.c", "a@x.123", "john.@x.com" and "ana@x.com." are
+    # rejected by the API, so they are rejected here.
+    def email?(value)
+      return false if value.nil? || value.length > MAX_LENGTHS["actor_email"]
+
+      local, at, domain = value.rpartition("@")
+      return false if at.empty? || local.empty? || local.length > 64
+
+      local_part?(local) && domain?(domain)
+    end
+
+    def local_part?(local)
+      return local.match?(QUOTED_LOCAL_PART) if local.start_with?('"')
+
+      local.split(".", -1).all? { |atom| atom.match?(LOCAL_ATOM) }
+    end
+
+    def domain?(domain)
+      labels = domain.split(".", -1)
+      labels.size >= 2 && labels.all? { |label| label.match?(DOMAIN_LABEL) } && labels.last.match?(TOP_LEVEL_DOMAIN)
+    end
+
+    def integer(value)
+      return value if value.is_a?(Integer)
+
+      Integer(value, 10) if value.is_a?(String) && value.match?(/\A\d+\z/)
+    end
+
+    def timestamp(value)
+      case value
+      when nil then Time.now.utc.iso8601(3)
+      when Time, DateTime then value.to_time.utc.iso8601(3)
+      else value.to_s
+      end
+    end
+  end
+end

data/lib/optiaudit/rails.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "optiaudit"
+require "optiaudit/railtie" if defined?(::Rails::Railtie)

data/lib/optiaudit/railtie.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module Optiaudit
+  class Railtie < ::Rails::Railtie
+    initializer "optiaudit.controller" do
+      ActiveSupport.on_load(:action_controller) do
+        require "optiaudit/controller"
+        include Optiaudit::Controller
+      end
+    end
+
+    # The Sidekiq server process has to know the job class even if no event
+    # was tracked in that process.
+    config.after_initialize do
+      require "optiaudit/sidekiq_job" if defined?(::Sidekiq)
+    end
+  end
+end

data/lib/optiaudit/request_data.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Optiaudit
+  # Event fields taken from the request: path, client IP, user agent and session.
+  module RequestData
+    module_function
+
+    def from(request)
+      {
+        resource_path: request.path,
+        ip_address: client_ip(request),
+        user_agent: request.user_agent,
+        session_id: session_id(request)
+      }
+    end
+
+    # remote_ip skips trusted proxies (private ranges by default), so behind a
+    # load balancer it returns the client's public IP. In Rails 5.2 it raises
+    # when Client-IP and X-Forwarded-For disagree.
+    def client_ip(request)
+      request.remote_ip
+    rescue ActionDispatch::RemoteIp::IpSpoofAttackError => e
+      Optiaudit.log_warning("remote_ip rejected (#{e.message}), using request.ip")
+      request.ip
+    end
+
+    # Hashed: the raw session id is a credential and never leaves the app.
+    # Only read when the action already loaded the session (authentication
+    # does), so tracking never creates a session or sets a cookie.
+    def session_id(request)
+      session = request.session
+      return unless session.respond_to?(:loaded?) && session.loaded?
+
+      id = session.id
+      id = id.public_id if id.respond_to?(:public_id)
+      Digest::SHA256.hexdigest(id.to_s) unless Util.blank?(id)
+    end
+  end
+end

data/lib/optiaudit/sidekiq_job.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Optiaudit
+  # Raised so that Sidekiq retries the job. Only for failures that can succeed
+  # later: 5xx, 429, timeouts and connection errors.
+  class RetryableDeliveryError < StandardError; end
+
+  class SidekiqJob
+    include(defined?(::Sidekiq::Job) ? ::Sidekiq::Job : ::Sidekiq::Worker)
+
+    # Only used when the job is enqueued by hand: the adapter sets the queue and
+    # retries from the configuration on every event.
+    sidekiq_options queue: Configuration::DEFAULT_QUEUE, retry: Configuration::DEFAULT_MAX_RETRIES
+
+    sidekiq_retries_exhausted do |job, _exception|
+      Optiaudit.log_warning("event #{job['args'].first['event_type']} dropped: retries exhausted")
+    end
+
+    # Runs in the Sidekiq process, where there is no adapter instance: the
+    # configuration comes from the app's initializer.
+    def perform(event)
+      response = Client.new(Optiaudit.configuration).send_event(event)
+      raise RetryableDeliveryError, response.to_s if response.retryable?
+    end
+  end
+end

data/lib/optiaudit/testing.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Optiaudit
+  # Test mode for apps that use the gem. Events are built and validated as in
+  # production but kept in memory instead of being sent.
+  #
+  #   # spec/rails_helper.rb
+  #   require "optiaudit/testing"
+  #   config.before { Optiaudit::Testing.fake! }
+  #   config.after  { Optiaudit::Testing.disable! }
+  #
+  #   expect(Optiaudit::Testing.events.last).to include("event_type" => "update")
+  module Testing
+    class Adapter
+      attr_reader :events
+
+      def initialize
+        @events = []
+      end
+
+      def deliver(event)
+        @events << event
+      end
+    end
+
+    module_function
+
+    # Enables tracking without url or write key and records every event.
+    def fake!
+      @adapter = Adapter.new
+    end
+
+    def disable!
+      @adapter = nil
+    end
+
+    def fake?
+      !@adapter.nil?
+    end
+
+    def adapter
+      @adapter
+    end
+
+    def events
+      fake? ? @adapter.events : []
+    end
+
+    def clear!
+      events.clear
+    end
+  end
+end

data/lib/optiaudit/util.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Optiaudit
+  # Helpers shared by the event builder, the actor and the configuration.
+  module Util
+    module_function
+
+    def stringify_keys(hash)
+      hash.each_with_object({}) { |(key, value), result| result[key.to_s] = value }
+    end
+
+    def blank?(value)
+      value.nil? || value.to_s.strip.empty?
+    end
+  end
+end

data/lib/optiaudit/version.rb

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

data/lib/optiaudit-rails.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "optiaudit/rails"

data/lib/optiaudit.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "logger"
+require "optiaudit/version"
+require "optiaudit/util"
+require "optiaudit/adapters"
+require "optiaudit/configuration"
+require "optiaudit/event"
+require "optiaudit/client"
+require "optiaudit/actor"
+require "optiaudit/request_data"
+require "optiaudit/testing"
+
+# Sends audit events to OptiAudit. See README.md.
+module Optiaudit
+  ADAPTER_LOCK = Mutex.new
+  private_constant :ADAPTER_LOCK
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Optiaudit.configure do |config|
+    #   config.adapter = :sidekiq
+    #   config.actor { |controller| controller.send(:true_user) }
+    # end
+    def configure
+      yield configuration
+      discard_adapter
+      configuration
+    end
+
+    def enabled?
+      Testing.fake? || configuration.enabled?
+    end
+
+    # Tracks an event. Returns true when it was handed to the adapter, false when
+    # it was skipped (disabled, invalid) or failed. Never raises.
+    #
+    #   Optiaudit.track(event_type: "export", actor_id: user.id, actor_email: user.email,
+    #                   organization_id: user.organization_id, metadata: { module: "reports" })
+    #
+    # Fields: event_type, actor_id (required), actor_type, actor_email,
+    # organization_id, resource_type, resource_id, resource_path, ip_address,
+    # user_agent, session_id, metadata, client_timestamp (default: now).
+    def track(params = {})
+      return false unless enabled?
+
+      event = Event.build(params, configuration)
+      return false unless event
+
+      adapter.deliver(event)
+      true
+    rescue StandardError => e
+      log_warning("event not tracked: #{e.class}: #{e.message}")
+      false
+    end
+
+    # Sends what the :thread adapter has in memory. No-op for other adapters.
+    def flush
+      adapter.flush if adapter.respond_to?(:flush)
+    end
+
+    def adapter
+      return Testing.adapter if Testing.fake?
+
+      @adapter || ADAPTER_LOCK.synchronize { @adapter ||= build_adapter }
+    end
+
+    def logger
+      configuration.logger || rails_logger || (@default_logger ||= Logger.new($stderr))
+    end
+
+    def log_warning(message)
+      logger.warn("[Optiaudit] #{message}") if configuration.log_errors
+    end
+
+    # Back to defaults (reads the environment again). For tests.
+    def reset!
+      discard_adapter
+      @configuration = nil
+    end
+
+    private
+
+    def build_adapter
+      Adapters.build(configuration.adapter_name, configuration)
+    end
+
+    # A :thread adapter built with the previous configuration sends what it
+    # has and stops, instead of running alongside the new one.
+    def discard_adapter
+      adapter = ADAPTER_LOCK.synchronize do
+        previous = @adapter
+        @adapter = nil
+        previous
+      end
+      adapter.shutdown if adapter.respond_to?(:shutdown)
+    end
+
+    def rails_logger
+      ::Rails.logger if defined?(::Rails) && ::Rails.respond_to?(:logger)
+    end
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: optiaudit-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- The Optimal Partner
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-10-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+description: Rails client for OptiAudit, the audit and usage tracking service of The
+  Optimal Partner. Controller macros, manual tracking, and Sidekiq, background thread
+  or inline delivery that never breaks or slows down the request. Ruby counterpart
+  of @theoptimalpartner/nestjs-optiaudit.
+email:
+- dev@theoptimalpartner.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/optiaudit-rails.rb
+- lib/optiaudit.rb
+- lib/optiaudit/actor.rb
+- lib/optiaudit/adapters.rb
+- lib/optiaudit/adapters/inline.rb
+- lib/optiaudit/adapters/sidekiq.rb
+- lib/optiaudit/adapters/threaded.rb
+- lib/optiaudit/client.rb
+- lib/optiaudit/configuration.rb
+- lib/optiaudit/controller.rb
+- lib/optiaudit/event.rb
+- lib/optiaudit/rails.rb
+- lib/optiaudit/railtie.rb
+- lib/optiaudit/request_data.rb
+- lib/optiaudit/sidekiq_job.rb
+- lib/optiaudit/testing.rb
+- lib/optiaudit/util.rb
+- lib/optiaudit/version.rb
+homepage: https://bitbucket.org/RoutingUC/optiaudit-rails
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://bitbucket.org/RoutingUC/optiaudit-rails
+  source_code_uri: https://bitbucket.org/RoutingUC/optiaudit-rails
+  changelog_uri: https://bitbucket.org/RoutingUC/optiaudit-rails/src/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Send audit events from Rails apps to OptiAudit.
+test_files: []