aptabase-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a789fcfdf15e96d57c8f3003265c50ab4f495636db7bba375e8187772c560460
+  data.tar.gz: e8729f5338cba96e112237c68b09d135575f29f354b8e5d3072177cd61a5d393
+SHA512:
+  metadata.gz: 6b797acc2b0b396ad410cf25f70daea999c2ad6bd37be07851b3df7e18b9ca62b3baebed4c903b800f3ea7b5657d09d30e2569be8cffa4ab0d90a98b172638af
+  data.tar.gz: 97c6b0dd5c9df7f186506ac1e6b5a76ad839abbd4a12d6579fb6fce08cc3a1af4ee2260d2e40b0ab976f702fb132cec5be3f224adef9e0396dafe35f16c822fd

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-06-11
+
+Initial release, ported from [aptabase-python](https://github.com/aptabase/aptabase-python)
+and verified against the live Aptabase ingestion API.
+
+### Added
+
+- `Aptabase.init` / `Aptabase.track` / `Aptabase.flush` / `Aptabase.stop` module-level singleton API
+- `Aptabase::Client` instance API, including a block form that guarantees flush on exit
+- Background worker thread with auto-batching (max 25 events) and periodic flushing (default 10s)
+- Failed batches are re-queued and retried; network errors never raise from `track`
+- Session tracking with a 1-hour inactivity timeout, using the id format shared by all Aptabase SDKs
+- Fork-safety: the worker thread restarts automatically in forked Puma/Unicorn workers
+- Pending events are flushed automatically at process exit
+- EU/US region routing derived from the app key; self-hosted instances via `base_url:`
+- Rails integration: railtie that defaults the SDK logger to `Rails.logger`
+- `rails generate aptabase:install` generator for the initializer
+- Runnable samples: a plain Ruby script and a single-file Rails app
+- CI across Ruby 3.1-3.4 and Rails 7.1, 7.2, 8.0 and latest
+
+[0.1.0]: https://github.com/tiny-cloud-ventures/aptabase-ruby/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tiny Cloud Ventures
+
+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,185 @@
+# Aptabase Ruby SDK
+
+[![Gem Version](https://badge.fury.io/rb/aptabase-ruby.svg)](https://rubygems.org/gems/aptabase-ruby)
+[![CI](https://github.com/tiny-cloud-ventures/aptabase-ruby/actions/workflows/ci.yml/badge.svg)](https://github.com/tiny-cloud-ventures/aptabase-ruby/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+Ruby and Rails SDK for [Aptabase](https://aptabase.com/) - open source, privacy-first
+analytics for mobile, desktop and web applications.
+
+> **Status:** 0.x - the API is stable and verified against the live Aptabase
+> ingestion API, but minor releases may still include breaking changes until 1.0.
+
+## Features
+
+- 🧵 **Non-blocking** - `track` queues in memory; a background thread does the sending
+- 🔒 **Privacy-first** - no personal data collection, no device identifiers
+- 🔄 **Auto-batching** - events are batched (max 25) and flushed every 10 seconds
+- ♻️ **Resilient** - failed batches are re-queued and retried; tracking never raises on network errors
+- ⚡ **Zero dependencies** - stdlib only
+- 🛤️ **Rails-friendly** - install generator, `Rails.logger` integration, fork-safe under Puma cluster mode, flushes on exit
+
+## Requirements
+
+- Ruby 3.1+
+- Rails 7.1+ (optional - the SDK works in any Ruby program)
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "aptabase-ruby"
+```
+
+Or install directly:
+
+```bash
+gem install aptabase-ruby
+```
+
+## Quick Start
+
+```ruby
+require "aptabase"
+
+Aptabase.init("A-EU-1234567890") # your app key
+
+# Track a simple event
+Aptabase.track("app_started")
+
+# Track an event with properties
+Aptabase.track("user_action", {
+  "action" => "button_click",
+  "button_id" => "login",
+  "screen" => "home"
+})
+
+# Events are flushed automatically (and on process exit),
+# but you can force it:
+Aptabase.flush
+```
+
+## Rails
+
+Add the gem, then generate the initializer:
+
+```bash
+rails generate aptabase:install
+```
+
+This creates `config/initializers/aptabase.rb`, which reads the app key from
+`Rails.application.credentials.dig(:aptabase, :app_key)` or `ENV["APTABASE_APP_KEY"]`.
+
+Then call `Aptabase.track` anywhere - controllers, jobs, models:
+
+```ruby
+class OrdersController < ApplicationController
+  def create
+    # ...
+    Aptabase.track("order_created", { "total_cents" => order.total_cents })
+  end
+end
+```
+
+The SDK logs through `Rails.logger` by default, restarts its background thread
+automatically in forked Puma/Unicorn workers, and flushes pending events when
+the process exits.
+
+See [samples/rails-app](samples/rails-app) for a runnable single-file example.
+
+## Configuration
+
+```ruby
+Aptabase.init(
+  "A-EU-1234567890",          # Your Aptabase app key
+  app_version: "1.2.3",       # Your app's version, shown in the dashboard
+  is_debug: false,            # Debug events are kept separate in Aptabase
+  max_batch_size: 25,         # Max events per request (hard max 25)
+  flush_interval: 10.0,       # Auto-flush interval in seconds
+  timeout: 30.0,              # HTTP timeout in seconds
+  logger: Logger.new($stderr) # Where SDK warnings/debug logs go
+)
+```
+
+## App Key Format
+
+Your app key determines the server region:
+
+| Key prefix | Region                                          |
+| ---------- | ----------------------------------------------- |
+| `A-EU-*`   | European servers                                |
+| `A-US-*`   | US servers                                      |
+| `A-SH-*`   | Self-hosted - requires the `base_url:` option   |
+
+Get your app key from the [Aptabase dashboard](https://aptabase.com/).
+
+```ruby
+# Self-hosted instance
+Aptabase.init("A-SH-1234567890", base_url: "https://analytics.example.com")
+```
+
+## Instance API
+
+For multiple apps or explicit lifecycle control, use `Aptabase::Client` directly:
+
+```ruby
+client = Aptabase::Client.new("A-EU-1234567890", app_version: "1.0.0")
+client.track("event")
+client.flush          # synchronous send
+client.pending_count  # events queued, not yet delivered
+client.stop           # flushes remaining events
+
+# Block form - stop/flush guaranteed on exit
+Aptabase::Client.start("A-EU-1234567890") do |client|
+  client.track("event")
+end
+```
+
+## Sessions
+
+Events are grouped into sessions automatically. A session id is reused until
+one hour of inactivity, then rotated - the same semantics and id format as the
+official Aptabase SDKs, so dashboards behave identically.
+
+## Error Handling
+
+Network failures never raise from `track` - failed batches are logged,
+re-queued and retried on the next flush. Programmer errors do raise:
+
+| Error                         | Raised when                                  |
+| ----------------------------- | -------------------------------------------- |
+| `Aptabase::ConfigurationError`| bad app key or invalid options               |
+| `Aptabase::ValidationError`   | bad event name or props                      |
+| `Aptabase::NetworkError`      | internal transport failures (`#status_code`) |
+
+All inherit from `Aptabase::Error`.
+
+## Samples
+
+- [Simple script](samples/simple-script) - plain Ruby, no framework
+- [Rails app](samples/rails-app) - single-file Rails app via `bundler/inline`
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec    # run tests
+bundle exec rubocop  # lint
+
+# run the suite against a specific Rails version
+BUNDLE_GEMFILE=gemfiles/rails_80.gemfile bundle install
+BUNDLE_GEMFILE=gemfiles/rails_80.gemfile bundle exec rspec
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome at
+[tiny-cloud-ventures/aptabase-ruby](https://github.com/tiny-cloud-ventures/aptabase-ruby/issues).
+
+## License
+
+[MIT](LICENSE)
+
+This is a community SDK, ported from the official
+[aptabase-python](https://github.com/aptabase/aptabase-python) SDK.

data/lib/aptabase/client.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Aptabase
+  # Aptabase analytics client.
+  #
+  # `track` is synchronous and cheap: it validates the event and pushes it
+  # onto an in-memory queue. A background worker thread flushes the queue
+  # every `flush_interval` seconds, or as soon as `max_batch_size` events
+  # are pending. Failed batches are re-queued and retried on the next flush.
+  class Client
+    HOSTS = {
+      "EU" => "https://eu.aptabase.com",
+      "US" => "https://us.aptabase.com"
+    }.freeze
+
+    MAX_BATCH_SIZE = 25
+
+    attr_reader :app_key, :base_url, :logger
+
+    # Block form: yields the client and guarantees stop/flush on exit.
+    #
+    #   Aptabase::Client.start("A-EU-123") { |client| client.track("event") }
+    def self.start(app_key, **options)
+      client = new(app_key, **options)
+      return client unless block_given?
+
+      begin
+        yield client
+      ensure
+        client.stop
+      end
+    end
+
+    def initialize(app_key, app_version: "1.0.0", is_debug: false,
+                   max_batch_size: MAX_BATCH_SIZE, flush_interval: 10.0,
+                   timeout: 30.0, base_url: nil, logger: nil)
+      validate_app_key!(app_key)
+      raise ConfigurationError, "Maximum batch size is #{MAX_BATCH_SIZE} events" if max_batch_size > MAX_BATCH_SIZE
+      raise ConfigurationError, "max_batch_size must be at least 1" if max_batch_size < 1
+
+      @app_key = app_key
+      @base_url = base_url || default_base_url(app_key)
+      @system_props = SystemProperties.new(app_version: app_version, is_debug: is_debug)
+      @max_batch_size = max_batch_size
+      @flush_interval = flush_interval
+      @logger = logger || Logger.new($stderr, progname: "aptabase", level: Logger::INFO)
+      @transport = Transport.new(base_url: @base_url, app_key: app_key, timeout: timeout)
+      @session = Session.new
+
+      @queue = []
+      @queue_mutex = Mutex.new
+      @flush_mutex = Mutex.new
+      @wake = ConditionVariable.new
+      @worker = nil
+      @stopping = false
+      @pid = Process.pid
+    end
+
+    # Track an analytics event.
+    #
+    #   client.track("app_started")
+    #   client.track("purchase", { "product_id" => "abc", "price" => 29.99 })
+    def track(event_name, props = nil)
+      unless event_name.is_a?(String) && !event_name.empty?
+        raise ValidationError, "Event name is required and must be a non-empty string"
+      end
+      raise ValidationError, "Event properties must be a Hash" if !props.nil? && !props.is_a?(Hash)
+
+      event = Event.new(name: event_name, session_id: @session.id, props: props)
+
+      @queue_mutex.synchronize do
+        ensure_worker
+        @queue << event
+        @wake.signal if @queue.size >= @max_batch_size
+      end
+      nil
+    end
+
+    # Synchronously send all queued events in batches of `max_batch_size`.
+    # On failure the unsent events stay queued for the next flush.
+    def flush
+      @flush_mutex.synchronize do
+        loop do
+          batch = @queue_mutex.synchronize { @queue.shift(@max_batch_size) }
+          break if batch.empty?
+
+          begin
+            @transport.post_events(batch.map { |event| event.to_h(@system_props) })
+            logger.debug { "[aptabase] sent #{batch.size} event(s)" }
+          rescue NetworkError => e
+            logger.warn("[aptabase] failed to send #{batch.size} event(s), will retry: #{e.message}")
+            @queue_mutex.synchronize { @queue.unshift(*batch) }
+            break
+          end
+        end
+      end
+      nil
+    end
+
+    # Stop the background worker and flush any remaining events.
+    # The client can keep being used afterwards; tracking restarts the worker.
+    def stop
+      worker = nil
+      @queue_mutex.synchronize do
+        @stopping = true
+        worker = @worker
+        @wake.broadcast
+      end
+      worker.join(@flush_interval + 1) if worker && worker != Thread.current
+      flush
+      @queue_mutex.synchronize do
+        @worker = nil
+        @stopping = false
+      end
+      nil
+    end
+
+    # Number of events queued and not yet delivered.
+    def pending_count
+      @queue_mutex.synchronize { @queue.size }
+    end
+
+    private
+
+    def validate_app_key!(app_key)
+      unless app_key.is_a?(String) && !app_key.empty?
+        raise ConfigurationError, "App key is required and must be a string"
+      end
+
+      parts = app_key.split("-")
+      return if parts.length == 3 && parts[0] == "A" && (HOSTS.key?(parts[1]) || parts[1] == "SH")
+
+      raise ConfigurationError, "Invalid app key format. Expected format: A-{REGION}-{ID}"
+    end
+
+    def default_base_url(app_key)
+      region = app_key.split("-")[1]
+      raise ConfigurationError, "Self-hosted app keys (A-SH-*) require the base_url option" if region == "SH"
+
+      HOSTS.fetch(region)
+    end
+
+    # Must be called with @queue_mutex held.
+    def ensure_worker
+      if @pid != Process.pid
+        # Forked child: the parent's worker thread does not survive fork.
+        @pid = Process.pid
+        @worker = nil
+        @stopping = false
+      end
+      return if @stopping || @worker&.alive?
+
+      @worker = Thread.new { worker_loop }
+      @worker.name = "aptabase-flusher"
+    end
+
+    def worker_loop
+      loop do
+        stopping = false
+        @queue_mutex.synchronize do
+          @wake.wait(@queue_mutex, @flush_interval) unless @stopping || @queue.size >= @max_batch_size
+          stopping = @stopping
+        end
+        flush
+        break if stopping
+      end
+    end
+  end
+end

data/lib/aptabase/errors.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Aptabase
+  # Base class for all errors raised by the SDK.
+  class Error < StandardError; end
+
+  # Raised when the SDK is misconfigured (bad app key, invalid options).
+  class ConfigurationError < Error; end
+
+  # Raised when event data fails validation.
+  class ValidationError < Error; end
+
+  # Raised when a request to the Aptabase API fails.
+  class NetworkError < Error
+    attr_reader :status_code
+
+    def initialize(message, status_code: nil)
+      super(message)
+      @status_code = status_code
+    end
+  end
+end

data/lib/aptabase/event.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+
+module Aptabase
+  # An analytics event queued for delivery to Aptabase.
+  class Event
+    attr_reader :name, :timestamp, :session_id, :props
+
+    def initialize(name:, timestamp: nil, session_id: nil, props: nil)
+      @name = name
+      @timestamp = (timestamp || Time.now).utc
+      @session_id = session_id || SecureRandom.uuid
+      @props = props || {}
+    end
+
+    def to_h(system_props)
+      {
+        "timestamp" => timestamp.iso8601(3),
+        "sessionId" => session_id,
+        "eventName" => name,
+        "systemProps" => system_props.to_h,
+        "props" => props
+      }
+    end
+  end
+end

data/lib/aptabase/railtie.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module Aptabase
+  # Rails integration. Kept deliberately thin: configuration happens
+  # explicitly in an initializer (see `rails g aptabase:install`); the
+  # railtie only wires the SDK's default logger to Rails.logger.
+  #
+  # Process-exit flushing and Puma/Unicorn fork-safety are handled by the
+  # core SDK and need no Rails-specific hooks.
+  class Railtie < ::Rails::Railtie
+    # after_initialize, not an initializer hook: Rails may wrap or replace
+    # Rails.logger during boot (e.g. with BroadcastLogger), so capture the
+    # final object once the app is fully initialized.
+    config.after_initialize do
+      Aptabase.default_logger ||= ::Rails.logger
+    end
+  end
+end

data/lib/aptabase/session.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Aptabase
+  # Session tracking with the same semantics as the other Aptabase SDKs:
+  # a session id is reused until one hour of inactivity, then rotated.
+  class Session
+    TIMEOUT = 60 * 60 # seconds
+
+    def initialize(clock: -> { Time.now })
+      @clock = clock
+      @mutex = Mutex.new
+      @id = nil
+      @last_touched = nil
+    end
+
+    def id
+      @mutex.synchronize do
+        now = @clock.call
+        @id = generate_id(now) if @id.nil? || now - @last_touched > TIMEOUT
+        @last_touched = now
+        @id
+      end
+    end
+
+    private
+
+    # Same id format as the other Aptabase SDKs:
+    # epoch seconds * 1e8 plus an 8-digit random part.
+    def generate_id(now)
+      ((now.to_i * 100_000_000) + rand(100_000_000)).to_s
+    end
+  end
+end

data/lib/aptabase/system_properties.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "etc"
+
+module Aptabase
+  # System properties automatically collected by the SDK and attached to
+  # every event. Mirrors the fields sent by the other Aptabase SDKs.
+  class SystemProperties
+    attr_reader :locale, :os_name, :os_version, :device_model,
+                :is_debug, :app_version, :sdk_version
+
+    def initialize(app_version: "1.0.0", is_debug: false)
+      uname = Etc.uname
+      @locale = detect_locale
+      @os_name = uname[:sysname]
+      @os_version = uname[:release]
+      @device_model = uname[:machine]
+      @is_debug = is_debug
+      @app_version = app_version
+      @sdk_version = "aptabase-ruby@#{VERSION}"
+    end
+
+    def to_h
+      {
+        "locale" => locale,
+        "osName" => os_name,
+        "osVersion" => os_version,
+        "deviceModel" => device_model,
+        "isDebug" => is_debug,
+        "appVersion" => app_version,
+        "sdkVersion" => sdk_version
+      }
+    end
+
+    private
+
+    # Turns POSIX locale strings like "en_US.UTF-8" into BCP 47-ish "en-US".
+    def detect_locale
+      raw = ENV["LC_ALL"] || ENV["LC_MESSAGES"] || ENV.fetch("LANG", nil)
+      return "en-US" if raw.nil? || raw.empty? || %w[C POSIX].include?(raw)
+
+      raw.split(".").first.tr("_", "-")
+    end
+  end
+end

data/lib/aptabase/transport.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "uri"
+
+module Aptabase
+  # Thin HTTP layer over Net::HTTP. Raises NetworkError for any failure so
+  # the client only has one error type to handle.
+  class Transport
+    EVENTS_PATH = "/api/v0/events"
+
+    def initialize(base_url:, app_key:, timeout: 30.0)
+      @uri = URI.parse(base_url.chomp("/") + EVENTS_PATH)
+      @app_key = app_key
+      @timeout = timeout
+    end
+
+    def post_events(payload)
+      request = Net::HTTP::Post.new(@uri)
+      request["App-Key"] = @app_key
+      request["Content-Type"] = "application/json"
+      request.body = JSON.generate(payload)
+
+      response = Net::HTTP.start(
+        @uri.host, @uri.port,
+        use_ssl: @uri.scheme == "https",
+        open_timeout: @timeout, read_timeout: @timeout, write_timeout: @timeout
+      ) { |http| http.request(request) }
+
+      return if response.is_a?(Net::HTTPSuccess)
+
+      raise NetworkError.new(
+        "HTTP error #{response.code}: #{response.body}",
+        status_code: response.code.to_i
+      )
+    rescue Timeout::Error, SystemCallError, SocketError, IOError, OpenSSL::SSL::SSLError => e
+      raise NetworkError, "Network error: #{e.message}"
+    end
+  end
+end

data/lib/aptabase/version.rb

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

data/lib/aptabase-ruby.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Entry point matching the gem name, so Bundler's default require works
+# with `gem "aptabase-ruby"`.
+require_relative "aptabase"

data/lib/aptabase.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "aptabase/version"
+require_relative "aptabase/errors"
+require_relative "aptabase/system_properties"
+require_relative "aptabase/event"
+require_relative "aptabase/session"
+require_relative "aptabase/transport"
+require_relative "aptabase/client"
+
+# Module-level singleton API, the most common way to use the SDK:
+#
+#   Aptabase.init("A-EU-1234567890", app_version: "1.2.3")
+#   Aptabase.track("app_started")
+#   Aptabase.track("purchase", { "product_id" => "abc123" })
+#
+# For multiple apps or explicit lifecycle control, use Aptabase::Client directly.
+module Aptabase
+  class << self
+    attr_reader :client
+
+    # Logger used when `init` is not given an explicit one. Set to
+    # Rails.logger automatically by the railtie in Rails apps.
+    attr_accessor :default_logger
+
+    # Initialize the global client. Replaces (and stops) any previous one.
+    # Queued events are flushed automatically when the process exits.
+    def init(app_key, **options)
+      @client&.stop
+      options[:logger] = default_logger if default_logger && !options.key?(:logger)
+      @client = Client.new(app_key, **options)
+      register_at_exit
+      @client
+    end
+
+    # Track an event on the global client. Warns (once) and discards the
+    # event if `Aptabase.init` has not been called.
+    def track(event_name, props = nil)
+      client = @client
+      if client.nil?
+        warn_not_initialized
+        return
+      end
+      client.track(event_name, props)
+    end
+
+    # Synchronously send all queued events.
+    def flush
+      @client&.flush
+      nil
+    end
+
+    # Stop the global client, flushing any remaining events.
+    def stop
+      @client&.stop
+      @client = nil
+    end
+
+    private
+
+    def register_at_exit
+      return if @at_exit_registered
+
+      @at_exit_registered = true
+      at_exit { @client&.stop }
+    end
+
+    def warn_not_initialized
+      return if @warned_not_initialized
+
+      @warned_not_initialized = true
+      Kernel.warn("[aptabase] Aptabase.track called before Aptabase.init - event discarded")
+    end
+  end
+end
+
+require_relative "aptabase/railtie" if defined?(Rails::Railtie)

data/lib/generators/aptabase/install_generator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module Aptabase
+  module Generators
+    # Creates config/initializers/aptabase.rb.
+    #
+    #   rails generate aptabase:install
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates an Aptabase initializer in config/initializers"
+
+      def copy_initializer
+        copy_file "aptabase.rb", "config/initializers/aptabase.rb"
+      end
+    end
+  end
+end

data/lib/generators/aptabase/templates/aptabase.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Aptabase - privacy-first analytics (https://aptabase.com)
+#
+# Get your app key from the Aptabase dashboard and store it in
+# credentials (bin/rails credentials:edit):
+#
+#   aptabase:
+#     app_key: A-EU-xxxxxxxxxx
+#
+# or in the APTABASE_APP_KEY environment variable.
+app_key = Rails.application.credentials.dig(:aptabase, :app_key) || ENV.fetch("APTABASE_APP_KEY", nil)
+
+if app_key
+  Aptabase.init(
+    app_key,
+    app_version: ENV.fetch("APP_VERSION", "1.0.0"),
+    is_debug: !Rails.env.production?
+    # base_url: "https://analytics.example.com" # required for self-hosted (A-SH-*) keys
+  )
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: aptabase-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tiny Cloud Ventures
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby and Rails SDK for Aptabase, privacy-first analytics for mobile,
+  desktop and web applications.
+email:
+- matthew@tinycloudventures.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/aptabase-ruby.rb
+- lib/aptabase.rb
+- lib/aptabase/client.rb
+- lib/aptabase/errors.rb
+- lib/aptabase/event.rb
+- lib/aptabase/railtie.rb
+- lib/aptabase/session.rb
+- lib/aptabase/system_properties.rb
+- lib/aptabase/transport.rb
+- lib/aptabase/version.rb
+- lib/generators/aptabase/install_generator.rb
+- lib/generators/aptabase/templates/aptabase.rb
+homepage: https://github.com/tiny-cloud-ventures/aptabase-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/tiny-cloud-ventures/aptabase-ruby
+  source_code_uri: https://github.com/tiny-cloud-ventures/aptabase-ruby
+  changelog_uri: https://github.com/tiny-cloud-ventures/aptabase-ruby/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Ruby SDK for Aptabase - privacy-first analytics
+test_files: []