mammoth 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fe6f64a39d214c62e11a29fccb091f58cd2a1b8038a0bb803c39c4e018b09b3
-  data.tar.gz: f557c7288df617029808c327b656a8b7cb1f7689eb7f4b6d99032b01bcc0535e
+  metadata.gz: d7437cc30ed1a50ca4b414c37bc75ba374569ef3cdfafc7b88f0631d5f462790
+  data.tar.gz: d75b6cf2476c892915aa24ceb5169f69889a794cb923e5d1748a7c5a726129e3
 SHA512:
-  metadata.gz: fe49156b57ff2355fd0e78368cd613fa3fa5dcf5d0a5ebf423ec799558b61a70da7529a123f5b254b904a93e7c7355a049b115308eb051e211894b84443f3444
-  data.tar.gz: 7b24591aa6f3996e51b5762022f680f212cbb1e8412e0e90ff42e34c3485d9f18fb2f4f4c9b9ca4420a697767400a2d37b6ebc600d203e7c4f5f0fbe5e904da2
+  metadata.gz: b38367dbafad260559c1f80558d2aeb6f452688fc1404b5652dbd8310625fbe0058eb2ac45ab0dea9dc226b19e0447efca79ff8a70556f3b10f24ba1ebd2e8c9
+  data.tar.gz: f7950310f899a5291889853f95b096937b51332899c8adabe7209e6bef3b5c186863cc37bc0cb331e06a51c3ff5abc15b5049995a0822f07ff51c3076b5b79b5

data/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Changelog
 
-## 0.7.0 Unreleased
+## 0.7.1 Unreleased
+
+### Added
+
+- Added local lifecycle hooks for start, shutdown, and dead-letter replay extension points.
+- Added file and hash configuration providers for CLI, tests, and future control-plane integration.
+- Added reusable command objects for validate, bootstrap, start, sample delivery, and dead-letter commands.
+
+### Changed
+
+- Bumped Mammoth version to `0.7.1`.
+
+## 0.7.0
 
 ### Added
 

data/README.md

@@ -59,6 +59,7 @@ https://kanutocd.github.io/mammoth/Mammoth.html
 - health and metrics endpoints
 - explicit extension registries for state, destination, and runtime adapters
 - node identity and local capability reporting
+- lifecycle hooks, configuration providers, and reusable local command objects
 
 ## Boundary
 
@@ -75,6 +76,9 @@ Mammoth OSS exposes small adapter registries for future extensions:
 - operational state adapters
 - destination adapters
 - runtime adapters
+- lifecycle hooks
+- configuration providers
+- local command objects
 
 See [`docs/EXTENSIONS.md`](docs/EXTENSIONS.md).
 

data/config/mammoth.example.yml

@@ -345,7 +345,7 @@ sqlite:
   path: data/mammoth.db
 
 operational_state:
-  # Mammoth OSS 0.7.0 ships the sqlite operational state adapter.
+  # Mammoth OSS 0.7.x ships the sqlite operational state adapter.
   adapter: sqlite
 
 observability:

data/config/mammoth.schema.json

@@ -264,7 +264,7 @@
             "enum": [
               "webhook"
             ],
-            "description": "Destination adapter type. Mammoth OSS 0.7.0 supports webhook destinations."
+            "description": "Destination adapter type. Mammoth OSS 0.7.x supports webhook destinations."
           },
           "enabled": {
             "type": "boolean",
@@ -435,7 +435,7 @@
           "enum": [
             "sqlite"
           ],
-          "description": "Operational state adapter. Mammoth OSS 0.7.0 ships the sqlite adapter."
+          "description": "Operational state adapter. Mammoth OSS 0.7.x ships the sqlite adapter."
         }
       },
       "description": "Operational state adapter selection. SQLite remains the default OSS adapter."

data/lib/mammoth/application.rb

@@ -10,14 +10,16 @@ module Mammoth
   # injected CDC work source rather than owning upstream CDC source-adapter
   # lifecycle decisions.
   class Application
-    attr_reader :config, :state_adapter, :consumer, :delivery_worker, :checkpoint_store
+    attr_reader :config, :state_adapter, :consumer, :delivery_worker, :checkpoint_store, :lifecycle_hooks
 
     # @param config [Mammoth::Configuration] loaded configuration
     # @param source [#each, nil] injectable event source for tests and demos
     # @param sink [#deliver, nil] optional destination sink
     # @param sleeper [#call] retry sleep strategy
-    def initialize(config, source: nil, sink: nil, sleeper: Kernel.method(:sleep))
+    # @param lifecycle_hooks [Mammoth::LifecycleHooks, Hash] local lifecycle callbacks
+    def initialize(config, source: nil, sink: nil, sleeper: Kernel.method(:sleep), lifecycle_hooks: LifecycleHooks.new)
       @config = config
+      @lifecycle_hooks = build_lifecycle_hooks(lifecycle_hooks)
       @state_adapter = build_state_adapter
       @checkpoint_store = state_adapter.checkpoint_store
       @consumer = ReplicationConsumer.new(source: source || build_source, delivery_unit: delivery_unit)
@@ -34,6 +36,36 @@ module Mammoth
     # @return [Integer] number of processed work units
     def start
       runtime = build_runtime
+      processed = nil
+
+      lifecycle_hooks.call(:before_start, application_context(runtime: runtime))
+      processed = process_consumer(runtime)
+      lifecycle_hooks.call(:after_start, application_context(runtime: runtime, processed: processed))
+      processed
+    ensure
+      lifecycle_hooks.call(:before_shutdown, application_context(runtime: runtime, processed: processed))
+      runtime.shutdown if runtime.respond_to?(:shutdown)
+      lifecycle_hooks.call(:after_shutdown, application_context(runtime: runtime, processed: processed))
+    end
+
+    private
+
+    def build_lifecycle_hooks(hooks)
+      return hooks if hooks.is_a?(LifecycleHooks)
+
+      LifecycleHooks.new(hooks)
+    end
+
+    def application_context(extra = {})
+      {
+        config: config,
+        state_adapter: state_adapter,
+        checkpoint_store: checkpoint_store,
+        delivery_worker: delivery_worker
+      }.merge(extra)
+    end
+
+    def process_consumer(runtime)
       processed = 0
       batch = [nil].compact
 
@@ -50,13 +82,14 @@ module Mammoth
         end
       end
 
-      processed += process_batch(runtime, batch) if runtime_batching?(runtime) && batch.any?
-      processed
-    ensure
-      runtime.shutdown if runtime.respond_to?(:shutdown)
+      processed + flush_batch(runtime, batch)
     end
 
-    private
+    def flush_batch(runtime, batch)
+      return 0 unless runtime_batching?(runtime) && batch.any?
+
+      process_batch(runtime, batch)
+    end
 
     def process_work(runtime, work)
       runtime.process_many([work])

data/lib/mammoth/cdc_source.rb

@@ -3,7 +3,7 @@
 module Mammoth
   # Backwards-compatible internal alias for the PostgreSQL CDC source.
   #
-  # New code should use {Mammoth::Sources::Postgres}. Mammoth v0.1.0 keeps this
+  # New code should use {Mammoth::Sources::Postgres}. Mammoth keeps this
   # constant so older tests or examples that referenced the transitional
   # CdcSource name continue to work while the product-facing source name moves
   # to PostgreSQL.

data/lib/mammoth/cli.rb

@@ -85,18 +85,12 @@ module Mammoth
     end
 
     def validate
-      load_config
-      puts "Configuration OK: #{config_path}"
-      0
+      require_config_path!
+      Commands::ValidateCommand.new(config_provider).call
     end
 
     def bootstrap
-      config = load_config
-      store = SQLiteStore.connect(config.dig("sqlite", "path")).bootstrap!
-      puts "SQLite database initialized"
-      puts "Path: #{store.path}"
-      puts "Tables: #{store.tables.join(", ")}"
-      0
+      Commands::BootstrapCommand.new(load_config).call
     end
 
     def status
@@ -106,31 +100,22 @@ module Mammoth
     end
 
     def start
-      config = load_config
-      processed = Application.new(config).start
-      puts "Processed events: #{processed}"
-      0
+      Commands::StartCommand.new(load_config).call
     end
 
     def deliver_sample
       config = load_config
       event_path = argv.fetch(2, nil)
       raise ConfigurationError, "event JSON path required\n#{USAGE}" unless event_path
-      raise ConfigurationError, "event JSON file not found: #{event_path}" unless File.file?(event_path)
 
-      event = JSON.parse(File.read(event_path))
-      processed = Application.new(config, source: [event]).start
-      puts "Processed sample events: #{processed}"
-      0
-    rescue JSON::ParserError => e
-      raise ConfigurationError, "invalid event JSON in #{event_path}: #{e.message}"
+      Commands::DeliverSampleCommand.new(config, event_path: event_path).call
     end
 
     # Dispatch the nested dead-letter command group.
     #
     # @return [Integer] process status code
     def dead_letters
-      DeadLetterCommands.call(argv)
+      Commands::DeadLettersCommand.new(argv).call
     end
 
     def observability
@@ -142,9 +127,17 @@ module Mammoth
     end
 
     def load_config
+      require_config_path!
+
+      config_provider.load
+    end
+
+    def require_config_path!
       raise ConfigurationError, "configuration path required\n#{USAGE}" unless config_path
+    end
 
-      Configuration.load(config_path)
+    def config_provider
+      Configuration::Providers::FileProvider.new(config_path)
     end
   end
 end

data/lib/mammoth/commands/bootstrap_command.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module Commands
+    # Initializes the configured operational SQLite database.
+    class BootstrapCommand
+      attr_reader :config, :output
+
+      # @param config [Mammoth::Configuration] loaded configuration
+      # @param output [#puts] output stream
+      def initialize(config, output: $stdout)
+        @config = config
+        @output = output
+      end
+
+      # @return [Integer] process-style status code
+      def call
+        store = SQLiteStore.connect(config.dig("sqlite", "path")).bootstrap!
+        output.puts "SQLite database initialized"
+        output.puts "Path: #{store.path}"
+        output.puts "Tables: #{store.tables.join(", ")}"
+        0
+      end
+    end
+  end
+end

data/lib/mammoth/commands/dead_letters_command.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module Commands
+    # Reusable local command object for dead-letter inspection and replay.
+    class DeadLettersCommand
+      attr_reader :argv, :lifecycle_hooks
+
+      # @param argv [Array<String>] dead-letters CLI-style arguments
+      # @param lifecycle_hooks [Mammoth::LifecycleHooks, Hash] local lifecycle callbacks
+      def initialize(argv, lifecycle_hooks: LifecycleHooks.new)
+        @argv = argv
+        @lifecycle_hooks = lifecycle_hooks
+      end
+
+      # @return [Integer] process-style status code
+      def call
+        DeadLetterCommands.call(argv, lifecycle_hooks: lifecycle_hooks)
+      end
+    end
+  end
+end

data/lib/mammoth/commands/deliver_sample_command.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Mammoth
+  module Commands
+    # Delivers one JSON event file through the configured local application.
+    class DeliverSampleCommand
+      attr_reader :config, :event_path, :output, :lifecycle_hooks
+
+      # @param config [Mammoth::Configuration] loaded configuration
+      # @param event_path [String] event JSON path
+      # @param output [#puts] output stream
+      # @param lifecycle_hooks [Mammoth::LifecycleHooks, Hash] local lifecycle callbacks
+      def initialize(config, event_path:, output: $stdout, lifecycle_hooks: LifecycleHooks.new)
+        @config = config
+        @event_path = event_path
+        @output = output
+        @lifecycle_hooks = lifecycle_hooks
+      end
+
+      # @return [Integer] process-style status code
+      def call
+        raise ConfigurationError, "event JSON file not found: #{event_path}" unless File.file?(event_path)
+
+        event = JSON.parse(File.read(event_path))
+        processed = Application.new(config, source: [event], lifecycle_hooks: lifecycle_hooks).start
+        output.puts "Processed sample events: #{processed}"
+        0
+      rescue JSON::ParserError => e
+        raise ConfigurationError, "invalid event JSON in #{event_path}: #{e.message}"
+      end
+    end
+  end
+end

data/lib/mammoth/commands/start_command.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module Commands
+    # Starts a Mammoth application and prints the processed work count.
+    class StartCommand
+      attr_reader :config, :source, :output, :lifecycle_hooks
+
+      # @param config [Mammoth::Configuration] loaded configuration
+      # @param source [#each, nil] optional injected source
+      # @param output [#puts] output stream
+      # @param lifecycle_hooks [Mammoth::LifecycleHooks, Hash] local lifecycle callbacks
+      def initialize(config, source: nil, output: $stdout, lifecycle_hooks: LifecycleHooks.new)
+        @config = config
+        @source = source
+        @output = output
+        @lifecycle_hooks = lifecycle_hooks
+      end
+
+      # @return [Integer] process-style status code
+      def call
+        processed = Application.new(config, source: source, lifecycle_hooks: lifecycle_hooks).start
+        output.puts "Processed events: #{processed}"
+        0
+      end
+    end
+  end
+end

data/lib/mammoth/commands/validate_command.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module Commands
+    # Validates a Mammoth configuration through a provider.
+    class ValidateCommand
+      attr_reader :provider, :output
+
+      # @param provider [#load] configuration provider
+      # @param output [#puts] output stream
+      def initialize(provider, output: $stdout)
+        @provider = provider
+        @output = output
+      end
+
+      # @return [Integer] process-style status code
+      def call
+        config = provider.load
+        output.puts "Configuration OK: #{config.path}"
+        0
+      end
+    end
+  end
+end

data/lib/mammoth/configuration.rb

@@ -5,7 +5,7 @@ require "json-schema"
 require "yaml"
 
 module Mammoth
-  # Loads and validates Mammoth YAML configuration.
+  # Loads and validates Mammoth configuration.
   #
   # Configuration is intentionally schema-backed so the same contract can power
   # editor IntelliSense, preflight validation, and runtime startup checks.
@@ -22,15 +22,27 @@ module Mammoth
     # @return [Mammoth::Configuration] loaded configuration
     # @raise [Mammoth::ConfigurationError] when the file is missing or invalid
     def self.load(path, schema_path: DEFAULT_SCHEMA_PATH)
-      new(path, schema_path: schema_path).load
+      Providers::FileProvider.new(path).load(schema_path: schema_path)
+    end
+
+    # Build and validate a configuration from an in-memory Hash.
+    #
+    # @param data [Hash] configuration data
+    # @param path [String, nil] optional display path/source
+    # @param schema_path [String] JSON Schema path
+    # @return [Mammoth::Configuration] loaded configuration
+    # @raise [Mammoth::ConfigurationError] when the data is invalid
+    def self.from_hash(data, path: nil, schema_path: DEFAULT_SCHEMA_PATH)
+      Providers::HashProvider.new(data, path: path).load(schema_path: schema_path)
     end
 
     # @param path [String] YAML configuration path
     # @param schema_path [String] JSON Schema path
-    def initialize(path, schema_path: DEFAULT_SCHEMA_PATH)
+    # @param data [Hash, nil] already parsed configuration data
+    def initialize(path, schema_path: DEFAULT_SCHEMA_PATH, data: nil)
       @path = path
       @schema_path = schema_path
-      @data = nil
+      @data = data
     end
 
     # Load and validate the configuration file.
@@ -38,9 +50,7 @@ module Mammoth
     # @return [Mammoth::Configuration] self
     # @raise [Mammoth::ConfigurationError] when validation fails
     def load
-      raise ConfigurationError, "configuration file not found: #{path}" unless File.file?(path)
-
-      @data = YAML.safe_load_file(path, permitted_classes: [], aliases: false)
+      @data ||= load_yaml_file
       raise ConfigurationError, "configuration must be a YAML mapping" unless data.is_a?(Hash)
 
       validate_schema!
@@ -60,6 +70,12 @@ module Mammoth
 
     private
 
+    def load_yaml_file
+      raise ConfigurationError, "configuration file not found: #{path}" unless path && File.file?(path)
+
+      YAML.safe_load_file(path, permitted_classes: [], aliases: false)
+    end
+
     def validate_schema!
       raise ConfigurationError, "schema file not found: #{schema_path}" unless File.file?(schema_path)
 
@@ -85,5 +101,48 @@ module Mammoth
 
       raise ConfigurationError, "destination names must be unique: #{duplicates.join(", ")}"
     end
+
+    # Configuration provider contracts shared by CLI and future control agents.
+    module Providers
+      # Loads configuration from a YAML file.
+      class FileProvider
+        attr_reader :path
+
+        # @param path [String] YAML configuration path
+        def initialize(path)
+          @path = path
+        end
+
+        # @param schema_path [String] JSON Schema path
+        # @return [Mammoth::Configuration]
+        def load(schema_path: Configuration::DEFAULT_SCHEMA_PATH)
+          Configuration.new(path, schema_path: schema_path).load
+        end
+      end
+
+      # Loads configuration from an already parsed Hash.
+      class HashProvider
+        attr_reader :data, :path
+
+        # @param data [Hash] configuration data
+        # @param path [String, nil] optional source name for diagnostics/status
+        def initialize(data, path: nil)
+          @data = data
+          @path = path || "<hash>"
+        end
+
+        # @param schema_path [String] JSON Schema path
+        # @return [Mammoth::Configuration]
+        def load(schema_path: Configuration::DEFAULT_SCHEMA_PATH)
+          Configuration.new(path, schema_path: schema_path, data: deep_copy(data)).load
+        end
+
+        private
+
+        def deep_copy(value)
+          Marshal.load(Marshal.dump(value))
+        end
+      end
+    end
   end
 end

data/lib/mammoth/dead_letter_commands.rb

@@ -17,16 +17,18 @@ module Mammoth
       :metadata
     )
 
-    attr_reader :argv
+    attr_reader :argv, :lifecycle_hooks
 
     # @param argv [Array<String>] command line arguments
-    def self.call(argv)
-      new(argv).call
+    def self.call(argv, lifecycle_hooks: LifecycleHooks.new)
+      new(argv, lifecycle_hooks: lifecycle_hooks).call
     end
 
     # @param argv [Array<String>] command line arguments
-    def initialize(argv)
+    # @param lifecycle_hooks [Mammoth::LifecycleHooks, Hash] local lifecycle callbacks
+    def initialize(argv, lifecycle_hooks: LifecycleHooks.new)
       @argv = argv
+      @lifecycle_hooks = lifecycle_hooks.is_a?(LifecycleHooks) ? lifecycle_hooks : LifecycleHooks.new(lifecycle_hooks)
     end
 
     # Dispatch the nested dead-letter subcommand.
@@ -79,11 +81,13 @@ module Mammoth
       rows = replay_rows
       raise ConfigurationError, "no dead letters found to replay" if rows.empty?
 
+      lifecycle_hooks.call(:before_replay, replay_context(rows: rows))
       rows.each do |row|
         result = replay_row(row)
         dead_letter_store.resolve(row.fetch("id")) if replay_resolved?(result)
         puts replay_message(row, result)
       end
+      lifecycle_hooks.call(:after_replay, replay_context(rows: rows))
       0
     end
 
@@ -307,6 +311,14 @@ module Mammoth
     def replay_message(row, result)
       "Dead letter #{row.fetch("id")}: #{result.fetch(:status)}"
     end
+
+    def replay_context(extra = {})
+      {
+        config: load_config,
+        dead_letter_store: dead_letter_store,
+        delivery_worker: worker
+      }.merge(extra)
+    end
   end
   # rubocop:enable Metrics/ClassLength
 end

data/lib/mammoth/lifecycle_hooks.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # Executes optional lifecycle callbacks around local Mammoth operations.
+  #
+  # Hooks are intentionally in-process and explicit. They give extensions and
+  # future control agents stable observation points without changing the data
+  # plane or introducing remote behavior into OSS.
+  class LifecycleHooks
+    EVENTS = %i[
+      before_start
+      after_start
+      before_shutdown
+      after_shutdown
+      before_replay
+      after_replay
+    ].freeze
+    EMPTY_CALLBACKS = [nil].compact.freeze
+
+    attr_reader :callbacks
+
+    # @param callbacks [Hash] lifecycle callbacks keyed by event name
+    def initialize(callbacks = {})
+      @callbacks = normalize(callbacks || {})
+    end
+
+    # @param event [Symbol, String] lifecycle event
+    # @param context [Hash] event context
+    # @return [void]
+    def call(event, context = {})
+      event = event.to_sym
+      raise ConfigurationError, "unknown lifecycle hook: #{event}" unless EVENTS.include?(event)
+
+      callback_list = callbacks.fetch(event, EMPTY_CALLBACKS)
+      # @type var callback_list: untyped
+      Array(callback_list).each do |callback|
+        # @type var callback: untyped
+        callback.call(context.merge(event: event))
+      end
+      nil
+    end
+
+    private
+
+    def normalize(callbacks)
+      normalized = {}
+      # @type var normalized: Hash[Symbol, untyped]
+      callbacks.each_with_object(normalized) do |(event, callback), memo|
+        key = event.to_sym
+        raise ConfigurationError, "unknown lifecycle hook: #{key}" unless EVENTS.include?(key)
+
+        memo[key] = Array(callback)
+      end
+    end
+  end
+end

data/lib/mammoth/version.rb

@@ -2,5 +2,5 @@
 
 module Mammoth
   # Current Mammoth gem version.
-  VERSION = "0.7.0"
+  VERSION = "0.7.1"
 end

data/lib/mammoth.rb

@@ -4,10 +4,16 @@ require_relative "mammoth/version"
 require_relative "mammoth/errors"
 require_relative "mammoth/registry"
 require_relative "mammoth/configuration"
+require_relative "mammoth/lifecycle_hooks"
 require_relative "mammoth/node_identity"
 require_relative "mammoth/capabilities"
 require_relative "mammoth/status"
+require_relative "mammoth/commands/validate_command"
+require_relative "mammoth/commands/bootstrap_command"
 require_relative "mammoth/commands/status_command"
+require_relative "mammoth/commands/start_command"
+require_relative "mammoth/commands/deliver_sample_command"
+require_relative "mammoth/commands/dead_letters_command"
 require_relative "mammoth/observability_snapshot"
 require_relative "mammoth/observability_server"
 require_relative "mammoth/sqlite_store"
@@ -41,9 +47,10 @@ require_relative "mammoth/cli"
 
 # Mammoth is a self-hosted PostgreSQL event relay.
 #
-# Mammoth v0.1.0 focuses on a deliberately small, boring product slice:
-# PostgreSQL change events are normalized, persisted through local operational
-# state, and delivered to webhook destinations.
+# Mammoth 0.7.x is a single-node PostgreSQL CDC relay with webhook fanout,
+# replayable operational SQLite state, health/metrics endpoints, and explicit
+# extension contracts for state, destination, runtime, lifecycle, configuration,
+# and local command integrations.
 module Mammoth
   OperationalState::Registry.register("sqlite", OperationalState::SQLiteAdapter)
   Destinations::Registry.register("webhook", Destinations::WebhookAdapter)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mammoth
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Ken C. Demanawa
@@ -149,7 +149,12 @@ files:
 - lib/mammoth/cdc_source.rb
 - lib/mammoth/checkpoint_store.rb
 - lib/mammoth/cli.rb
+- lib/mammoth/commands/bootstrap_command.rb
+- lib/mammoth/commands/dead_letters_command.rb
+- lib/mammoth/commands/deliver_sample_command.rb
+- lib/mammoth/commands/start_command.rb
 - lib/mammoth/commands/status_command.rb
+- lib/mammoth/commands/validate_command.rb
 - lib/mammoth/concurrent_delivery_runtime.rb
 - lib/mammoth/configuration.rb
 - lib/mammoth/dead_letter_commands.rb
@@ -163,6 +168,7 @@ files:
 - lib/mammoth/errors.rb
 - lib/mammoth/event_serializer.rb
 - lib/mammoth/fanout_delivery_worker.rb
+- lib/mammoth/lifecycle_hooks.rb
 - lib/mammoth/node_identity.rb
 - lib/mammoth/observability_server.rb
 - lib/mammoth/observability_snapshot.rb