igniter 0.5.1 → 0.5.2

data/packages/igniter-app/lib/igniter/app/credentials/trail.rb

@@ -1,254 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-require "time"
-
-module Igniter
-  class App
-    module Credentials
-      class Trail
-        attr_reader :store
-
-        def initialize(store: nil, clock: -> { Time.now.utc.iso8601 })
-          @store = store
-          @clock = clock
-          @events = Array(store&.load_events).map { |event| normalize_loaded_event(event).freeze }
-        end
-
-        def record(event = nil, **attributes)
-          canonical_event =
-            if event
-              normalize_event(event)
-            else
-              build_event(attributes)
-            end
-
-          payload = canonical_event.to_h.merge(event_id: SecureRandom.uuid).freeze
-
-          @events << payload
-          store&.append(payload)
-          prune_retained_events!
-          payload
-        end
-
-        def events(limit: nil)
-          selected = limit ? @events.last(limit) : @events
-          selected.map(&:dup)
-        end
-
-        def latest_event
-          @events.last&.dup
-        end
-
-        def snapshot(limit: 10, filters: nil, order_by: nil, direction: :asc)
-          selected = apply_query(filters: filters, order_by: order_by, direction: direction)
-          limited = selected.first(limit)
-
-          {
-            query: {
-              filters: compact_filters(filters),
-              order_by: order_by&.to_sym,
-              direction: direction&.to_sym,
-              limit: limit
-            }.freeze,
-            total: selected.size,
-            latest_type: selected.last&.dig(:event),
-            latest_status: selected.last&.dig(:status),
-            latest_at: selected.last&.dig(:timestamp),
-            by_event: counts_for(:event, selected),
-            by_status: counts_for(:status, selected),
-            by_policy: counts_for(:policy_name, selected),
-            by_credential: counts_for(:credential_key, selected),
-            by_target_node: counts_for(:target_node, selected),
-            persistence: persistence_metadata,
-            events: limited.map(&:dup)
-          }
-        end
-
-        def lease_request_snapshot(limit: 10, filters: nil, order_by: nil, direction: :asc)
-          requests = apply_request_query(filters: filters, order_by: order_by, direction: direction)
-          limited = requests.first(limit)
-
-          {
-            query: {
-              filters: compact_filters(filters),
-              order_by: order_by&.to_sym,
-              direction: direction&.to_sym,
-              limit: limit
-            }.freeze,
-            total: requests.size,
-            latest_request_id: requests.last&.dig(:request_id),
-            latest_event: requests.last&.dig(:latest_event),
-            latest_status: requests.last&.dig(:status),
-            latest_at: requests.last&.dig(:latest_at),
-            by_event: counts_for(:latest_event, requests),
-            by_status: counts_for(:status, requests),
-            by_policy: counts_for(:policy_name, requests),
-            by_credential: counts_for(:credential_key, requests),
-            by_target_node: counts_for(:target_node, requests),
-            persistence: persistence_metadata,
-            requests: limited.map(&:dup)
-          }.freeze
-        end
-
-        def clear!
-          @events.clear
-          store&.clear!
-          self
-        end
-
-        private
-
-        def build_event(attributes)
-          Events::CredentialEvent.new(
-            timestamp: @clock.call,
-            **attributes
-          )
-        end
-
-        def normalize_event(value)
-          case value
-          when Events::CredentialEvent
-            value
-          when Hash
-            Events::CredentialEvent.from_h(value)
-          else
-            raise ArgumentError, "event must be a CredentialEvent or Hash"
-          end
-        end
-
-        def normalize_loaded_event(event)
-          canonical = normalize_event(event).to_h.each_with_object({}) do |(key, value), memo|
-            memo[key] = value
-          end
-          event_id = event[:event_id] || event["event_id"]
-          canonical[:event_id] = event_id if event_id
-          canonical
-        end
-
-        def counts_for(key, events)
-          Array(events).each_with_object(Hash.new(0)) do |event, memo|
-            value = event[key]
-            next if value.nil?
-
-            memo[value] += 1
-          end
-        end
-
-        def apply_query(filters:, order_by:, direction:)
-          filtered = apply_filters(@events, filters)
-          apply_order(filtered, order_by: order_by, direction: direction)
-        end
-
-        def apply_request_query(filters:, order_by:, direction:)
-          filtered = apply_filters(lease_request_records, filters)
-          apply_order(filtered, order_by: order_by, direction: direction)
-        end
-
-        def apply_filters(events, filters)
-          return Array(events) if filters.nil? || filters.empty?
-
-          filters.each_with_object(Array(events)) do |(key, value), memo|
-            next if value.nil? || (value.respond_to?(:empty?) && value.empty?)
-
-            allowed = Array(value)
-            memo.select! do |event|
-              event_value = event[key.to_sym]
-              allowed.include?(event_value)
-            end
-          end
-        end
-
-        def apply_order(events, order_by:, direction:)
-          return Array(events) if order_by.nil?
-
-          sorted = Array(events).sort_by do |event|
-            value = event[order_by.to_sym]
-            value.is_a?(Symbol) ? value.to_s : value.to_s
-          end
-          direction.to_sym == :desc ? sorted.reverse : sorted
-        end
-
-        def compact_filters(filters)
-          (filters || {}).each_with_object({}) do |(key, value), memo|
-            next if value.nil? || (value.respond_to?(:empty?) && value.empty?)
-
-            memo[key.to_sym] = Array(value)
-          end.freeze
-        end
-
-        def persistence_metadata
-          return { enabled: false } unless store
-
-          return store.persistence_metadata if store.respond_to?(:persistence_metadata)
-
-          {
-            enabled: true,
-            store_class: store.class.name,
-            path: store.respond_to?(:path) ? store.path : nil
-          }.compact
-        end
-
-        def prune_retained_events!
-          if store&.respond_to?(:prune_events)
-            @events = store.prune_events(@events).map(&:freeze)
-            return
-          end
-
-          limit = store&.respond_to?(:retained_limit) ? store.retained_limit : nil
-          return unless limit && limit.positive?
-          return if @events.size <= limit
-
-          @events.shift(@events.size - limit)
-        end
-
-        def lease_request_records
-          grouped = Hash.new { |hash, key| hash[key] = [] }
-
-          @events.each do |event|
-            next unless event[:event].to_s.start_with?("lease_")
-
-            grouped[request_id_for(event)] << event
-          end
-
-          grouped.each_value.map do |events|
-            build_request_record(events)
-          end
-        end
-
-        def build_request_record(events)
-          ordered_events = Array(events).sort_by { |event| event[:timestamp].to_s }
-          latest = ordered_events.last || {}
-          first = ordered_events.first || {}
-          metadata = latest.fetch(:metadata, {})
-
-          {
-            request_id: request_id_for(latest),
-            credential_key: latest[:credential_key],
-            policy_name: latest[:policy_name],
-            node: latest[:node] || first[:node],
-            target_node: latest[:target_node] || first[:target_node],
-            actor: latest[:actor],
-            origin: latest[:origin],
-            source: latest[:source],
-            reason: latest[:reason],
-            lease_id: latest[:lease_id],
-            requested_scope: metadata[:requested_scope],
-            credential_provider: metadata[:credential_provider],
-            latest_event: latest[:event],
-            status: latest[:status],
-            latest_at: latest[:timestamp],
-            requested_at: first[:timestamp],
-            events_count: ordered_events.size,
-            events: ordered_events.map(&:dup)
-          }.compact.freeze
-        end
-
-        def request_id_for(event)
-          metadata = event.fetch(:metadata, {})
-          metadata[:request_id] || event[:lease_id] || "#{event[:timestamp]}:#{event[:credential_key]}:#{event[:target_node]}"
-        end
-      end
-    end
-  end
-end

data/packages/igniter-app/lib/igniter/app/credentials.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/core"
-
-require_relative "credentials/credential_policy"
-require_relative "credentials/credential"
-require_relative "credentials/config_loader"
-require_relative "credentials/lease_request"
-require_relative "credentials/policies"
-require_relative "credentials/events"
-require_relative "credentials/trail"
-require_relative "credentials/store"
-require_relative "credentials/stores/file_store"
-
-module Igniter
-  class App
-    module Credentials
-    end
-  end
-end

data/packages/igniter-app/lib/igniter/app/dev_output_sync.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-$stdout.sync = true
-$stderr.sync = true

data/packages/igniter-app/lib/igniter/app/diagnostics/app_host_contributor.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  class App
-    module Diagnostics
-      module AppHostContributor
-        class << self
-          def augment(report:, execution:) # rubocop:disable Lint/UnusedMethodArgument
-            app = report[:app]
-            return report unless app
-            return report unless app[:host] == :app
-
-            settings = Hash(app.dig(:host_settings, :app) || {})
-            report[:app_host] = {
-              adapter: :server,
-              host: settings[:host],
-              port: settings[:port],
-              log_format: settings[:log_format],
-              drain_timeout: settings[:drain_timeout],
-              routes: app[:routes],
-              hooks: app[:hooks],
-              metrics: app[:metrics],
-              store: app[:store]
-            }
-            report
-          end
-
-          def append_text(report:, lines:)
-            app_host = report[:app_host]
-            return unless app_host
-
-            lines << "App Host: #{summary(app_host)}"
-          end
-
-          def append_markdown_summary(report:, lines:)
-            app_host = report[:app_host]
-            return unless app_host
-
-            lines << "- App Host: #{summary(app_host)}"
-          end
-
-          def append_markdown_sections(report:, lines:)
-            app_host = report[:app_host]
-            return unless app_host
-
-            lines << ""
-            lines << "## App Host"
-            lines << "- Listener: host=`#{app_host[:host]}` port=`#{app_host[:port]}` log_format=`#{app_host[:log_format]}`"
-            lines << "- Runtime: drain_timeout=#{app_host[:drain_timeout]}, routes=#{app_host[:routes]}"
-            lines << "- Hooks: before=#{app_host.dig(:hooks, :before_request)}, after=#{app_host.dig(:hooks, :after_request)}, around=#{app_host.dig(:hooks, :around_request)}"
-            lines << "- Metrics: configured=#{app_host.dig(:metrics, :configured)}"
-            lines << "- Store: configured=#{app_host.dig(:store, :configured)}"
-          end
-
-          private
-
-          def summary(app_host)
-            [
-              "host=#{app_host[:host]}",
-              "port=#{app_host[:port]}",
-              "log_format=#{app_host[:log_format]}",
-              "routes=#{app_host[:routes]}",
-              "metrics=#{app_host.dig(:metrics, :configured)}",
-              "store=#{app_host.dig(:store, :configured)}"
-            ].join(", ")
-          end
-        end
-      end
-    end
-  end
-end

data/packages/igniter-app/lib/igniter/app/diagnostics/cluster_app_host_contributor.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  class App
-    module Diagnostics
-      module ClusterAppHostContributor
-        class << self
-          def augment(report:, execution:) # rubocop:disable Lint/UnusedMethodArgument
-            app = report[:app]
-            return report unless app
-            return report unless app[:host] == :cluster_app
-
-            cluster_settings = Hash(app.dig(:host_settings, :cluster_app) || {})
-            server_settings = Hash(app.dig(:host_settings, :app) || {})
-
-            report[:cluster_app_host] = {
-              adapter: :cluster_app,
-              peer_name: cluster_settings[:peer_name],
-              local_capabilities: Array(cluster_settings[:local_capabilities]).map(&:to_sym).sort,
-              local_tags: Array(cluster_settings[:local_tags]).map(&:to_sym).sort,
-              local_metadata: Hash(cluster_settings[:local_metadata] || {}),
-              local_metadata_keys: Hash(cluster_settings[:local_metadata] || {}).keys.map(&:to_s).sort,
-              seeds: Array(cluster_settings[:seeds]),
-              seed_count: Array(cluster_settings[:seeds]).size,
-              static_peers: Array(cluster_settings[:peers]).map { |peer| serialize_peer(peer) },
-              static_peer_count: Array(cluster_settings[:peers]).size,
-              discovery_interval: cluster_settings[:discovery_interval],
-              auto_announce: cluster_settings[:auto_announce],
-              local_url: cluster_settings[:local_url],
-              gossip_fanout: cluster_settings[:gossip_fanout],
-              start_discovery: cluster_settings[:start_discovery],
-              server: {
-                host: server_settings[:host],
-                port: server_settings[:port],
-                log_format: server_settings[:log_format],
-                drain_timeout: server_settings[:drain_timeout]
-              }
-            }
-            report
-          end
-
-          def append_text(report:, lines:)
-            cluster_host = report[:cluster_app_host]
-            return unless cluster_host
-
-            lines << "Cluster Host: #{summary(cluster_host)}"
-          end
-
-          def append_markdown_summary(report:, lines:)
-            cluster_host = report[:cluster_app_host]
-            return unless cluster_host
-
-            lines << "- Cluster Host: #{summary(cluster_host)}"
-          end
-
-          def append_markdown_sections(report:, lines:)
-            cluster_host = report[:cluster_app_host]
-            return unless cluster_host
-
-            lines << ""
-            lines << "## Cluster App Host"
-            lines << "- Peer: name=`#{cluster_host[:peer_name] || "anonymous"}` local_url=`#{cluster_host[:local_url] || "n/a"}`"
-            lines << "- Capabilities: total=#{cluster_host[:local_capabilities].size}, names=#{cluster_host[:local_capabilities].join(", ")}"
-            lines << "- Tags: total=#{cluster_host[:local_tags].size}, names=#{cluster_host[:local_tags].join(", ")}"
-            lines << "- Mesh: seeds=#{cluster_host[:seed_count]}, static_peers=#{cluster_host[:static_peer_count]}, discovery_interval=#{cluster_host[:discovery_interval]}, auto_announce=#{cluster_host[:auto_announce]}, start_discovery=#{cluster_host[:start_discovery]}, gossip_fanout=#{cluster_host[:gossip_fanout]}"
-            lines << "- Server: host=`#{cluster_host.dig(:server, :host)}` port=`#{cluster_host.dig(:server, :port)}` log_format=`#{cluster_host.dig(:server, :log_format)}`"
-          end
-
-          private
-
-          def serialize_peer(peer)
-            normalized = Hash(peer || {})
-            {
-              name: normalized[:name],
-              url: normalized[:url],
-              capabilities: Array(normalized[:capabilities]).map(&:to_sym).sort,
-              tags: Array(normalized[:tags]).map(&:to_sym).sort,
-              metadata_keys: Hash(normalized[:metadata] || {}).keys.map(&:to_s).sort
-            }
-          end
-
-          def summary(cluster_host)
-            [
-              "peer=#{cluster_host[:peer_name] || "anonymous"}",
-              "capabilities=#{cluster_host[:local_capabilities].size}",
-              "tags=#{cluster_host[:local_tags].size}",
-              "seeds=#{cluster_host[:seed_count]}",
-              "static_peers=#{cluster_host[:static_peer_count]}",
-              "auto_announce=#{cluster_host[:auto_announce]}",
-              "start_discovery=#{cluster_host[:start_discovery]}"
-            ].join(", ")
-          end
-        end
-      end
-    end
-  end
-end

data/packages/igniter-app/lib/igniter/app/diagnostics/credential_contributor.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  class App
-    module Diagnostics
-      module CredentialContributor
-        class << self
-          def augment(report:, execution:) # rubocop:disable Lint/UnusedMethodArgument
-            context = Igniter::App::RuntimeContext.current
-            return report unless context
-
-            app_class = context.fetch(:app_class)
-            credential_audit = app_class.send(:credential_audit_overview, limit: 10)
-            return report unless credential_audit
-
-            report[:app_credentials] = credential_audit
-            report
-          end
-
-          def append_text(report:, lines:)
-            credentials = report[:app_credentials]
-            return unless credentials
-
-            lines << "App Credentials: #{summary(credentials)}"
-          end
-
-          def append_markdown_summary(report:, lines:)
-            credentials = report[:app_credentials]
-            return unless credentials
-
-            lines << "- App Credentials: #{summary(credentials)}"
-          end
-
-          def append_markdown_sections(report:, lines:)
-            credentials = report[:app_credentials]
-            return unless credentials
-
-            lines << ""
-            lines << "## App Credentials"
-            lines << "- Summary: #{summary(credentials)}"
-            Array(credentials[:events]).each do |event|
-              lines << "- `#{event[:event]}` credential=`#{event[:credential_key]}` policy=`#{event[:policy_name]}` status=`#{event[:status]}` target=`#{event[:target_node] || "none"}` reason=`#{event[:reason] || "none"}`"
-            end
-          end
-
-          private
-
-          def summary(credentials)
-            parts = []
-            parts << "events=#{credentials[:total]}"
-            parts << "latest=#{credentials[:latest_type]}" if credentials[:latest_type]
-            parts << "status=#{credentials[:latest_status]}" if credentials[:latest_status]
-            parts << "by_event=#{inline_counts(credentials[:by_event])}" unless credentials[:by_event].nil? || credentials[:by_event].empty?
-            parts << "by_policy=#{inline_counts(credentials[:by_policy])}" unless credentials[:by_policy].nil? || credentials[:by_policy].empty?
-            parts << "persisted=#{credentials.dig(:persistence, :enabled)}"
-            parts.join(", ")
-          end
-
-          def inline_counts(counts)
-            counts.sort_by { |key, _count| key.to_s }.map { |key, count| "#{key}=#{count}" }.join(", ")
-          end
-        end
-      end
-    end
-  end
-end

data/packages/igniter-app/lib/igniter/app/diagnostics/evolution_contributor.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  class App
-    module Diagnostics
-      module EvolutionContributor
-        class << self
-          def augment(report:, execution:) # rubocop:disable Lint/UnusedMethodArgument
-            context = Igniter::App::RuntimeContext.current
-            return report unless context
-
-            report[:app_evolution] = context.fetch(:app_class).evolution_trail.snapshot(limit: 10)
-            report
-          end
-
-          def append_text(report:, lines:)
-            evolution = report[:app_evolution]
-            return unless evolution
-
-            lines << "App Evolution: #{summary(evolution)}"
-          end
-
-          def append_markdown_summary(report:, lines:)
-            evolution = report[:app_evolution]
-            return unless evolution
-
-            lines << "- App Evolution: #{summary(evolution)}"
-          end
-
-          def append_markdown_sections(report:, lines:)
-            evolution = report[:app_evolution]
-            return unless evolution
-
-            lines << ""
-            lines << "## App Evolution"
-            lines << "- Events: total=#{evolution[:total]}, latest=#{evolution[:latest_type] || "none"}"
-            lines << "- Persistence: enabled=#{evolution.dig(:persistence, :enabled)} store=#{evolution.dig(:persistence, :store_class) || "none"} path=#{evolution.dig(:persistence, :path) || "none"} retain=#{evolution.dig(:persistence, :max_events) || "all"} archived=#{evolution.dig(:persistence, :archived_events) || 0}"
-            unless evolution.dig(:persistence, :retention_policy).nil? || evolution.dig(:persistence, :retention_policy).empty?
-              lines << "- Retention Policy: #{inline_counts(evolution.dig(:persistence, :retention_policy))}"
-            end
-            unless evolution.dig(:persistence, :retained_by_class).nil? || evolution.dig(:persistence, :retained_by_class).empty?
-              lines << "- Live Crest: #{inline_counts(evolution.dig(:persistence, :retained_by_class))}"
-            end
-            evolution[:events].each do |event|
-              lines << "- `#{event[:type]}` source=`#{event[:source]}` at=`#{event[:timestamp]}` payload=#{event[:payload].inspect}"
-            end
-          end
-
-          private
-
-          def summary(evolution)
-            parts = []
-            parts << "total=#{evolution[:total]}"
-            parts << "latest=#{evolution[:latest_type] || "none"}"
-            if evolution[:persistence]
-              parts << "persisted=#{evolution.dig(:persistence, :enabled)}"
-              parts << "retain=#{evolution.dig(:persistence, :max_events) || "all"}"
-              parts << "archived=#{evolution.dig(:persistence, :archived_events) || 0}"
-              unless evolution.dig(:persistence, :retained_by_class).nil? || evolution.dig(:persistence, :retained_by_class).empty?
-                parts << "live=#{inline_counts(evolution.dig(:persistence, :retained_by_class))}"
-              end
-            end
-            parts << "types=#{inline_counts(evolution[:by_type])}" unless evolution[:by_type].empty?
-            parts.join(", ")
-          end
-
-          def inline_counts(counts)
-            counts.sort_by { |key, _count| key.to_s }.map { |key, count| "#{key}=#{count}" }.join(", ")
-          end
-        end
-      end
-    end
-  end
-end