dials 0.1.0

data/lib/dials/stores/memory.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Dials
+  module Stores
+    # The reference store: plain hashes behind a mutex. It is the default
+    # store so the gem works out of the box (and in client test suites)
+    # without a database, and it doubles as the executable specification of
+    # the store interface:
+    #
+    #   state                                  → { globals:, scoped_overrides:, version:, row_versions: }
+    #   version                                → monotonic value, moves on every write
+    #   override_version(key, canonical)       → the stream's stamp (tombstones
+    #                                            included); 0 only when never written
+    #   set_override(key, canonical, value, actor, expected_version: nil) → [previous value or nil, new stamp]
+    #   clear_override(key, canonical, actor, expected_version: nil)      → [true if an override existed, stamp]
+    #   changes(key: nil, limit: 50)           → newest-first [ChangeRecord]
+    #
+    # `canonical` is always a canonical scope string; Scope::GLOBAL names the
+    # global override (the override at the empty scope).
+    #
+    # `actor` is the normalized hash from Dials::Actor. Value validation and
+    # scope validation happen above the store; a store only persists.
+    #
+    # Concurrency control is per-override optimistic locking: every stream
+    # carries a version stamp (here, the write counter at its last write; in
+    # the ActiveRecord store, the stream seq — both only ever grow).
+    # Tombstones KEEP their stamp, so an absent → set → clear cycle can never
+    # make an old "absent" token current again; StoreVersion::ABSENT strictly
+    # means "never written". `expected_version:` (an opaque StoreVersion
+    # token) compares against THAT stream's stamp atomically with the write;
+    # a mismatch raises StaleWrite with nothing applied or logged. The check
+    # runs before the existence check on clears: a no-op clear against a
+    # stale picture is still stale.
+    #
+    # Values are round-tripped through JSON on write, exactly like the
+    # ActiveRecord store. That buys two guarantees at once: the store never
+    # retains a reference to a caller-owned mutable object (mutating a hash
+    # after a write cannot silently change the stored override or rewrite
+    # change-log history), and both stores return byte-identical shapes
+    # (symbol keys become strings here too, so a test suite on the memory
+    # store proves what production on ActiveRecord will do).
+    class Memory
+      def initialize
+        @globals = {}
+        @scoped = Hash.new { |h, k| h[k] = {} }
+        @row_versions = Hash.new { |h, k| h[k] = {} }
+        @changes = []
+        @version = 0
+        @mutex = Mutex.new
+      end
+
+      def state
+        @mutex.synchronize do
+          {
+            globals: @globals.transform_values { |v| dup_value(v) },
+            scoped_overrides: @scoped.to_h { |k, scopes| [k, scopes.transform_values { |v| dup_value(v) }] },
+            version: @version,
+            row_versions: @row_versions.to_h { |k, scopes| [k, scopes.dup] }
+          }
+        end
+      end
+
+      def version
+        @mutex.synchronize { @version }
+      end
+
+      def override_version(key, canonical_scope)
+        @mutex.synchronize { row_version(key, canonical_scope) }
+      end
+
+      def set_override(key, canonical_scope, value, actor, expected_version: nil)
+        @mutex.synchronize do
+          assert_version!(expected_version, row_version(key, canonical_scope))
+          stored = roundtrip(value)
+          if canonical_scope == Scope::GLOBAL
+            old = @globals[key]
+            @globals[key] = stored
+            record(key, nil, "set", old, stored, actor)
+          else
+            old = @scoped[key][canonical_scope]
+            @scoped[key][canonical_scope] = stored
+            record(key, canonical_scope, "set", old, stored, actor)
+          end
+          [old, stamp(key, canonical_scope)]
+        end
+      end
+
+      def clear_override(key, canonical_scope, actor, expected_version: nil)
+        @mutex.synchronize do
+          current = row_version(key, canonical_scope)
+          assert_version!(expected_version, current)
+          if canonical_scope == Scope::GLOBAL
+            next [false, current] unless @globals.key?(key)
+
+            old = @globals.delete(key)
+            record(key, nil, "clear", old, nil, actor)
+          else
+            next [false, current] unless @scoped.key?(key) && @scoped[key].key?(canonical_scope)
+
+            old = @scoped[key].delete(canonical_scope)
+            @scoped.delete(key) if @scoped[key].empty?
+            record(key, canonical_scope, "clear", old, nil, actor)
+          end
+          # The tombstone keeps a (new) stamp: "absent because cleared" must
+          # never compare equal to "absent because never written".
+          [true, stamp(key, canonical_scope)]
+        end
+      end
+
+      def changes(key: nil, limit: 50)
+        @mutex.synchronize do
+          selected = key ? @changes.select { |c| c.key == key.to_sym } : @changes
+          selected.last(limit).reverse
+        end
+      end
+
+      private
+
+      # Callers hold the mutex.
+      def row_version(key, canonical_scope)
+        @row_versions[key][canonical_scope] || 0
+      end
+
+      # Callers hold the mutex. Raises StaleWrite before anything is touched,
+      # so the transactionless memory store still guarantees "unapplied and
+      # unlogged" on a version mismatch.
+      def assert_version!(expected, current)
+        return if expected.nil? || expected == StoreVersion.token(current)
+
+        raise StaleWrite,
+              "the override has changed since version #{expected} was read — " \
+              "re-read (Dials.overview) and retry deliberately"
+      end
+
+      # Callers hold the mutex; record has already bumped @version, which
+      # serves as the stream stamp (the ActiveRecord analog is the seq).
+      def stamp(key, canonical_scope)
+        @row_versions[key][canonical_scope] = @version
+      end
+
+      # Callers hold the mutex. Old/new values are duplicated (so a change
+      # record never shares structure with the live store state) and frozen
+      # (so a caller mutating what Dials.changes returned cannot rewrite the
+      # retained history — the ActiveRecord store decodes fresh per call and
+      # has no equivalent hazard).
+      def record(key, canonical_scope, action, old_value, new_value, actor)
+        @version += 1
+        @changes << ChangeRecord.new(
+          key: key,
+          scope: canonical_scope && Freeze.deep(Scope.parse(canonical_scope)),
+          action: action,
+          old_value: Freeze.deep(dup_value(old_value)),
+          new_value: Freeze.deep(dup_value(new_value)),
+          actor_type: actor[:actor_type],
+          actor_id: actor[:actor_id],
+          actor_label: actor[:actor_label],
+          created_at: Time.now.utc
+        )
+      end
+
+      def roundtrip(value)
+        JSON.parse(JSON.generate(value))
+      end
+
+      # Containers are deep-duplicated (they are JSON-pure after roundtrip);
+      # scalars are safe to share.
+      def dup_value(value)
+        case value
+        when Hash, Array then roundtrip(value)
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/dials/testing.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Dials
+  # Test helpers. `with_overrides` pins dial values for the duration of a
+  # block without touching the store, the cache, or the change log — reads
+  # inside the block (on the same thread) see the pinned value for every
+  # scope of that dial. Nesting composes; inner blocks win.
+  #
+  #   Dials::Testing.with_overrides(merchant_fee_bps: 250) do
+  #     Dials.merchant_fee_bps(market: "KE") # => 250
+  #   end
+  #
+  # Values are validated against the dial's declaration, so a test cannot
+  # pin a value production could never hold.
+  module Testing
+    THREAD_KEY = :dials_testing_overrides
+
+    module_function
+
+    def with_overrides(overrides)
+      validated = overrides.to_h do |key, value|
+        definition = Dials.registry.fetch(key)
+        [definition.key, definition.validate_value!(value)]
+      end
+
+      previous = Thread.current[THREAD_KEY]
+      Thread.current[THREAD_KEY] = (previous || {}).merge(validated)
+      yield
+    ensure
+      Thread.current[THREAD_KEY] = previous
+    end
+
+    def override_for(key)
+      overrides = Thread.current[THREAD_KEY]
+      return nil unless overrides
+
+      overrides.key?(key) ? [overrides[key]] : nil
+    end
+  end
+end

data/lib/dials/version.rb

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

data/lib/dials.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "dials/version"
+require_relative "dials/errors"
+require_relative "dials/generated"
+require_relative "dials/freeze"
+require_relative "dials/schema"
+require_relative "dials/dimension"
+require_relative "dials/definition"
+require_relative "dials/registry"
+require_relative "dials/scope"
+require_relative "dials/snapshot"
+require_relative "dials/store_version"
+require_relative "dials/overview"
+require_relative "dials/resolver"
+require_relative "dials/cache"
+require_relative "dials/change_record"
+require_relative "dials/actor"
+require_relative "dials/stores/memory"
+require_relative "dials/config"
+require_relative "dials/testing"
+
+# Dials: operator-adjustable values with per-scope overrides.
+#
+# A dial is a value that starts life as a code default, can be overridden
+# globally at runtime, and can be overridden again per scope along its
+# declared dimensions (per market, per platform, ...). Resolution is always:
+#
+#   scoped override → global override → code default
+#
+# Declarations live in code (Dials.define); values live in a store; reads
+# come from a per-process cache. Every write is attributed and logged.
+#
+# Declaring a dial generates its methods (see Generated):
+#
+#   Dials.base_fee(market: "KE")                        # read
+#   Dials.adjust_base_fee(25, actor: ops, market: "KE") # write
+#   Dials.clear_base_fee(actor: ops, market: "KE")      # remove an override
+#
+# The key-taking primitives (get, set, clear) stay public underneath — they
+# are the dynamic-access layer for code that receives the key at runtime
+# (an admin surface iterating the registry, a console one-liner).
+module Dials
+  # Thread-local marker: this thread performed a dial write inside a
+  # database transaction that is still open. While set, the thread's reads
+  # come from fresh, UNPUBLISHED snapshots — it sees its own uncommitted
+  # write, but the uncommitted value never lands in the shared cache (where
+  # other threads would read it, and where it would survive a rollback).
+  TXN_WRITE_KEY = :dials_wrote_in_open_transaction
+
+  CACHE_LOCK = Mutex.new
+
+  # The stale-write token of an override that is not stored. Pass it as
+  # `expected_version:` to assert "there was no override here when I looked"
+  # — the write succeeds only if that is still true.
+  ABSENT_VERSION = StoreVersion::ABSENT
+
+  class << self
+    # -- declaration ---------------------------------------------------------
+
+    attr_reader :registry, :config
+
+    # Declare dials:
+    #
+    #   Dials.define do
+    #     dial :merchant_fee_bps, default: 100, type: :integer,
+    #          minimum: 1, maximum: 10_000, unit: "bps",
+    #          dimensions: { market: { enum: %w[KE NG BD] } }
+    #     dial :signups_enabled, default: true, type: :boolean
+    #   end
+    #
+    # Each declaration generates the dial's methods: merchant_fee_bps (the
+    # reader), adjust_merchant_fee_bps, clear_merchant_fee_bps (see
+    # Generated).
+    def define(&)
+      registry.instance_eval(&)
+    end
+
+    # -- configuration -------------------------------------------------------
+
+    def configure
+      yield config
+    end
+
+    def store
+      config.store
+    end
+
+    def cache
+      @cache || CACHE_LOCK.synchronize { @cache ||= Cache.new(store: store, ttl: config.cache_ttl) }
+    end
+
+    # Discard the cache object entirely (used when the store is swapped).
+    def reset_cache!
+      CACHE_LOCK.synchronize { @cache = nil }
+    end
+
+    # Force the next read to rebuild from the store — e.g. after writing
+    # through a console in another process, or in a test. Also clears this
+    # thread's in-transaction-write marker (test suites that wrap examples
+    # in transactions call this between examples).
+    def reload!
+      Thread.current[TXN_WRITE_KEY] = nil
+      cache.bust!
+    end
+
+    # -- reads ---------------------------------------------------------------
+
+    # Resolve a dial by key — the primitive under the generated readers,
+    # for callers that receive the key at runtime. Scope is passed
+    # as keyword arguments and must name every dimension the dial declares —
+    # no more, no less:
+    #
+    #   Dials.get(:signups_enabled)                     # global-only dial
+    #   Dials.get(:merchant_fee_bps, market: "KE")      # varied dial
+    #
+    # Raises UnknownDial / InvalidScope on misuse; never raises for a merely
+    # missing override (that is what defaults are for).
+    def get(key, **scope)
+      definition = registry.fetch(key)
+      normalized = Scope.validate!(definition, scope, exact: true)
+
+      # After scope validation, so a test override can never mask a read that
+      # would raise in production.
+      pinned = Testing.override_for(definition.key)
+      return pinned.first if pinned
+
+      Resolver.resolve(definition, normalized, current_snapshot)
+    end
+
+    # One dial's stored scoped overrides as { parsed scope => value }, e.g.
+    # { { market: "BD" } => 24, { market: "NG" } => 48 } — "which markets
+    # override this dial?". Scopes come back as parsed hashes, never
+    # canonical scope strings. A dial with nothing scoped stored (or no
+    # dimensions at all) returns {}; the global override is not included
+    # (see overview). Reads from the same snapshot path as the generated
+    # readers, including the in-transaction rule. The result is deep-frozen —
+    # it shares structure with the process-wide snapshot.
+    def scoped_overrides(key)
+      definition = registry.fetch(key)
+      parsed_scoped_overrides(current_snapshot, definition.key)
+    end
+
+    # Every registered dial's full state — definition (with its JSON Schema),
+    # global override (explicitly present-or-absent), scoped overrides, and
+    # the per-override stale-write tokens — read from ONE snapshot, so the
+    # picture is coherent. Feed an override's token back as
+    # `expected_version:` when writing it (Dials::ABSENT_VERSION for
+    # overrides the page showed as not stored).
+    def overview
+      snapshot = current_snapshot
+      dials = registry.map do |definition|
+        stamps = snapshot.row_versions[definition.key] || {}
+        DialState.new(
+          definition: definition,
+          global_override: snapshot.globals.key?(definition.key),
+          global_value: snapshot.globals[definition.key],
+          global_version: StoreVersion.token(stamps[Scope::GLOBAL] || 0),
+          scoped_overrides: parsed_scoped_overrides(snapshot, definition.key),
+          scoped_override_versions: parsed_versions(snapshot, definition.key)
+        )
+      end.freeze
+      Overview.new(version: StoreVersion.token(snapshot.version), dials: dials)
+    end
+
+    # The full change log, newest first. `key:` filters to one dial.
+    def changes(key: nil, limit: 50)
+      key = registry.fetch(key).key if key
+      store.changes(key: key, limit: limit)
+    end
+
+    # -- writes --------------------------------------------------------------
+
+    # Store an override by key — the primitive under the generated
+    # adjust_<key> methods. With no scope, overrides the global; with a
+    # scope, creates or updates the override for exactly that scope. The
+    # value is validated against the dial's type and schema; `actor:` is
+    # required and lands in the change log.
+    #
+    # `expected_version:` makes the write compare-and-swap against THIS
+    # override (the global when no scope keywords, the named scoped override
+    # otherwise): pass the override's token from Dials.overview (or a
+    # previous CAS write; Dials::ABSENT_VERSION when the page showed no
+    # override) and the write is refused with StaleWrite — unapplied,
+    # unlogged — if that override has changed since. A CAS write returns the
+    # override's NEW token (chain it into the next write); an unconditional
+    # write returns the value, as always.
+    def set(key, value, actor:, scope: nil, expected_version: nil)
+      definition = registry.fetch(key)
+      actor_attrs = Actor.normalize(actor)
+      definition.validate_value!(value)
+
+      if scope.nil? || scope.empty?
+        canonical = Scope::GLOBAL
+      else
+        raise InvalidScope, "dial #{definition.key} declares no dimensions" unless definition.dimensions?
+
+        normalized = Scope.validate!(definition, scope, exact: true)
+        canonical = Scope.canonical(normalized)
+      end
+      _old, written = store.set_override(definition.key, canonical, value, actor_attrs,
+                                         expected_version: expected_version)
+
+      after_write
+      # The token comes from the write we KNOW happened — never from a
+      # second read a concurrent writer could slip in front of.
+      expected_version ? StoreVersion.token(written) : value
+    end
+
+    # Remove an override by key — the primitive under the generated
+    # clear_<key> methods — returning resolution to the next layer down: a
+    # cleared scoped override inherits the global; a cleared global inherits the
+    # code default. Returns true if an override existed. Clearing what is not
+    # there is a no-op (and logs nothing).
+    #
+    # `expected_version:` works exactly as on set — the staleness check runs
+    # even when the clear would be a no-op (a page that shows an override
+    # which no longer exists IS stale), and a CAS clear returns the
+    # tombstone's token instead of the boolean (chainable: a later set
+    # carrying it succeeds; an "absent" assertion from an older page does
+    # not — cleared is not the same as never-written).
+    def clear(key, actor:, scope: nil, expected_version: nil)
+      definition = registry.fetch(key)
+      actor_attrs = Actor.normalize(actor)
+
+      if scope.nil? || scope.empty?
+        canonical = Scope::GLOBAL
+      else
+        normalized = Scope.validate!(definition, scope, exact: true)
+        canonical = Scope.canonical(normalized)
+      end
+      removed, written = store.clear_override(definition.key, canonical, actor_attrs,
+                                              expected_version: expected_version)
+
+      after_write
+      expected_version ? StoreVersion.token(written) : removed
+    end
+
+    private
+
+    # { canonical scope string => value } from the snapshot, re-keyed by
+    # parsed scope hash. Values are already frozen snapshot references; the
+    # freshly built hashes are frozen so no caller can mutate shared state.
+    def parsed_scoped_overrides(snapshot, key)
+      stored = snapshot.scoped_overrides[key] || {}
+      stored.to_h { |canonical, value| [Freeze.deep(Scope.parse(canonical)), value] }.freeze
+    end
+
+    # { parsed scope hash => version token } for a dial's scoped overrides.
+    def parsed_versions(snapshot, key)
+      stamps = snapshot.row_versions[key] || {}
+      stamps.except(Scope::GLOBAL)
+            .to_h { |canonical, stamp| [Freeze.deep(Scope.parse(canonical)), StoreVersion.token(stamp)] }.freeze
+    end
+
+    def after_write
+      cache.bust!
+      return unless store_transaction_open?
+
+      # The write is inside an application transaction and not committed
+      # yet. Two things follow. This thread's reads must bypass the shared
+      # cache until the transaction closes (see current_snapshot). And the
+      # bust above happened PRE-commit — another thread can legitimately
+      # republish the pre-transaction state before the commit lands — so the
+      # cache must be busted again ON commit, or a writer that never reads
+      # again would leave every process serving the old value until the TTL
+      # probe notices (forever, with ttl = nil). On rollback the hook is
+      # discarded: the shared cache never held the transaction's data.
+      Thread.current[TXN_WRITE_KEY] = true
+      store.after_commit { cache.bust! } if store.respond_to?(:after_commit)
+    end
+
+    def current_snapshot
+      if Thread.current[TXN_WRITE_KEY]
+        return cache.uncached_snapshot if store_transaction_open?
+
+        # The transaction closed (committed or rolled back). Rejoin the
+        # shared cache, busting first so the next snapshot reflects the
+        # outcome rather than anything published mid-transaction.
+        Thread.current[TXN_WRITE_KEY] = nil
+        cache.bust!
+      end
+
+      cache.snapshot
+    end
+
+    def store_transaction_open?
+      s = store
+      s.respond_to?(:transaction_open?) && s.transaction_open?
+    end
+  end
+
+  @registry = Registry.new
+  @config = Config.new
+end
+
+begin
+  require "rails/railtie"
+  require_relative "dials/railtie"
+rescue LoadError
+  nil
+rescue StandardError => e
+  # A broken or incompatible Rails installation must not stop the core gem
+  # from loading — Rails integration is opportunistic, never required.
+  warn "[dials] skipping Rails integration (#{e.class}: #{e.message})"
+end

data/lib/generators/dials/install/install_generator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Dials
+  module Generators
+    # `bin/rails generate dials:install`
+    #
+    # Creates the migration for the three gem-owned tables and an initializer
+    # with a commented starter registry.
+    class InstallGenerator < Rails::Generators::Base
+      include ::ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      def create_migration_file
+        migration_template "migration.rb.tt", "db/migrate/create_dials_tables.rb"
+      end
+
+      def create_initializer
+        template "initializer.rb.tt", "config/initializers/dials.rb"
+      end
+
+      def show_readme
+        say <<~TEXT
+
+          Dials installed. Next steps:
+
+            1. bin/rails db:migrate
+            2. Declare your dials in config/initializers/dials.rb
+            3. Declaring dial :base_fee generates Dials.base_fee,
+               Dials.adjust_base_fee, and Dials.clear_base_fee
+
+        TEXT
+      end
+    end
+  end
+end

data/lib/generators/dials/install/templates/initializer.rb.tt

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "dials/active_record"
+
+Dials.configure do |config|
+  # Where values live. :active_record uses the tables created by
+  # `rails g dials:install`; :memory keeps everything in-process (handy in
+  # test environments that never exercise persistence).
+  config.store = :active_record
+
+  # Seconds between cache staleness probes (one cheap query per process per
+  # interval). 0 probes on every read; nil never probes.
+  # config.cache_ttl = 5.0
+
+  # How an actor is rendered in the change log.
+  # config.actor_label = ->(actor) { actor.email }
+
+  # No User model? Attribution does not need one — actor: takes any object,
+  # and strings are first-class (actor: "console"). To make actor: optional,
+  # declare an app-level fallback (a value, or a callable evaluated per
+  # write). Leave unset to require actor: on every write.
+  # config.default_actor = -> { ENV.fetch("USER", "console") }
+end
+
+# Declare your dials. A dial with no `dimensions:` is global-only by
+# construction. Declaring `dimensions:` is the arming gate — add it in the same
+# change as the code that reads the varied value.
+#
+# Value constraints are JSON Schema keywords, snake_cased (minimum:,
+# maximum:, enum:, pattern:, min_length:, properties:/required: for :json) —
+# the vocabulary you already know from JSON Schema and OpenAPI. `validate:`
+# takes a callable for rules a schema cannot express.
+#
+# Each declaration generates the dial's methods, e.g. for :merchant_fee_bps:
+#   Dials.merchant_fee_bps(market: "KE")
+#   Dials.adjust_merchant_fee_bps(90, actor: current_admin, market: "KE")
+#   Dials.clear_merchant_fee_bps(actor: current_admin, market: "KE")
+Dials.define do
+  # dial :merchant_fee_bps, default: 100,
+  #      type: :integer,
+  #      minimum: 1,
+  #      maximum: 10_000,
+  #      unit: "bps",
+  #      description: "Fee charged to merchants, in basis points.",
+  #      dimensions: { market: { enum: %w[KE NG BD] } }
+
+  # dial :signups_enabled, default: true, type: :boolean,
+  #      description: "Global kill switch for new signups."
+end

data/lib/generators/dials/install/templates/migration.rb.tt

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class CreateDialsTables < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    # The gem's ONE table, append-only: every write INSERTs a row, and the
+    # newest row per (key, scope) stream is the current override — action
+    # "set" carries a value, action "clear" ends the override. The change
+    # log IS the state (history cannot disagree with it), the row count is
+    # the cache's version counter, and UNIQUE(key, scope, seq) makes writes
+    # atomic: every writer claims the stream's next seq, and of two
+    # concurrent claims the database rejects one — no lock table, no
+    # advisory locks, no race.
+    #
+    # A global override is the stream at the canonical empty scope "{}".
+    # `value` is JSON-encoded text, never queried in SQL — reads go through
+    # the in-process cache. No updated_at: rows are immutable facts.
+    #
+    # Explicit column limits keep the composite unique index inside every
+    # supported database's index budget (MySQL utf8mb4 in particular).
+    # On MySQL, the default case-insensitive collation would merge streams
+    # whose scopes differ only by case ("KE" vs "ke") — identity columns get
+    # a binary collation there. PostgreSQL and SQLite compare bytes already.
+    identity_collation = ("utf8mb4_bin" if connection.adapter_name.match?(/mysql/i))
+
+    create_table :dials do |t|
+      t.string :key, null: false, limit: 100, collation: identity_collation
+      t.string :scope, null: false, limit: 255, collation: identity_collation
+      t.bigint :seq, null: false
+      t.string :action, null: false
+      t.text :value
+      t.string :actor_type
+      t.string :actor_id
+      t.string :actor_label
+      t.datetime :created_at, null: false
+    end
+    add_index :dials, [:key, :scope, :seq], unique: true
+    add_index :dials, :key
+  end
+end