diff --git a/.custodian-brief.md b/.custodian-brief.md index b64d033..c962686 100644 --- a/.custodian-brief.md +++ b/.custodian-brief.md @@ -2,19 +2,16 @@ # Custodian Brief — facetted-interfaces **Domain:** infotech -**Last synced:** 2026-09-09 19:45 UTC +**Last synced:** 2026-09-09 19:52 UTC **State Hub:** http://127.0.0.1:8000 *(adjust if running on a remote machine)* ## Active Workstreams -### Bootstrap FIAM repository governance and baseline -Progress: 1/5 done | workplan_id: `df6dc111-064b-5154-964b-6683190a79f6` +*(none — repo may need first-session setup)* -**Open tasks:** -- · T02 — Register repository with State Hub `ab0919d3` -- · T03 — Verify and document the Draft 6 baseline `e49c82ce` -- · T04 — Plan the maintained FIAM release layout `19518be4` -- · T05 — Close out the bootstrap `e85b9157` +## SCOPE Freshness + +- SCOPE.md says active but no open workplans remain — refresh Current State. --- ## MCP Orientation (when available) diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e4e0199 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +# state-hub: track .claude/rules +# Claude Code local state (track shared rules; ignore machine-specific files) +.claude/* +!.claude/rules/ +!.claude/rules/*.md diff --git a/.repo-classification.yaml b/.repo-classification.yaml new file mode 100644 index 0000000..65e0f41 --- /dev/null +++ b/.repo-classification.yaml @@ -0,0 +1,20 @@ +repo_classification: + standard: Repo Classification Standard + version: '1.0' + classified_at: '2026-09-09' + classified_by: agent + category: project + domain: infotech + secondary_domains: [] + capability_tags: + - interface-architecture + - standards + - evidence + - traceability + - source-management + business_stake: + - technology + - operations + business_mechanics: + - coordination + - operation diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..f354093 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,205 @@ +# facetted-interfaces — Agent Instructions + +## Repo Identity + +**Purpose:** FIAM standard and reference architecture analytics and control implementation + +**Domain:** infotech +**Repo slug:** facetted-interfaces +**Topic ID:** `fe2aaa78-9c20-4feb-b3d2-4fe0529572a3` +**Workplan prefix:** `FIAM-WP-` + +--- + +## State Hub Integration + +The Custodian State Hub tracks work across all domains. Codex uses HTTP REST and +the `statehub` CLI by default. MCP is opt-in because the current Codex MCP bridge +adds severe call latency; the full administrative MCP surface remains available +to clients that need it. + +| Context | URL | +|---------|-----| +| Local workstation | `http://127.0.0.1:8000` | +| Remote via tunnel | `http://127.0.0.1:18000` | +| Optional local edge relay | http://127.0.0.1:18080 | + +When an operator has enabled the edge relay, set API_BASE to the relay URL. +Queueable writes return an explicit queued receipt if the central hub is +unreachable. Treat that as pending local evidence, then ask the operator to run +statehub outbox status/replay after connectivity returns. + +Codex workspace-write sandboxes need network access enabled to reach the host's +loopback listener. Bootstrap this once with `make -C ~/state-hub configure-codex` +and restart Codex. The canonical REST health endpoint is `/state/health`, not +`/health`. If a sandboxed loopback probe fails, retry it with escalated execution +before declaring State Hub unavailable; a managed Codex permission profile may +still enforce isolated networking. Experimental MCP can be enabled explicitly +with `make -C ~/state-hub configure-codex WITH_MCP=1`. + +### Orient at session start + +```bash +# Offline brief — works without hub connection +cat .custodian-brief.md + +# Active workplans for this domain +curl -s "http://127.0.0.1:8000/workplans/?topic_id=fe2aaa78-9c20-4feb-b3d2-4fe0529572a3&status=active" \ + | python3 -m json.tool + +# Check inbox +curl -s "http://127.0.0.1:8000/messages/?to_agent=facetted-interfaces&unread_only=true" \ + | python3 -m json.tool +``` + +Mark a message read: +```bash +curl -s -X PATCH "http://127.0.0.1:8000/messages//read" \ + -H "Content-Type: application/json" -d '{}' +``` + +### Log progress (required at session close) + +```bash +curl -s -X POST http://127.0.0.1:8000/progress/ \ + -H "Content-Type: application/json" \ + -d '{ + "summary": "what was done", + "event_type": "note", + "author": "codex", + "workplan_id": "", + "task_id": "" + }' +``` + +Omit `workplan_id` / `task_id` when not applicable. + +### Update task status + +```bash +curl -s -X PATCH "http://127.0.0.1:8000/tasks/" \ + -H "Content-Type: application/json" \ + -d '{"status": "progress"}' +# values: wait | todo | progress | done | cancel +``` + +### Flag a task for human review + +```bash +curl -s -X PATCH "http://127.0.0.1:8000/tasks/" \ + -H "Content-Type: application/json" \ + -d '{"needs_human": true, "intervention_note": "reason"}' +``` + +--- + +## Session Protocol + +**Start:** +1. `cat .custodian-brief.md` — domain goal and open workplans (offline-safe) +2. Check inbox: `GET /messages/?to_agent=facetted-interfaces&unread_only=true`; mark read +3. Scan workplans: `ls workplans/` — note `status: ready`, `active`, or `blocked` files and open tasks +4. Check human-needed tasks: `GET /tasks/?needs_human=true` + +**During work:** +- Update task statuses in workplan files as tasks progress +- Record significant decisions via `POST /decisions/` + +**Close:** +1. Update workplan file task statuses to reflect progress +2. If finishing a workplan: hand off **residuals** as live work records first + (intake with `origin: residual` + `origin_ref: `, or a next workplan / + decision / engagement). Do not park leftovers only in prose or `SCOPE.md`. + Canon: `the-custodian/canon/standards/work-record-types_v0.1.md` § Residuals. +3. Log: `POST /progress/` with a summary of what changed (name handoff ids) +4. After workplan file changes, run: + ```bash + uv run --project ~/repo-manager rmgr sync --path . --push + ``` + This assigns only missing deterministic identifiers, verifies the pushed + Forgejo commit and `primary/railliance01`, then requests one central + reconciliation. A queued receipt is pending evidence; rerun after + connectivity returns. Use `statehub fix-consistency` for a separate deep audit. + +--- + +{CREDENTIAL_ROUTING} + + + + +--- + +## Workplan Convention (ADR-001) + +Work items originate as files in this repo — not in the hub. The hub is a +read/cache/index layer that rebuilds from files. + +**File location:** `workplans/FIAM-WP-NNNN-.md` + +**Archived location:** finished workplans may move to +`workplans/archived/YYMMDD-FIAM-WP-NNNN-.md`. The `YYMMDD` prefix is +the completion/archive date; the frontmatter `id` does not change. + +**Ad Hoc Tasks:** small opportunistic fixes discovered during a session use +`workplans/ADHOC-YYYY-MM-DD.md`, workplan id +`FIAM-WP-ADHOC-YYYY-MM-DD`, and task ids +`FIAM-WP-ADHOC-YYYY-MM-DD-T01`, etc. `FIAM-WP` includes its final `-WP` +token. Unqualified historic `ADHOC-*` ids are grandfathered and must not be +copied into new records. Use this only for low-risk work completed directly; +create a normal workplan for anything needing analysis, design, approval, +dependencies, or multiple phases. + +**Frontmatter:** + +```yaml +--- +id: FIAM-WP-NNNN +type: workplan +title: "..." +domain: infotech +repo: facetted-interfaces +status: proposed | ready | active | blocked | backlog | finished | archived +owner: codex +topic_slug: ... +created: "YYYY-MM-DD" +updated: "YYYY-MM-DD" +state_hub_workstream_id: "" # deterministic UUIDv5; managed by Repo Manager +--- +``` + +Use `proposed` for a new draft, `ready` after review against current repo +state, and `finished` after implementation. `stalled` and `needs_review` are +derived health labels, not frontmatter statuses. + +**Terminology:** workplan is the fleet term; `workstream` appears only in legacy +API/MCP/frontmatter bridges until `STATE-WP-0069` retires them — see +`the-custodian/canon/standards/workplan-terminology-fleet_v0.1.md`. + +**Task block format** (one per `##` section): + +``` +## Task Title + +` ` `task +id: FIAM-WP-NNNN-T01 +status: wait | todo | progress | done | cancel +priority: high | medium | low +state_hub_task_id: "" # deterministic UUIDv5; managed by Repo Manager +` ` ` + +Task description text. +``` + +Status progression: `todo` → `progress` → `done`; use `wait` for waiting/blocked work and `cancel` for stopped work. + +**Residuals when finishing:** actionable leftovers become live work records +before `status: finished` — usually an intake (`origin: residual`, +`origin_ref: FIAM-WP-NNNN`) or a spawned workplan. Residual is a *role*, +not a kind. Fleet list lives on State Hub, not in `SCOPE.md`. + +To create a new workplan: +1. Write the file following the format above +2. Run `uv run --project ~/repo-manager rmgr sync --path . --push`. +3. Run `statehub fix-consistency` only when a separate deep audit is needed. diff --git a/INTENT.md b/INTENT.md new file mode 100644 index 0000000..f84d8d2 --- /dev/null +++ b/INTENT.md @@ -0,0 +1,56 @@ +# INTENT + +## Purpose + +This repository develops and maintains the FIAM (Facetted Interface +Architecture Model) standard and its reference architecture, analytics, and +control implementation. + +FIAM provides a precise way to describe interfaces as composable facets, +connect declared architecture with runtime evidence, and query the resulting +architecture without confusing observations with declarations. + +## Intended Users + +The primary users are architects, platform engineers, implementers of +interface and architecture tooling, and agents working across the FIAM +ecosystem. The repository should make the standard understandable and +executable for both humans and automation. + +## Scope + +This repository owns: + +- the FIAM vocabulary, canonical model, and conformance rules; +- schemas and examples for declared, observed, and composite architectures; +- reference converters, catalog/index tools, and analytical lenses; +- validation, adversarial fixtures, and semantic-regression checks; +- documentation of versioning, identity, evidence, snapshots, and migration. + +It does not own deployment of a consuming platform, a general-purpose +service catalog, or the product UI of downstream architecture products. + +## Architectural Principles + +- Keep interface identity, representation shape, and evidence distinct. +- Preserve source records and provenance; inferred correspondence is not a + destructive merge. +- Treat declared and observed architecture as complementary projections. +- Make uncertainty, ambiguity, staleness, and missing evidence explicit. +- Prefer deterministic, schema-validated artifacts and reproducible checks. +- Evolve the standard deliberately, with migration and conformance guidance. + +## Current Baseline + +The current repository is a seed containing the FIAM v0.2 Draft 6 reference +material under `history/FIAM_v0.2_Draft6/`. That material is the starting +baseline, not yet a complete actively maintained release layout. The first +operational priority is to establish ownership, validation, and a clear path +from the archived draft to the next maintained FIAM release. + +## Completion Condition + +The intent is being fulfilled when FIAM has a maintained normative release, +an executable conformance suite, documented extension and migration rules, +and reference tooling that produces trustworthy architecture intelligence from +declared and runtime interface evidence. diff --git a/README.md b/README.md index e85da43..7631ef4 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,15 @@ # facetted-interfaces -The FIAM Facetted Interface Architecture Model standard with it's reference architecture analytics and control reference implementation. \ No newline at end of file +The FIAM Facetted Interface Architecture Model standard with it's reference architecture analytics and control reference implementation. + +## Repository baseline + +The maintained starting point is the FIAM v0.2 Draft 6 reference tree in +`history/FIAM_v0.2_Draft6/`. Its conformance suite is run with: + +```bash +make -C history/FIAM_v0.2_Draft6 check +``` + +Normative releases should be promoted into a versioned top-level release +layout; `history/` remains reserved for superseded drafts. diff --git a/SCOPE.md b/SCOPE.md new file mode 100644 index 0000000..f23d62a --- /dev/null +++ b/SCOPE.md @@ -0,0 +1,32 @@ +# SCOPE + +> This file was generated by `statehub register`. Refine it as the repository +> boundaries become clearer. + +## One-liner + +FIAM standard and reference architecture analytics and control implementation + +## Core Idea + +facetted-interfaces exists to provide the capability described in INTENT.md. + +## In Scope + +- Maintain the repository's primary implementation. +- Keep docs, tests, and operational metadata current. + +## Out of Scope + +- Own unrelated adjacent systems. +- Make irreversible operational decisions without human approval. + +## Current State + +- Status: active; implementation and stability should be verified by the repo agent. + +## Getting Oriented + +- Start with: INTENT.md +- Agent instructions: AGENTS.md +- Workplans: workplans/ diff --git a/WORK-RECORDS.md b/WORK-RECORDS.md new file mode 100644 index 0000000..8f8e402 --- /dev/null +++ b/WORK-RECORDS.md @@ -0,0 +1,16 @@ +# Work Records — facetted-interfaces + +> Generated by `statehub fix-consistency` (CUST-WP-0061-T04, work-record +> stage 3). Do not edit by hand — edit the source file/block listed for +> each record and re-run fix-consistency to refresh this index. Archived +> workplans are omitted; closed decisions/intakes/engagements stay listed +> so recently-resolved work is still visible. [auto] + +| Kind | ID | Status | Lane | Source | +| --- | --- | --- | --- | --- | +| workplan | FIAM-WP-0001 | finished | — | workplans/FIAM-WP-0001-statehub-bootstrap-and-baseline.md | +| task | FIAM-WP-0001-T01 | done | — | workplans/FIAM-WP-0001-statehub-bootstrap-and-baseline.md | +| task | FIAM-WP-0001-T02 | done | — | workplans/FIAM-WP-0001-statehub-bootstrap-and-baseline.md | +| task | FIAM-WP-0001-T03 | done | — | workplans/FIAM-WP-0001-statehub-bootstrap-and-baseline.md | +| task | FIAM-WP-0001-T04 | done | — | workplans/FIAM-WP-0001-statehub-bootstrap-and-baseline.md | +| task | FIAM-WP-0001-T05 | done | — | workplans/FIAM-WP-0001-statehub-bootstrap-and-baseline.md | diff --git a/history/FIAM_v0.2_Draft6/ARCHITECTURE-INTELLIGENCE-INDEX-v0.2.md b/history/FIAM_v0.2_Draft6/ARCHITECTURE-INTELLIGENCE-INDEX-v0.2.md new file mode 100644 index 0000000..4cc3116 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/ARCHITECTURE-INTELLIGENCE-INDEX-v0.2.md @@ -0,0 +1,80 @@ +# FIAM v0.2 — Architecture Intelligence Index Contract + +## Derived query plane + +The index is a rebuildable query projection. It MUST NOT become the sole copy of FIAM evidence or Catalog Exchange history. + +Draft.6 indexes: + +- latest entities plus historical entity versions; +- raw assertions and raw evidence; +- non-destructive working identities; +- generic declared relation inventory; +- runtime aggregates; +- **scope-owned topology observation intervals**; +- **population-level logical topology intervals** formed by unioning observation scopes; +- unresolved observations and reconciliation candidates; +- temporal Zone memberships. + +## Observation scope vs logical architecture + +A logical architectural edge has one `edge_key`. Each observing collector has a distinct `observation_scope` and therefore a distinct observation interval: + +```text +logical Orders -> Inventory + observed by prod-cluster-a-app-traces + observed by prod-cluster-a-mesh +``` + +The logical edge remains active while any covering observation scope remains active. Closing one collector's observation never closes another collector's interval. + +This avoids both collector identity contaminating Core architectural identity and one platform team accidentally closing another team's observations. + +## Complete snapshot closure + +A complete snapshot can close only observations: + +- owned by its observation scope; +- in domains covered by its authority grant; +- missing for the configured number of consecutive complete snapshots; +- whose `last_seen` is older than the configured grace period. + +The observation interval records: + +- `last_seen` — evidence time; +- `closed_at` — policy-action time; +- `close_reason`; +- `absence_streak` in current observation state. + +Population-level logical intervals close only when every active observation scope for that edge has closed. + +## Raw evidence only + +The index stores raw evidence records. It MUST NOT persist evidence-strength scores as architectural facts. Evidence scores are computed by a Lens at query time and every result identifies the scoring policy id/hash. + +## Declaration inventory + +Declared relation assertions are indexed generically with subject/object owner projections. The query-time declaration matcher determines whether a runtime edge is declared using target, intended target, Channel, working-set identity, and domain-aware relation semantics. + +## Catalog-native write path + +Continuous ingestion SHOULD use Catalog Exchange records directly: + +```text +adapter -> Catalog Exchange/NDJSON -> index +``` + +A whole FIAM YAML model is not required as a write-ahead log. FIAM model conversion remains available for audit, interoperability and fixtures. + +The index can export a scope checkpoint as Catalog Exchange, but the checkpoint does not replace original evidence/source documents. + +## Retention + +Closed intervals and historical entity/assertion/evidence versions are retained until an explicit derived-index purge. A purge: + +- requires an explicit confirmation flag; +- removes only index rows older than the requested time; +- MUST NOT delete Catalog Exchange or source artifacts; +- makes older historical queries unavailable until the index is rebuilt from retained exchange artifacts. + +This preserves the distinction between **disposable index retention** and **evidence/audit retention**. diff --git a/history/FIAM_v0.2_Draft6/CATALOG-EXCHANGE-PROFILE-v0.2.md b/history/FIAM_v0.2_Draft6/CATALOG-EXCHANGE-PROFILE-v0.2.md new file mode 100644 index 0000000..10907a4 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/CATALOG-EXCHANGE-PROFILE-v0.2.md @@ -0,0 +1,74 @@ +# FIAM v0.2 — Catalog Exchange Profile + +## Purpose + +The Catalog Exchange Profile is the **versioned operational interchange contract** between FIAM adapters and persistent architecture catalogs. It makes the runtime/catalog extensions public and stable without changing the frozen FIAM Core. + +FIAM Core models remain the architecture/evidence exchange form for hand-authored and reconstructed models. Catalog Exchange documents are optimized for incremental catalog ingestion, replay, audit, and index rebuild. + +## Envelope + +Every exchange document contains: + +```yaml +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange. +created_at: 2026-09-09T12:00:00Z +source: + source_id: collector.prod.app-traces + source_kind: otlp-adapter + source_ref: estate://collector/app-traces +observation: + mode: incremental # incremental | complete-snapshot | declared-snapshot + observation_scope: prod-cluster-a-app-traces + population_id: prod-cluster-a + population: {environment: prod, cluster: cluster-a} + domains: [http, rpc] + snapshot_time: 2026-09-09T12:00:00Z +records: + entities: [] + assertions: [] + zone_memberships: [] + runtime_aggregates: [] + topology_observations: [] + unresolved: [] + reconciliation_candidates: [] +``` + +For `complete-snapshot`, the source and observation scope MUST be authorized by the Snapshot Authority Policy. Incremental documents never close absence. + +## Record stability + +Within the v0.2 line: + +- existing field meanings MUST NOT be silently changed; +- new optional fields may be added; +- `catalog_exchange_version` changes if an incompatible exchange change is required; +- Core entity payloads are carried unchanged inside `records.entities[*].entity`; +- assertions preserve their complete Core assertion/evidence payload; +- topology and aggregate records use stable architectural identifiers rather than span ids. + +## Zone membership + +`zone_memberships` is explicit in the exchange profile because it is required for temporal boundary queries. Deployment environment, cluster, and Kubernetes namespace membership SHOULD be derived automatically from runtime identity tuples. Trust and organization Zones remain declared knowledge unless a separate authoritative source provides them. + +## Streaming serialization + +The canonical logical model is the envelope above. The same content may be serialized as NDJSON: + +```text +{"record_type":"header", ...} +{"record_type":"entity", ...} +{"record_type":"assertion", ...} +{"record_type":"topology", ...} +... +``` + +An index may ingest this stream directly. It need not create or rewrite a whole FIAM YAML model for every telemetry batch. + +## Rebuildability + +A Catalog Index MUST be rebuildable from a retained sequence of Catalog Exchange documents plus referenced FIAM declared artifacts. SQLite/PostgreSQL/graph indexes are projections; exchange documents and their original evidence references remain the audit surface. + +Index export is supported for inspection and checkpointing, but an exported index view does not replace the original evidence-bearing exchange history. diff --git a/history/FIAM_v0.2_Draft6/CONFORMANCE.txt b/history/FIAM_v0.2_Draft6/CONFORMANCE.txt new file mode 100644 index 0000000..f3c0d52 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/CONFORMANCE.txt @@ -0,0 +1,24 @@ +FIAM v0.2-draft.6 Catalog Operations & Policy conformance: PASS +CORE-FREEZE PASS byte-identical frozen v0.2 Core +SEMANTIC-CORPUS PASS 26 specimens +SNAPSHOT-AUTHORITY-POLICY PASS validated scoped authority grants +CATALOG-EXCHANGE PASS versioned exchange fixtures +AUTHORITY-GRACE PASS first missing complete snapshot does not close recent/once-missing edge +AUTHORITY-CLOSURE PASS last_seen evidence remains distinct from closed_at policy action +TEMPORAL-QUERY PASS appeared/disappeared/newly-undeclared with governed closure +BOUNDARY-DRIFT PASS trust + organization crossing +POLICY-INTELLIGENCE PASS undeclared partner dependency is high-materiality + policy violation under named policy +TEMPORAL-REAPPEARANCE PASS closed history preserved and new interval opened +QUERY-TIME-SCORING PASS index stores raw evidence, not policy scores +RETENTION PASS explicit purge affects derived index only +AUTHORITY-DOMAIN PASS HTTP completeness cannot close RPC +MULTI-SCOPE PASS app scope closes while mesh scope keeps one logical dependency active +AUTHORITY-OWNERSHIP PASS source cannot claim another source observation scope +DECLARATION-MATCHING PASS Channel + gateway intended target + working-set preferred ids +ZONE-DERIVATION PASS deployment identity automatically yields environment/cluster/namespace memberships +OPERATION-COVERAGE PASS observed + dormant + never-observed declared capabilities +SECURITY-EVIDENCE-COVERAGE PASS declared auth + observed operation remains runtime-security unknown +EVIDENCE-HEALTH PASS conflict + challenge + stale evidence; scoring policy id/hash explicit +INDEX-NATIVE-INGEST PASS NDJSON direct write + replay idempotency + Catalog Exchange export +SET-ORIENTED-INDEX PASS 1000 logical edges via direct Catalog Exchange (not a performance benchmark) +ADVERSARIAL-FIAM PASS existing semantic rejection suite diff --git a/history/FIAM_v0.2_Draft6/DECLARATION-MATCHING-v0.2.md b/history/FIAM_v0.2_Draft6/DECLARATION-MATCHING-v0.2.md new file mode 100644 index 0000000..90c71d0 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/DECLARATION-MATCHING-v0.2.md @@ -0,0 +1,15 @@ +# FIAM v0.2 — Declaration Matching Contract + +`declared` is not a shortcut for “the runtime target node appears in a `uses` assertion.” It is a time-aware graph query. + +For a runtime logical edge `(from, target, domain, channel?, intended_target?)` at time `T`: + +1. project observed identifiers through the non-destructive working-set mapping effective at `T`; +2. select the latest declared snapshot from each declaration source effective at `T` and applicable to the edge population; +3. resolve declaration subjects/objects to architectural owners where appropriate; +4. consider the runtime target, intended target, and mediating Channel as valid declaration surfaces according to domain; +5. return the matching declaration ids and reasons, not only a boolean. + +A mediated messaging edge may therefore be declared by `Producer --uses--> Channel` even if the runtime topology view also resolves a downstream consumer. A gateway-mediated runtime edge is declared when the intended target is declared even though the observed responder is the gateway. An observed identifier and its preferred declared working-set identity are treated as the same query-time navigation target without merging the source records. + +Ambiguous or absent declarations remain explicit findings. The declaration matcher never creates `same-entity-as` and never changes evidence. diff --git a/history/FIAM_v0.2_Draft6/DECLARED-OBSERVED-LENS-v0.2.md b/history/FIAM_v0.2_Draft6/DECLARED-OBSERVED-LENS-v0.2.md new file mode 100644 index 0000000..ae05c76 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/DECLARED-OBSERVED-LENS-v0.2.md @@ -0,0 +1,94 @@ +# FIAM v0.2 — Declared vs Observed Lens + +## Purpose + +Answer architecture-intelligence questions over one evidence-preserving graph: + +- What was declared? +- What was observed? +- Where do properties agree, refine or conflict? +- Which declared operations/channels have never been observed in the current evidence horizon? +- Which runtime operations are undeclared or ambiguous? +- Who owns the declared side of the finding? + +## Pairing and candidates + +Property comparison uses evidence-backed: + +```text +observed -- corresponds-to --> declared +``` + +Reconciliation also exposes scored candidate lists even when no correspondence is safe. + +This lets the Lens distinguish: + +```text +matched +ambiguous +near-match +unmatched +``` + +instead of treating every failed join as silence. + +## Property comparison + +Current strategies include exact comparison and Canon-hierarchy comparison. + +Example: + +```text +declared: fiam.protocol.http +observed: fiam.protocol.http2 +=> compatible-refinement +``` + +while: + +```text +declared: fiam.protocol.http1.1 +observed: fiam.protocol.http2 +=> conflict +``` + +## Coverage findings + +Coverage is currently evaluated for Operations and Channels. + +Classes: + +| Class | Meaning | +|---|---| +| `observed` | declared entity has a correlated runtime observation | +| `declared-only` | declared entity has no correlated observation in the available evidence | +| `observed-only` | runtime entity has no useful declared candidate | +| `ambiguous` | runtime entity has plausible declared candidates but no safe correspondence | + +`declared-only` does **not** mean unused forever. It means unseen in the current catalog/evidence horizon. + +## Ambiguity example + +The estate-hardening fixture declares two GET `/pets/{id}` operations on different servers, then supplies a runtime span without server identity. + +The Lens emits: + +```text +ambiguous observed operation + candidate A score 0.8 + candidate B score 0.8 +``` + +and no `corresponds-to` assertion. + +## Owner resolution + +Binding/Operation/Endpoint findings resolve through the declared provider Port to its owning SystemNode. Channel and Resource findings may resolve through their owner when present. + +This identifies architectural ownership; organizational team/person ownership remains unknown unless separately supplied. + +## Security + +Security coverage is handled by the separate `fiam.lens.security-coverage` Lens because generic OTLP absence does not prove authentication absence. + +The declared-vs-observed Lens may later compare security when an explicit runtime security evidence source exists. diff --git a/history/FIAM_v0.2_Draft6/EVIDENCE-SCORING-v0.2.md b/history/FIAM_v0.2_Draft6/EVIDENCE-SCORING-v0.2.md new file mode 100644 index 0000000..bd13049 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/EVIDENCE-SCORING-v0.2.md @@ -0,0 +1,85 @@ +# FIAM Evidence Scoring v0.2 + +## Intent + +FIAM preserves evidence records rather than collapsing observations into one current fact. Architecture-intelligence tools still need to rank claims, conflicts, and stale evidence. + +Evidence strength is therefore a **query-time heuristic under an explicit policy**. It is neither a canonical FIAM property nor a calibrated probability of truth. + +## Persistence rule + +The Architecture Intelligence Index stores raw assertion/evidence payloads only. It MUST NOT persist canonical columns such as: + +```text +support_score +challenge_score +net_support +``` + +Every scored result must identify the exact scoring policy id and SHA-256. Re-evaluating the same raw evidence under another policy is a new query interpretation, not an estate change. + +## Inputs + +The reference policy uses existing evidence fields: + +```text +confidence +mode +source type +source ref / locator +stance +observed_at +``` + +## Per-record strength + +Conceptually: + +```text +strength = confidence + * mode_weight + * source_type_weight + * freshness_factor +``` + +Factors are bounded to `[0,1]`. Runtime/inferred evidence may decay for ranking; declared/static evidence has no default freshness decay. Decay never deletes or invalidates historical evidence. + +## Independence + +Repeated evidence from one evidential source must not masquerade as independent corroboration. + +Default independence key: + +```text +mode +source.type +source.ref +source.locator +``` + +The strongest record in each independence group contributes. Independent supports combine via bounded noisy-OR: + +```text +support = 1 - product(1 - strength_i) +``` + +Challenges combine separately. `net_support = support - challenge` is only a ranking convenience. + +## Evidence Health Lens + +`fiam.lens.evidence-health` uses the scoring policy to surface operational questions rather than to rewrite facts: + +- conflicting supported values for one subject/predicate; +- facts with challenging evidence; +- runtime-only claims whose latest evidence is stale; +- low-support claims. + +The reference fixture yields one of each category and includes the policy id/hash in its result. + +## Governance + +Reference policy: + +`policies/EVIDENCE-SCORING-v0.2.yaml` + +Organizations may tune weights and freshness windows. Different policies may legitimately rank the same evidence differently; this is why scores are deliberately excluded from the stored assertion table. diff --git a/history/FIAM_v0.2_Draft6/FIAM-v0.2-Draft6.md b/history/FIAM_v0.2_Draft6/FIAM-v0.2-Draft6.md new file mode 100644 index 0000000..6168f5f --- /dev/null +++ b/history/FIAM_v0.2_Draft6/FIAM-v0.2-Draft6.md @@ -0,0 +1,255 @@ +# FIAM v0.2-draft.6 — Catalog Operations & Policy + +## Status + +FIAM v0.2-draft.6 hardens the **operating contract** around the frozen v0.2 Core. It does not add Core entities or change Core semantics. The focus is authority, exchange, incremental persistence, temporal truth, declaration matching, policy projections, evidence health, and practical estate queries. + +The Core freeze remains intentional: difficult operational cases are first solved in adapters, profiles, policies, indexes, or lenses. A new Core concept should be considered only after those layers demonstrably cannot express the problem. + +## 1. Architectural boundary + +Draft.6 separates four layers explicitly: + +```text +FIAM Core model + stable architectural facts + evidence-bearing assertions + +Catalog Exchange Profile + versioned operational records for incremental/replayable catalog ingestion + +Architecture Intelligence Index + rebuildable temporal/query projection over retained exchange artifacts + +Lenses + Policies + named, versioned interpretations: drift, materiality, compliance, dormancy, + evidence health, security coverage +``` + +The index is never the sole evidence store, and a Lens result is never silently promoted into a Core fact. + +## 2. Authoritative snapshot governance + +Completeness is no longer an ingestion flag. A `complete-snapshot` is accepted only when a validated Snapshot Authority Policy grants a source authority for an exact combination of: + +- source id; +- observation scope; +- architectural population; +- covered domains; +- optional population qualifiers such as environment, cluster, and platform. + +A complete HTTP/RPC snapshot cannot close messaging or database observations merely because those observations occur in the same cluster. A source can close only its own observation scope. + +The reference policy requires both: + +```text +consecutive missing complete snapshots >= absence_snapshots +snapshot_time - last_seen >= grace_hours +``` + +before an observation interval closes. `last_seen` remains evidence time; `closed_at` records the later policy action. A reappearance opens a new interval rather than rewriting history. + +Multiple collectors that observe the same architectural dependency normally use distinct observation scopes. Their active observations are unioned into one logical topology edge. Closing one collector therefore does not close the logical dependency while another still observes it. + +Shared observation-scope ownership is rejected unless a layered policy explicitly defines precedence. In the reference implementation only the highest-precedence source is allowed to make the closing completeness claim for such a layered scope. + +## 3. Catalog Exchange Profile + +The former runtime extension bags are now an explicit, versioned operational interchange profile: + +```text +fiam.catalog-exchange.v0.2 +``` + +The profile carries: + +- Core entities; +- Core assertions/evidence; +- temporal Zone memberships; +- runtime aggregates; +- topology observations; +- unresolved observations; +- reconciliation candidates; +- declaration inventory. + +YAML and JSON remain useful audit/export forms. NDJSON provides a direct streaming write path: + +```text +OTLP / OpenAPI / other adapter + ↓ + Catalog Exchange records + ↓ + persistent FIAM index +``` + +A continuous catalog therefore does **not** need to rewrite an ever-growing FIAM YAML document per batch. The index can export Catalog Exchange checkpoints for inspection, while retained source/exchange history remains the rebuild/audit surface. + +## 4. Observation identity and scope + +Architectural edge identity excludes collector identity. Observation state does not. + +```text +logical edge: Orders -> Inventory + +observation scope A: application traces active/closed independently +observation scope B: service mesh active/closed independently +``` + +The population-level logical edge stays active while at least one valid observation scope remains active. This prevents both duplicate logical dependencies and one platform collector erasing another platform's evidence. + +Deployment-oriented Zone membership is derived from runtime identity tuples where possible: + +```text +environment -> deployment-environment Zone +cluster -> cluster Zone +namespace -> Kubernetes-namespace Zone +``` + +Trust and organization Zones remain declared/governed knowledge unless a separately authoritative source supplies them. + +## 5. Declaration matching as a graph query + +“Declared” is no longer equivalent to “the source node has a direct `uses` relation to the exact runtime target id.” The declaration matcher evaluates the historical graph at the edge timestamp using: + +- non-destructive working-set identity; +- direct target and intended target; +- mediated Channel; +- owner projections; +- domain-appropriate declared relations. + +The included fixtures prove three cases that must **not** create false undeclared findings: + +1. the producer declares the Channel while runtime topology resolves a downstream consumer; +2. the client declares the intended server while runtime traverses a gateway; +3. the declaration uses an observed id while the working-set projection prefers a declared id. + +Ambiguity remains explicit rather than forcing a match. + +## 6. Query-time evidence strength + +Evidence strength remains a Lens heuristic. The persistent assertion table stores raw assertions/evidence only; it has no canonical `support_score`, `challenge_score`, or `net_support` columns. + +Every scored result names: + +```text +policy id +policy SHA-256 +query/evaluation time +``` + +Changing evidence policy therefore changes a query interpretation, not the recorded estate. Duplicate evidence from one independence group does not masquerade as independent corroboration. + +## 7. Policy intelligence + +Draft.6 formalizes the distinction between facts and governance conclusions. + +A newly observed dependency can have factual properties such as: + +```text +undeclared = true +crosses trust boundary = true +crosses organization boundary = true +observation count = 12 +``` + +A named governance policy may then classify it as material or non-compliant. The reference policy assigns the included `Orders -> Partner API` dependency a materiality score of `0.75` (`high`) and reports one high-severity violation because internal-to-partner trust-zone access requires declaration. + +Those are **policy results**, not universal FIAM truth. Another organization can apply different weights/rules to the same evidence without changing the catalog. + +## 8. First operational questions + +The draft.6 reference fixtures now answer the four architecture-control questions that motivated this increment. + +### Which new undeclared dependencies are material? + +Included fixture: + +```text +new dependencies 1 +material dependencies 1 +policy violations 1 +``` + +`Orders -> Partner API` is undeclared and crosses both trust and organizational boundaries, producing reference-policy materiality `0.75 / high`. + +### Which boundary crossings violate intended architecture? + +The Boundary Drift Lens reports the descriptive crossing. The Architecture Policy Lens separately applies the named rule: + +```text +require-declaration-internal-to-partner +severity: high +``` + +and reports the undeclared partner dependency as a violation. + +### Which declared capabilities have been dormant for 90 days? + +The operation-coverage fixture reports: + +```text +observed in window 1 +dormant 1 +never observed 2 +``` + +Dormant means previously observed but not within the evaluation window; never-observed remains distinct. + +### Which facts rely on stale or conflicting evidence? + +The evidence-health fixture reports: + +```text +conflicting facts 1 +challenged facts 1 +stale runtime-only 1 +low support 1 +``` + +Scores are computed from raw evidence under the named evidence policy at query time. + +A separate security-evidence query demonstrates an important open-world case: an operation may have declared authentication requirements and runtime activity while generic telemetry provides **unknown** runtime authentication evidence. Unknown is not converted to “unprotected.” + +## 9. Snapshot and index retention + +Index retention is operational and reversible. Closed intervals, entity versions, assertions, and evidence may be purged from the derived index only through an explicit derived-index purge operation. Such a purge must not modify or delete retained Catalog Exchange/source artifacts. + +Historical queries older than the retained index horizon then require rebuilding from those retained artifacts. This keeps index retention and evidence/audit retention separate. + +## 10. Conformance meaning + +A draft.6 PASS means more than schema compatibility. It verifies: + +- frozen Core hash; +- 26 semantic specimens; +- scoped authority and grace semantics; +- distinct `last_seen` and `closed_at` clocks; +- domain-specific completeness; +- multi-scope union and unauthorized authority rejection; +- Channel/gateway/working-set declaration matching; +- automatic deployment Zone derivation; +- operation dormancy and never-observed coverage; +- security-runtime unknown preservation; +- stale/conflicting evidence findings with policy hash; +- index-native NDJSON ingest, replay idempotency, and Catalog Exchange export; +- derived-index retention safety; +- direct set-oriented Catalog Exchange ingestion; +- existing FIAM semantic adversarial cases. + +The set-oriented test is a conformance smoke test, **not** a performance benchmark. + +## 11. What remains outside the Core + +Draft.6 deliberately does not introduce: + +- Session; +- domain-specific interface entities such as `GrpcInterface`; +- schema fields on `InformationShape`; +- automatic destructive entity merge; +- stored truth probabilities; +- global authoritative snapshots. + +The remaining engineering work is increasingly a catalog/service problem: durable exchange retention, concurrency, operational deployment, broader declared-source adapters, policy administration, and estate-scale query optimization. + +## 12. Recommended next milestone + +The natural next milestone is no longer another FIAM draft driven by ontology. It is a **reference architecture-intelligence service** implementing this operating contract against a durable production-oriented store (for example PostgreSQL), with Catalog Exchange as the ingestion boundary and the existing lenses as an initial query API. diff --git a/history/FIAM_v0.2_Draft6/IDENTITY-RECONCILIATION-v0.2.md b/history/FIAM_v0.2_Draft6/IDENTITY-RECONCILIATION-v0.2.md new file mode 100644 index 0000000..f6f3094 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/IDENTITY-RECONCILIATION-v0.2.md @@ -0,0 +1,71 @@ +# FIAM v0.2 — Identity and Reconciliation Policy + +## Principle + +Discovery must not erase uncertainty. + +FIAM therefore separates: + +```text +correspondence +identity equivalence +working-set preference +physical merge +``` + +These are not synonyms. + +## `corresponds-to` + +`fiam.relation.corresponds-to` means two records plausibly describe the same architectural concern or exposure strongly enough to compare/project together. + +Runtime reconciliation produces this relation only for a strong unique candidate. + +Candidate search may still produce: + +```text +ambiguous +near-match +unmatched +``` + +without asserting correspondence. + +## `same-entity-as` + +This is a stronger identity statement governed by the existing Shape/Entity identity rules. + +An inferred `same-entity-as` requires multiple independent signals at high confidence. A single structural/name fingerprint is insufficient. + +Even `same-entity-as` does not authorize destructive record deletion. + +## Runtime deployed identity + +Runtime SystemNode identity is an architectural deployment tuple, not merely `safe(service.name)`. + +It combines service namespace/name with available deployment/cluster/namespace/cloud context so production and staging observations do not collapse into one node. + +## Working set + +A high-confidence correspondence can produce a declared-preferred working reference for navigation. + +The observed entity remains attached with evidence and is never silently rewritten. + +See `WORKING-SET-v0.2.md`. + +## Reconciliation candidate visibility + +Every adapter should prefer a scored candidate list over silent matching failure. + +Candidate metadata should explain the signals used, such as: + +- service name / namespace; +- protocol/system; +- HTTP method; +- normalized route similarity; +- declared/observed host; +- RPC method; +- messaging destination; +- database namespace/collection. + +Ambiguity is therefore a queryable architecture finding. diff --git a/history/FIAM_v0.2_Draft6/MIGRATION-v0.1.1-to-v0.2.md b/history/FIAM_v0.2_Draft6/MIGRATION-v0.1.1-to-v0.2.md new file mode 100644 index 0000000..666390b --- /dev/null +++ b/history/FIAM_v0.2_Draft6/MIGRATION-v0.1.1-to-v0.2.md @@ -0,0 +1,66 @@ +# FIAM Migration — v0.1.1 to v0.2 + +## Structural additions + +Add `information_resources[]` and `information_shapes[]` when the architecture contains independently meaningful information loci or admissible information forms. + +Do not add them mechanically to every interface. Incomplete models remain valid. + +## InformationShape + +`shape_kind` is required for v0.2 shapes. Use `fiam.information-shape.object` for structured named-member forms; the experimental `record` term is deprecated. + +Keep fine-grained members and constraints in schema/type Artifacts (OpenAPI, JSON Schema, protobuf, GraphQL, DDL, source declarations). FIAM Core identifies and relates the shape; it does not reimplement those schema languages. + +## Representation + +Remove authoritative use of `contracts[].representations` and `contracts[].operations[].representations`. These fields remain parseable only to support migration and produce warnings. + +Attach representation to the most specific shape-participation relation: Operation for a semantic default only when appropriate, Binding for a realization, Interaction for what actually occurred. + +## Shape relations + +Use: + +- `accepts-shape` +- `produces-shape` +- `errors-with-shape` +- `conforms-to-shape` +- `element-shape` +- `embeds-shape` + +Binding-level shape participation on a Binding with multiple operations requires `facets.operation_ref`. + +## Shape composition + +`embeds-shape` and `element-shape` may carry `facets.slot` and `facets.role`. These are coarse architectural anchors, not a replacement for field-level schema definitions. + +## Evidence + +All v0.2 Assertions require evidence. Preserve conflicting/superseded assertions rather than overwriting discovery history. + +## Identity + +Follow `policies/FIAM-ShapeIdentity-v0.2.md`. Prefer `corresponds-to` while two discoveries are only candidate matches. Use `same-entity-as` only with sufficient evidence. Identity assertions do not delete source records. + +## Specimen tests + +v0.2 `tests.expected_properties` are executable checks. Move narrative expectations to `tests.notes`. + +## draft.1 hardening notes + +### Family labels + +Do not manually carry forward `family_labels` as authoritative classifications. Either remove them or back each cached label with an inferred `fiam.property.family-label` assertion produced by a Lens. The validator rejects unproven family-label caches. + +### Shape refinement + +When migrating shape participations, verify Operation → Binding → Interaction refinement. A lower-level Shape must be the same/equivalent Shape or be related by `projection-of` / `version-of` to the parent declaration. + +### Collection coherence + +Collection-like InformationResources that use `conforms-to-shape` should point to a collection Shape. Use a separate `element-shape` relation for member shape. + +### Identity + +Do not convert similarity heuristics into `same-entity-as`. Ingest/reconciliation tools should emit `corresponds-to` until sufficient governed identity evidence exists. Purely inferred `same-entity-as` is rejected unless the current Canon evidence threshold is met. diff --git a/history/FIAM_v0.2_Draft6/Makefile b/history/FIAM_v0.2_Draft6/Makefile new file mode 100644 index 0000000..6494019 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/Makefile @@ -0,0 +1,51 @@ +.PHONY: check estate-check validate specimens exchange authority catalog-example policy-example runtime runtime-multidomain topology lens security reconcile working-set + +check estate-check: + python3 tools/check_all.py + +validate: + python3 tools/validate_fiam.py + +specimens: + python3 tools/validate_fiam.py $$(find specimens -name '*.yaml' | sort) + +authority: + python3 tools/validate_authority_policy.py policies/SNAPSHOT-AUTHORITY-v0.2.yaml + +exchange: + python tools/catalog_exchange.py convert real-world/catalog-exchange/runtime-2026-09-01.yaml -o /tmp/fiam-runtime.ndjson --input-format yaml --format ndjson + +catalog-example: + rm -f /tmp/fiam-estate.sqlite + python tools/catalog_index.py ingest-exchange /tmp/fiam-estate.sqlite real-world/catalog-exchange/declared-2026-09-01.yaml + python tools/catalog_index.py ingest-exchange /tmp/fiam-estate.sqlite real-world/catalog-exchange/runtime-2026-09-01.yaml --authority-policy policies/SNAPSHOT-AUTHORITY-v0.2.yaml + python tools/catalog_index.py ingest-exchange /tmp/fiam-estate.sqlite real-world/catalog-exchange/runtime-2026-09-08.yaml --authority-policy policies/SNAPSHOT-AUTHORITY-v0.2.yaml + python tools/catalog_index.py ingest-exchange /tmp/fiam-estate.sqlite real-world/catalog-exchange/runtime-2026-09-09.yaml --authority-policy policies/SNAPSHOT-AUTHORITY-v0.2.yaml + python tools/architecture_changes_lens.py /tmp/fiam-estate.sqlite --population prod-cluster-a --since 2026-09-07T00:00:00Z --until 2026-09-09T23:59:59Z -o /tmp/fiam-changes.yaml + +policy-example: catalog-example + python tools/architecture_policy_lens.py /tmp/fiam-estate.sqlite --population prod-cluster-a --since 2026-09-07T00:00:00Z --until 2026-09-09T23:59:59Z --policy policies/ARCHITECTURE-GOVERNANCE-v0.2.yaml -o /tmp/fiam-policy.yaml + +runtime: + python tools/otel_to_fiam.py real-world/otel/petstore-get-pet-http2.otlp.json --base real-world/openapi/petstore-identity-excerpt.fiam.yaml -o real-world/composite/petstore-openapi-plus-otel.fiam.yaml + +runtime-multidomain: + python tools/otel_to_fiam.py real-world/otel/multidomain-runtime.otlp.json -o real-world/otel/multidomain-runtime.fiam.yaml + +topology: runtime-multidomain + python tools/runtime_topology_lens.py real-world/otel/multidomain-runtime.fiam.yaml -o real-world/otel/multidomain-runtime.topology.yaml --markdown real-world/otel/multidomain-runtime.topology.md + +lens: + python tools/declared_observed_lens.py real-world/composite/security-api-declared-plus-observed.fiam.yaml -o real-world/composite/security-api-declared-plus-observed.lens.yaml --markdown real-world/composite/security-api-declared-plus-observed.lens.md + +security: + python tools/openapi_to_fiam.py real-world/openapi/estate-hardening/security-api.yaml -o real-world/openapi/estate-hardening/security-api.fiam.yaml + python tools/security_coverage_lens.py real-world/openapi/estate-hardening/security-api.fiam.yaml -o real-world/openapi/estate-hardening/security-api.security-coverage.yaml + +working-set: + python tools/working_set_view.py real-world/composite/gateway-rpc.fiam.yaml -o real-world/composite/gateway-rpc.working-set.yaml + +reconcile: + python tools/otel_to_fiam.py real-world/otel/grpc-runtime.otlp.json --base specimens/regression/04-grpc-bidirectional-stream.yaml -o real-world/composite/grpc-declared-plus-runtime.fiam.yaml + python tools/otel_to_fiam.py real-world/otel/kafka-runtime.otlp.json --base specimens/regression/06-kafka-topic.yaml -o real-world/composite/kafka-declared-plus-runtime.fiam.yaml + python tools/otel_to_fiam.py real-world/otel/postgres-runtime.otlp.json --base specimens/regression/03-shared-postgresql-table.yaml -o real-world/composite/postgres-declared-plus-runtime.fiam.yaml diff --git a/history/FIAM_v0.2_Draft6/OPENAPI-INGEST-v0.2.md b/history/FIAM_v0.2_Draft6/OPENAPI-INGEST-v0.2.md new file mode 100644 index 0000000..ed7c31c --- /dev/null +++ b/history/FIAM_v0.2_Draft6/OPENAPI-INGEST-v0.2.md @@ -0,0 +1,87 @@ +# FIAM v0.2 — OpenAPI Declared-Ingest Profile (draft.4) + +## Intent + +Turn an OpenAPI 3.x description into a FIAM **declared architecture model** while preserving the distinction between architectural entities and the source artifact. + +The importer is architecture-oriented, not a lossless OpenAPI converter. Detailed schema semantics remain in the OpenAPI Artifact. + +## Mapping + +| OpenAPI construct | FIAM expression | +|---|---| +| API document | `Artifact` (`fiam.artifact.api-description`) | +| API/service | `SystemNode` + offered `Port` + `InterfaceContract` | +| path + HTTP method | `Operation` | +| server URL | `Endpoint` | +| HTTP realization | `Binding` + communication stack | +| path template | logical-selection `InformationResource` | +| component or inline schema | `InformationShape` | +| response/request schema | Shape-participation relations | +| media type | relation-scoped `representation` | +| object/array composition | coarse `embeds-shape` / `element-shape` | +| source location | assertion Evidence locator | +| HTTP method | declared property assertion | +| generic HTTP family | declared `communication-protocol` assertion | +| `components.securitySchemes` | FIAM Security profiles | +| top-level / operation `security` | contract/operation Security requirements | + +## Evidence + +Relations and material property facts emitted from OpenAPI carry declared evidence with the source Artifact and JSON-pointer locator. + +Observer: + +```text +openapi-ingest/v0.2-draft.4 +``` + +## Transport conservatism + +An `https://` server URL declares secure HTTP addressing. It does **not** determine TCP versus QUIC, because the OpenAPI document normally does not state the negotiated HTTP version/transport. + +Draft.4 therefore emits: + +```text +HTTP +TLS +``` + +for an HTTPS declaration, but does not infer TCP. + +This preserves the transport-conservative behavior introduced after draft.1. + +## Shape identity + +The importer reuses a FIAM Shape for repeated references to the same OpenAPI component identity. Different components remain distinct even when structurally identical. + +Structural fingerprint equality emits only: + +```text +Shape A --corresponds-to--> Shape B +``` + +never automatic `same-entity-as`. + +## Current scope + +Supported: + +- OpenAPI 3.x YAML/JSON; +- component and common inline Shapes; +- coarse shape composition; +- request/response shape participation; +- common representations; +- server endpoints and HTTP/TLS stack; +- path-template Resources; +- evidence-backed HTTP method and generic protocol facts; +- structural-fingerprint candidate alignment; +- local OpenAPI security schemes and Security Requirement composition (see `OPENAPI-SECURITY-INGEST-v0.2.md`). + +Not yet a goal: + +- lossless parameter/schema conversion; +- complete external `$ref` resolution; +- full callback/webhook flows; +- automatic identity merge; +- schema fields in FIAM Core. diff --git a/history/FIAM_v0.2_Draft6/OPENAPI-SECURITY-INGEST-v0.2.md b/history/FIAM_v0.2_Draft6/OPENAPI-SECURITY-INGEST-v0.2.md new file mode 100644 index 0000000..bed3e3c --- /dev/null +++ b/history/FIAM_v0.2_Draft6/OPENAPI-SECURITY-INGEST-v0.2.md @@ -0,0 +1,90 @@ +# FIAM v0.2 — OpenAPI Security Ingest Profile + +## Purpose + +Map declared OpenAPI security schemes and Security Requirement Objects into FIAM Security profiles without collapsing security into interface-family names. + +## Supported Security Scheme families + +The draft.4 adapter recognizes: + +- `apiKey`; +- `http` Basic; +- `http` Bearer; +- `oauth2`; +- `openIdConnect`; +- `mutualTLS`. + +These map to FIAM authentication/credential terms while preserving the original scheme metadata as facets. + +## Requirement semantics + +The adapter preserves OpenAPI requirement composition. + +Within one Security Requirement Object: + +```text +scheme A + scheme B = both required +``` + +Across multiple Security Requirement Objects: + +```text +requirement 1 OR requirement 2 +``` + +An empty requirement object `{}` represents an anonymous-access alternative. + +Operation-level `security` overrides top-level security. An empty operation list `security: []` removes inherited security for that operation. + +## FIAM profiles + +Top-level requirements create Security profiles applying to the InterfaceContract. + +Operation-level requirements create Security profiles applying to the Operation. + +Profiles retain, where applicable: + +- source scheme name/type; +- alternative number; +- required scopes; +- API-key location/name; +- OAuth flow names; +- OpenID Connect discovery URL; +- credential / transport-security semantics. + +## Effective-security Lens + +`tools/security_coverage_lens.py` evaluates effective declared security per operation. + +Current classes: + +```text +inherited-contract-security +operation-specific +anonymous-access-allowed +explicitly-unprotected +no-declared-security +``` + +The fixture `real-world/openapi/estate-hardening/security-api.yaml` covers the first four classes. + +## Runtime boundary + +Generic HTTP OTLP spans do not establish whether application authentication occurred. + +Therefore the absence of an authentication-specific telemetry signal is **unknown**, not evidence of unprotected access. + +A future runtime security source may enrich these same FIAM Security profiles/assertions; no Core change is implied. + +## Current limitations + +The reference OpenAPI adapter does not yet fully resolve: + +- external `$ref` documents; +- callbacks and webhooks; +- all Server Object variable expansion; +- security schemes declared by external URI rather than local component reference; +- APIs intentionally split across multiple OpenAPI files. + +These are adapter/composition concerns and remain outside the frozen Core. diff --git a/history/FIAM_v0.2_Draft6/OTEL-INGEST-v0.2.md b/history/FIAM_v0.2_Draft6/OTEL-INGEST-v0.2.md new file mode 100644 index 0000000..123ed76 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/OTEL-INGEST-v0.2.md @@ -0,0 +1,145 @@ +# FIAM v0.2 — OpenTelemetry Runtime-Ingest Profile + +## Intent + +Map OpenTelemetry trace observations into an **incremental FIAM architecture catalog** without pretending telemetry is a complete architecture description and without mirroring every span as a permanent architectural Interaction. + +The full estate aggregation and identity rules are normative in `RUNTIME-CATALOG-v0.2.md`. + +## Standards basis + +Draft.4 targets the current OpenTelemetry semantic-convention families used by the reference implementation: + +- service/resource conventions — https://opentelemetry.io/docs/specs/semconv/resource/service/ +- deployment environment — https://opentelemetry.io/docs/specs/semconv/resource/deployment-environment/ +- HTTP spans — https://opentelemetry.io/docs/specs/semconv/http/http-spans/ +- RPC spans — https://opentelemetry.io/docs/specs/semconv/rpc/rpc-spans/ +- gRPC — https://opentelemetry.io/docs/specs/semconv/rpc/grpc/ +- messaging spans — https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/ +- database spans — https://opentelemetry.io/docs/specs/semconv/db/database-spans/ +- Trace API / SpanKind — https://opentelemetry.io/docs/specs/otel/trace/api/ +- OTLP — https://opentelemetry.io/docs/specs/otlp/ + +OTLP/JSON integer enum encoding is enforced for `Span.kind`. + +## Default output model + +```text +many spans + | + v +architectural runtime aggregates + | + +--> stable FIAM Nodes / Ports / Operations / Bindings + +--> Channels or InformationResources when observed + +--> idempotent runtime assertions + +--> bounded Interaction samples + +--> unresolved/candidate findings +``` + +## HTTP server + +| OpenTelemetry | FIAM | +|---|---| +| service identity + deployment context | deployed SystemNode + Zones | +| HTTP `SERVER` span | runtime aggregate + optional sample Interaction | +| method + `http.route` | Operation | +| missing route | `unknown-route` Operation + unresolved finding | +| server address/port | Endpoint | +| actual HTTP version | Binding runtime property | +| `network.peer.*` | competing locator evidence | +| status/error | aggregate error count / sample result | + +Raw `url.path` and raw span names do not become architecture identifiers. + +The adapter does not infer TCP merely from HTTPS/HTTP because lower transport may differ, including with HTTP/3. + +## RPC / gRPC + +RPC client/server observations create required/offered participation and stable runtime aggregates. + +`rpc.system.name` and `rpc.method` provide the primary semantic inputs. For gRPC, the Canon protocol term is used. + +When both sides of a trace are available, parent/child correlation can produce a direct-call topology observation. A client span without its server child remains an unresolved partial dependency instead of inventing a responder. + +`service.peer.name`, `server.address` and network peer attributes are treated as separate evidence signals. + +## Messaging + +OpenTelemetry messaging operation type and SpanKind remain separate. + +Examples: + +```text +create -> producer semantics +send -> producer/client transport semantics +receive -> consumer semantics even when SpanKind = CLIENT +process -> consumer semantics +settle -> control/client semantics +``` + +Destination identity creates/reuses a Channel. Producer/consumer continuation is inferred only when trace/span links support it. + +A producer without a linked downstream span remains a valid Channel observation with an unresolved continuation. + +## Database + +Database spans can create: + +```text +required Port +Binding + Endpoint +InformationResource (namespace and/or collection) +read/write/target relation +``` + +If neither a stable namespace nor collection is supplied, FIAM retains the operation/binding evidence and reports the resource target as unresolved. + +### Privacy boundary + +The adapter deliberately excludes: + +- `db.query.text`; +- `db.query.parameter.*`; +- raw span names. + +Architecture discovery should not silently become a copy of application data or sensitive query material. + +## Incremental behavior + +```bash +python tools/otel_to_fiam.py new-batch.json \ + --base estate-catalog.yaml \ + --source-url estate://collector/traces \ + -o estate-catalog-next.yaml +``` + +Exact replay of a processed batch is byte-idempotent. New batches update aggregate counts and validity timestamps. For continuous operation, the preferred path is OTLP → architectural aggregation → Catalog Exchange/NDJSON → persistent index rather than repeatedly rewriting a whole FIAM YAML model. + +Ordinary sampled batches never retract architecture. In draft.6 the OTEL-to-model adapter does not accept a naked completeness switch. Absence/closure is handled only after conversion to Catalog Exchange and validation against `policies/SNAPSHOT-AUTHORITY-v0.2.yaml`, where source, observation scope, population, domains, grace, and repeated absence are explicit. + +## Reconciliation + +With a declared base, the adapter produces scored reconciliation candidates. + +HTTP candidate signals include: + +- method; +- exact/normalized/near route; +- server address. + +Other domains use protocol/system, method/operation, destination/resource and service/locator evidence appropriate to the domain. + +A result is one of: + +```text +matched | ambiguous | near-match | unmatched +``` + +Only a strong unique result generates `corresponds-to`. + +## Gateway/mesh interpretation + +Logical destination evidence is not automatically replaced by actual network-peer or responder evidence. + +The topology layer can retain both and mark a runtime edge as gateway-mediated when the observed responder differs from the reconciled declared target. diff --git a/history/FIAM_v0.2_Draft6/POLICY-INTELLIGENCE-LENSES-v0.2.md b/history/FIAM_v0.2_Draft6/POLICY-INTELLIGENCE-LENSES-v0.2.md new file mode 100644 index 0000000..253fc38 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/POLICY-INTELLIGENCE-LENSES-v0.2.md @@ -0,0 +1,46 @@ +# FIAM v0.2 — Policy Intelligence Lenses + +These lenses deliberately separate **architectural facts** from **organizational decisions**. + +## Materiality + +A new dependency is not intrinsically “material.” The reference policy scores independent facts such as: + +- undeclared status; +- trust-boundary crossing; +- organizational-boundary crossing; +- observation volume; +- independent observation-scope corroboration. + +The result names the governance policy id and hash. Changing policy changes the decision projection, not FIAM history. + +## Intended-boundary compliance + +Boundary policy rules may forbid a Zone pair or require a declaration for that pair. The Lens evaluates the actual historical Zone memberships effective when the edge appeared. + +A rule violation is a policy finding, never a replacement for the underlying Boundary Drift fact. + +## Dormancy + +Operation Coverage compares the latest effective declaration against runtime aggregate `last_seen` within a chosen window: + +- `observed-in-window`; +- `dormant` — observed historically, not in the window; +- `never-observed`. + +Dormancy does not prove that a capability is unused if the runtime observation population is incomplete. + +## Evidence health + +Evidence Health evaluates raw evidence at query time with a named scoring policy. It reports: + +- competing supported values for one subject/predicate; +- challenged assertions; +- runtime-backed facts whose latest runtime evidence is stale; +- low-support facts. + +Scores are not persisted as estate facts. + +## Security evidence coverage + +Declared authentication can coexist with runtime security evidence `unknown`. Generic OTLP is not interpreted as proof that authentication is absent. The Lens makes that coverage gap visible without inventing an unprotected state. diff --git a/history/FIAM_v0.2_Draft6/README.md b/history/FIAM_v0.2_Draft6/README.md new file mode 100644 index 0000000..43e760f --- /dev/null +++ b/history/FIAM_v0.2_Draft6/README.md @@ -0,0 +1,101 @@ +# FIAM v0.2-draft.6 — Catalog Operations & Policy + +Implementation draft of the **Faceted Interface Architecture Model** focused on safe continuous catalog operation and architecture-control queries. + +`fiam_version` remains `0.2`. **The Core is frozen and byte-identical to the v0.2 draft baseline.** Draft.6 changes profiles, policies, index semantics, adapters, and lenses—not Core entities. + +## What draft.6 adds + +- scoped Snapshot Authority Policy: source + observation scope + population + domain; +- repeated-absence + grace closure, with `last_seen` distinct from `closed_at`; +- multi-scope observation union into one logical architectural edge; +- versioned **Catalog Exchange Profile** for YAML/JSON/NDJSON operational interchange; +- direct index-native Catalog Exchange ingest/export; whole-model YAML is no longer the operational write-ahead log; +- raw-evidence persistence with query-time scoring policy id/hash; +- generic declaration matching across Channel mediation, gateways, and working-set identities; +- automatic deployment environment/cluster/namespace Zone derivation from runtime identity tuples; +- Architecture Policy Lens for materiality and boundary-governance rules; +- Operation Coverage Lens for observed/dormant/never-observed declarations; +- Evidence Health Lens for conflict, challenge, staleness, and weak evidence; +- Security Evidence Coverage Lens that preserves runtime authentication **unknown**; +- explicit derived-index retention/purge contract. + +## Main documents + +- `FIAM-v0.2-Draft6.md` — design/status memo and operational decisions. +- `SNAPSHOT-AUTHORITY-v0.2.md` — completeness authority, overlap, clocks, and grace. +- `CATALOG-EXCHANGE-PROFILE-v0.2.md` — versioned operational exchange contract. +- `ARCHITECTURE-INTELLIGENCE-INDEX-v0.2.md` — derived persistent query plane. +- `DECLARATION-MATCHING-v0.2.md` — historical declaration matching semantics. +- `POLICY-INTELLIGENCE-LENSES-v0.2.md` — materiality, compliance, coverage, evidence health. +- `EVIDENCE-SCORING-v0.2.md` — query-time evidence-strength policy. +- `TEMPORAL-QUERY-LENSES-v0.2.md` — architecture change and boundary drift. +- `RUNTIME-CATALOG-v0.2.md` — aggregate/runtime catalog write path. +- `WORKING-SET-v0.2.md` — non-destructive preferred-id projection. +- `SEMANTIC-REGRESSION.md` — executable guarantees. + +## Repository structure + +```text +canon/ controlled vocabulary + semantic policies +schemas/ frozen Core plus profile/policy/result schemas +lenses/ executable Lens definitions +policies/ authority, evidence, governance, Core freeze, shape identity +specimens/ semantic regression corpus +real-world/ ingest, authority, declaration, catalog, and query fixtures +tools/ adapters, exchange/index tools, validators, lenses, harness +history/ previous draft memos +``` + +## Run conformance + +```bash +make check +``` + +The checked result is `CONFORMANCE.txt`. The current reference run completes in roughly tens of seconds; the set-oriented fixture is a correctness smoke test, not a performance benchmark. + +## Operational Catalog Exchange example + +```bash +python tools/catalog_index.py ingest-exchange estate.sqlite \ + real-world/catalog-exchange/runtime-2026-09-01.yaml \ + --authority-policy policies/SNAPSHOT-AUTHORITY-v0.2.yaml + +python tools/catalog_index.py ingest-exchange estate.sqlite \ + real-world/catalog-exchange/runtime-2026-09-08.yaml \ + --authority-policy policies/SNAPSHOT-AUTHORITY-v0.2.yaml + +python tools/architecture_changes_lens.py estate.sqlite \ + --population prod-cluster-a \ + --since 2026-09-07T00:00:00Z --until 2026-09-09T23:59:59Z \ + -o changes.yaml +``` + +Incremental feeds do not need completeness authority. A `complete-snapshot` is accepted only when its source/scope/population/domains are granted by the authority policy. + +## Direct NDJSON path + +```bash +python tools/catalog_exchange.py convert input.yaml -o stream.ndjson \ + --input-format yaml --format ndjson + +python tools/catalog_index.py ingest-exchange estate.sqlite stream.ndjson \ + --format ndjson --authority-policy policies/SNAPSHOT-AUTHORITY-v0.2.yaml +``` + +## Reference architecture-control outputs + +`real-world/catalog-operations/` contains reproducible outputs for: + +- appeared/disappeared/newly-undeclared dependencies; +- trust/organization boundary drift; +- policy materiality and violation; +- 90-day operation dormancy/never-observed coverage; +- security runtime-evidence unknown; +- evidence conflict/challenge/staleness; +- Catalog Exchange export. + +## Design posture + +FIAM Core facts, Catalog Exchange records, index projections, and policy findings are deliberately separate. Do not add Core entities because an operational query is difficult. First ask whether the missing capability belongs to authority, exchange, indexing, reconciliation, evidence policy, Zone derivation, or a Lens. diff --git a/history/FIAM_v0.2_Draft6/RUNTIME-CATALOG-v0.2.md b/history/FIAM_v0.2_Draft6/RUNTIME-CATALOG-v0.2.md new file mode 100644 index 0000000..f94da0a --- /dev/null +++ b/history/FIAM_v0.2_Draft6/RUNTIME-CATALOG-v0.2.md @@ -0,0 +1,47 @@ +# FIAM v0.2 — Runtime Catalog Profile + +The runtime catalog stores architectural aggregates, not a trace warehouse. + +## Write path + +Preferred continuous path: + +```text +OTLP / runtime source + -> low-cardinality architectural aggregation + -> Catalog Exchange v0.2 records + -> persistent query index +``` + +Whole-model FIAM YAML remains an export/audit form and is not required for every batch. + +## Identity + +Runtime identity remains tuple-based and deployment-scoped. Raw paths/span names/query text are excluded from persistent identifiers. + +Environment, cluster and Kubernetes namespace in the identity tuple produce derived Zone memberships in Catalog Exchange. Trust and organization Zones remain declared unless supplied by another authoritative source. + +## Aggregation + +Architectural aggregate tuple: + +```text +(domain, role, operation, binding, local-node, + remote-node?, channel?, information-resource?) +``` + +Aggregate records carry count/error_count/first_seen/last_seen and bounded evidence samples. Catalog Exchange declares whether aggregate counters are `cumulative` or `delta`. + +## Completeness + +Ordinary runtime batches are `incremental`. They never close absence. + +A `complete-snapshot` is valid only when its source has an explicit Snapshot Authority grant for the exact observation scope, population and domains. Closure follows grace and repeated-absence rules from `SNAPSHOT-AUTHORITY-v0.2.md`. + +## Multi-source coverage + +Different collectors covering one population use different observation scopes. The query index unions their observations into one logical architectural topology. Duplicate collector coverage therefore does not require duplicate Core entities and one collector cannot retract another collector's evidence. + +## Privacy + +The architecture catalog excludes raw query text/parameters, raw high-cardinality HTTP paths and raw span names. Occurrence systems remain the place to retrieve detailed telemetry under their own retention/access policy. diff --git a/history/FIAM_v0.2_Draft6/RUNTIME-TOPOLOGY-LENS-v0.2.md b/history/FIAM_v0.2_Draft6/RUNTIME-TOPOLOGY-LENS-v0.2.md new file mode 100644 index 0000000..682fb35 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/RUNTIME-TOPOLOGY-LENS-v0.2.md @@ -0,0 +1,79 @@ +# FIAM v0.2 — Runtime Topology Lens + +## Purpose + +`fiam.lens.runtime-topology` projects **aggregated runtime observations** into architecture dependency edges while preserving different interaction mechanisms. + +It does not require FIAM to retain every source span as an Interaction. + +## RPC + +When client/server trace evidence can be correlated: + +```text +client SystemNode -> server SystemNode +``` + +If only one side is sampled, the partial dependency remains in the runtime catalog's unresolved findings rather than inventing an edge. + +## Messaging + +Span-link causality creates: + +```text +producer SystemNode -> Channel -> consumer SystemNode +``` + +The Channel is not flattened into a direct service dependency. + +A producer without a linked consumer still establishes production to the Channel, but downstream topology remains partial. + +## Database + +Database runtime aggregates and `reads-from` / `writes-to` / `targets` evidence project as: + +```text +application SystemNode -> InformationResource +``` + +## Working-set projection + +By default the Lens uses the non-destructive working-set view: + +- a high-confidence observed->declared correspondence may display the declared id as preferred; +- the observed id is retained in the result; +- ambiguous mappings stay separate. + +## Gateways and meshes + +A reconciled intended target and an observed responder can coexist. + +Example result: + +```text +from: declared-client +to: observed-istio-proxy +via_gateway: true +gateway: observed-istio-proxy +intended_target: declared-server +``` + +This distinguishes deployment intermediaries from application ownership. + +## Unresolved is not failure + +The Lens result contains an unresolved section. Real sampled topology is expected to have unresolved observations. + +The complete multi-domain fixture happens to resolve all five deterministic edges, but the estate conformance suite separately requires partial RPC, messaging, DB and HTTP cases to remain unresolved. + +## Multi-domain proof + +The deterministic fixture yields: + +```text +RPC direct-call: 1 +broker-mediated messaging: 2 +database resource access: 2 +``` + +All three are projected from one unchanged FIAM Core. diff --git a/history/FIAM_v0.2_Draft6/SEMANTIC-REGRESSION.md b/history/FIAM_v0.2_Draft6/SEMANTIC-REGRESSION.md new file mode 100644 index 0000000..5b2c092 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/SEMANTIC-REGRESSION.md @@ -0,0 +1,115 @@ +# FIAM v0.2-draft.6 Semantic and Operational Regression + +## Core guarantee + +`schemas/FIAM-Core-v0.2.schema.json` remains byte-identical to the frozen v0.2 Core. Draft.6 changes no Core entities. + +## Semantic baseline + +The harness retains the complete 26-specimen positive corpus and the existing adversarial suite. It continues to enforce Resource/Shape separation, evidence-backed relations, participation refinement, non-destructive identity, and the v0.2 Canon semantics. + +## Snapshot authority regression + +A complete runtime snapshot is valid only when a Snapshot Authority Policy grants its source the exact observation scope/population/domain claim. + +The reference history proves: + +```text +Sep 01 Inventory observed +Sep 08 Inventory absent in complete snapshot #1 -> remains active +Sep 09 Inventory absent in complete snapshot #2 + and grace exceeded -> observation closes +Sep 10 Inventory observed again -> new interval opens +``` + +The closed interval preserves: + +```text +last_seen = 2026-09-01 # evidence clock +closed_at = 2026-09-09 # policy-action clock +``` + +A complete HTTP-only snapshot must not advance absence/closure state for an RPC edge. + +## Multi-scope regression + +Application traces and service mesh observe the same logical Orders → Inventory dependency through separate observation scopes. Closing the application-trace observation must leave the logical dependency active while the mesh observation remains active. + +A source attempting to claim another source's authoritative observation scope must be rejected. + +## Declaration-matching regression + +The harness verifies that runtime dependencies are treated as declared when declaration is expressed through: + +1. the mediating Channel; +2. an intended server reached through a gateway; +3. an observed identity whose working-set projection prefers the declared identity. + +None of these cases may be reported as newly undeclared. + +## Zone derivation regression + +A runtime identity tuple containing environment, cluster, and Kubernetes namespace must automatically produce the corresponding deployment Zone memberships. Trust and organization Zones are intentionally not inferred from those technical identifiers. + +## Policy intelligence regression + +The September estate fixture must produce: + +```text +new dependencies 1 +material dependencies 1 +policy violations 1 +``` + +The undeclared internal → partner dependency must classify as `high` materiality (`0.75`) under the named governance policy and violate the `require-declaration-internal-to-partner` rule. + +## Coverage regression + +For the included 90-day operation window: + +```text +observed-in-window 1 +dormant 1 +never-observed 2 +``` + +Security evidence coverage must preserve one observed operation with runtime authentication evidence classified as `unknown`, not “unprotected.” + +## Evidence-health regression + +Raw evidence is persisted without policy scores. Query-time evaluation under the named scoring policy must report exactly: + +```text +conflicts 1 +challenged 1 +stale runtime-only 1 +low support 1 +``` + +The result must include the evidence-scoring policy id and SHA-256. + +## Catalog Exchange regression + +Catalog Exchange fixtures must validate against `FIAM-CatalogExchange-v0.2.schema.json`. + +NDJSON must support: + +```text +direct index ingest +exact replay -> already indexed +Catalog Exchange export +``` + +without requiring a whole-model YAML rewrite. + +## Retention regression + +An explicit derived-index purge may remove old index rows, but it must not mutate the source Catalog Exchange artifact used to rebuild those rows. + +## Set-oriented persistence smoke test + +The harness directly generates a 1,000-edge Catalog Exchange document and requires the index to expose 1,000 active logical topology edges. This is a correctness/conformance smoke test, **not** a throughput benchmark. + +## Meaning of PASS + +A green draft.6 run means the frozen Core can be operated through a governed, replayable catalog contract without letting completeness authority, collector overlap, identity projection, evidence scoring, or policy interpretation silently rewrite architectural history. diff --git a/history/FIAM_v0.2_Draft6/SNAPSHOT-AUTHORITY-v0.2.md b/history/FIAM_v0.2_Draft6/SNAPSHOT-AUTHORITY-v0.2.md new file mode 100644 index 0000000..8cd5c15 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/SNAPSHOT-AUTHORITY-v0.2.md @@ -0,0 +1,45 @@ +# FIAM v0.2 — Authoritative Snapshot Governance + +## Safety rule + +An authoritative snapshot is a claim of **completeness for a named observation population, observation scope, and domain set**. It is never global and it is never inferred from a CLI flag alone. + +Every complete snapshot MUST identify: + +- `source_id` — the authority making the completeness claim; +- `observation_scope` — the stream whose absence state it owns; +- `population_id` and population qualifiers such as environment/cluster/platform; +- `domains` covered (`http`, `rpc`, `messaging`, `database`); +- `snapshot_time`; +- grace parameters or a reference to the authority policy. + +A source may close only observations previously written in its own `observation_scope` and only for the domains named in the completeness claim. A complete HTTP/RPC snapshot cannot close Kafka observations merely because they share the same cluster. + +## Overlap + +Multiple collectors may cover the same architectural population. They MUST use distinct observation scopes unless an authority policy explicitly defines a layered precedence for one shared scope. + +Query-time topology unions active observations across scopes into one logical architectural edge. Closing one scope therefore does not make the logical edge disappear while another scope still observes it. + +Two authoritative sources attempting to own the same observation scope without an explicit layered rule MUST be rejected. + +## Clocks and grace + +`last_seen` is evidence time. `closed_at` is policy-action time. They are not interchangeable. + +A missing edge is closed only when both conditions hold: + +1. it has been absent from at least `absence_snapshots` consecutive complete snapshots for that scope/domain; and +2. `snapshot_time - last_seen >= grace_hours`. + +Until then, the observation remains active with an increasing `absence_streak`. + +A later reappearance opens a new observation interval and does not rewrite the closed interval. + +## Default posture + +Incremental ingestion is the default. Authoritative completeness MUST be declared through a validated authority profile; examples and wrappers SHOULD NOT expose a naked `--authoritative` switch as a normal operating path. + +## Layered shared scopes + +The preferred v0.2 operating model is one owner per `observation_scope`. If multiple sources are explicitly configured for one layered scope, the authority policy MUST provide precedence. The reference index permits closing completeness claims only from the highest-precedence source; lower-precedence sources must not independently retract that shared scope. This is intentionally stricter than silently unioning two sources under one scope. diff --git a/history/FIAM_v0.2_Draft6/TEMPORAL-QUERY-LENSES-v0.2.md b/history/FIAM_v0.2_Draft6/TEMPORAL-QUERY-LENSES-v0.2.md new file mode 100644 index 0000000..dbba524 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/TEMPORAL-QUERY-LENSES-v0.2.md @@ -0,0 +1,89 @@ +# FIAM Temporal Query Lenses v0.2 + +## Observation time model + +Temporal findings operate on **population-level logical topology intervals** derived from one or more scope-owned observation intervals. + +Three clocks/contexts must remain distinct: + +```text +first_seen / last_seen observed evidence time +snapshot_time completeness-evaluation time for one observation scope +closed_at policy-action time that closes one scope-owned interval +``` + +A missing incremental/sampled observation has no closing force. A complete snapshot may close only observations owned by its validated authority scope/domain, and only after the configured absence count plus grace period. + +The logical architectural edge closes only when no covering observation scope remains active. + +## Architecture Changes Lens + +`fiam.lens.architecture-changes` operates over logical topology intervals for a named architectural population. + +For `[since, until]` it returns: + +### appeared + +Logical intervals whose `valid_from` falls inside the window. + +### disappeared + +Logical intervals whose `valid_until` falls inside the window. Disappearance therefore represents governed absence, not simple sampling omission. + +### newly-undeclared + +Appeared dependencies for which the historical declaration matcher finds no satisfying declaration at the appearance time. + +The matcher accounts for working-set identity, Channel mediation, intended targets/gateways, owners, and domain-appropriate declaration relations. + +## Boundary Drift Lens + +`fiam.lens.boundary-drift` evaluates Zone memberships effective at edge appearance time. + +Default monitored Zone types include: + +```text +trust-zone +organization +deployment-environment +cluster +``` + +A crossing is reported only when both sides have known membership for the monitored type and the memberships differ. Unknown Zone evidence remains unknown. + +The crossing itself is descriptive. Policy compliance belongs to `fiam.lens.architecture-policy`. + +## Example + +Reference history: + +```text +Sep 01 Orders -> Inventory + declared, internal trust/org + +Sep 08 Orders -> Partner API appears + Inventory first missing complete snapshot (not yet closed) + +Sep 09 Inventory second missing snapshot + grace -> closes + Partner remains active +``` + +Result for Sep 7–9: + +```text +appeared 1 + Orders -> Partner API + +disappeared 1 + Orders -> Inventory + +newly undeclared 1 + Orders -> Partner API + +new trust crossings 1 +new org crossings 1 +``` + +## Temporal integrity + +Declarations, Zone membership, entity ownership, and working identity are interpreted **as of the historical event time**. Later declarations or Zone moves must not retroactively make an old dependency declared or alter which boundary it crossed. diff --git a/history/FIAM_v0.2_Draft6/WORKING-SET-v0.2.md b/history/FIAM_v0.2_Draft6/WORKING-SET-v0.2.md new file mode 100644 index 0000000..22b3814 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/WORKING-SET-v0.2.md @@ -0,0 +1,88 @@ +# FIAM v0.2 — Non-Destructive Working-Set Projection + +## Problem + +Evidence-preserving discovery intentionally creates separate declared and observed records: + +```text +declared service +observed service +``` + +`corresponds-to` must not destroy either record, but forcing every operator and every Lens to manually choose between the two makes conservative identity unusable. + +## Working-set rule + +`tools/working_set_view.py` creates a projection, not a merge. + +For a high-confidence, unique: + +```text +observed --corresponds-to--> declared +``` + +the working set may choose the declared reference as the preferred navigation identity. + +The projection records: + +- observed reference; +- preferred declared reference; +- correspondence confidence; +- assertion id; +- `merged: false`. + +## Non-destructive semantics + +The projection does not: + +- rewrite source ids; +- delete observed entities; +- assert `same-entity-as`; +- discard evidence; +- collapse ambiguous candidates. + +It is therefore safe to rebuild at any time from the evidence graph. + +## Ambiguity + +When multiple candidates are too close, or correspondence confidence is below the threshold, no preferred id is chosen. + +The ambiguity remains visible to query/lens consumers. + +## Use in topology + +The Runtime Topology Lens uses the working-set projection by default. + +Example: + +```text +observed client -> observed istio-proxy + | | + | corresponds | runtime responder + v v + declared client gateway/proxy + | + +---------- intended target ----------> declared server +``` + +Output can therefore report: + +```text +from: declared-client +observed_from: observed-client +to: observed-proxy +via_gateway: true +intended_target: declared-server +``` + +This yields a usable architecture view without pretending the proxy and target are the same entity. + +## Relationship to identity equivalence + +`same-entity-as` remains a stronger identity assertion governed by the FIAM identity policy. + +The working set does not need it. High-confidence correspondence is sufficient for **navigation preference**, not for ontological identity. + +## Declaration matching + +The working-set projection is also used by the draft.6 declaration matcher. A declaration attached to an observed identity or a declared preferred identity can satisfy the same historical dependency after non-destructive projection. The underlying ids and `corresponds-to` / `same-entity-as` evidence remain intact; the matcher does not merge records. diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/01-deprecated-record.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/01-deprecated-record.yaml new file mode 100644 index 0000000..15ada08 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/01-deprecated-record.yaml @@ -0,0 +1,14 @@ +fiam_version: '0.2' +instance: + id: adversarial.deprecated-record + kind: specimen + title: Deprecated record kind + status: provisional +tests: + expected_properties: + - id: check.base + kind: no-deprecated-terms +information_shapes: +- id: shape.bad + kind: information-shape + shape_kind: fiam.information-shape.record diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/02-missing-shape-kind.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/02-missing-shape-kind.yaml new file mode 100644 index 0000000..5f46a3a --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/02-missing-shape-kind.yaml @@ -0,0 +1,13 @@ +fiam_version: '0.2' +instance: + id: adversarial.missing-shape-kind + kind: specimen + title: Missing required shape kind + status: provisional +tests: + expected_properties: + - id: check.base + kind: no-deprecated-terms +information_shapes: +- id: shape.bad + kind: information-shape diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/03-cross-kind-same-entity.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/03-cross-kind-same-entity.yaml new file mode 100644 index 0000000..0bc6843 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/03-cross-kind-same-entity.yaml @@ -0,0 +1,29 @@ +fiam_version: '0.2' +instance: + id: adversarial.cross-kind-identity + kind: specimen + title: same-entity-as across kinds + status: provisional +tests: + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence +nodes: +- id: node.a + kind: system-node + node_type: fiam.node-type.application +information_shapes: +- id: shape.a + kind: information-shape + shape_kind: fiam.information-shape.object +assertions: +- id: assertion.bad + assertion_kind: relation + subject: node.a + predicate: fiam.relation.same-entity-as + polarity: asserted + object_ref: shape.a + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/04-invalid-embed-facet.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/04-invalid-embed-facet.yaml new file mode 100644 index 0000000..5569e25 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/04-invalid-embed-facet.yaml @@ -0,0 +1,30 @@ +fiam_version: '0.2' +instance: + id: adversarial.invalid-embed-facet + kind: specimen + title: Invalid embed facet + status: provisional +tests: + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence +information_shapes: +- id: shape.a + kind: information-shape + shape_kind: fiam.information-shape.envelope +- id: shape.b + kind: information-shape + shape_kind: fiam.information-shape.object +assertions: +- id: assertion.bad + assertion_kind: relation + subject: shape.a + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.b + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + representation: fiam.representation.json diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/05-ambiguous-binding-shape.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/05-ambiguous-binding-shape.yaml new file mode 100644 index 0000000..bc8e3d3 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/05-ambiguous-binding-shape.yaml @@ -0,0 +1,50 @@ +fiam_version: '0.2' +instance: + id: adversarial.ambiguous-binding-shape + kind: specimen + title: Ambiguous binding shape participation + status: provisional +tests: + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence +nodes: +- id: node.s + kind: system-node + node_type: fiam.node-type.service +ports: +- id: port.s + owner: node.s + participations: + - contract: contract.c + mode: offers +contracts: +- id: contract.c + kind: interface-contract + operations: + - id: operation.a + - id: operation.b +bindings: +- id: binding.c + contract: contract.c + provider_port: port.s + operations: + - operation.a + - operation.b +information_shapes: +- id: shape.a + kind: information-shape + shape_kind: fiam.information-shape.object +assertions: +- id: assertion.bad + assertion_kind: relation + subject: binding.c + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.a + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + representation: fiam.representation.json diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/06-missing-evidence.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/06-missing-evidence.yaml new file mode 100644 index 0000000..8c28475 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/06-missing-evidence.yaml @@ -0,0 +1,21 @@ +fiam_version: '0.2' +instance: + id: adversarial.missing-evidence + kind: specimen + title: Assertion without evidence + status: provisional +tests: + expected_properties: + - id: check.base + kind: no-deprecated-terms +nodes: +- id: node.a + kind: system-node + node_type: fiam.node-type.application +assertions: +- id: assertion.bad + assertion_kind: property + subject: node.a + predicate: fiam.property.network-required + polarity: asserted + value: false diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/07-legacy-operation-representation.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/07-legacy-operation-representation.yaml new file mode 100644 index 0000000..5ba25d5 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/07-legacy-operation-representation.yaml @@ -0,0 +1,17 @@ +fiam_version: '0.2' +instance: + id: adversarial.legacy-operation-representation + kind: specimen + title: Legacy operation representation + status: provisional +tests: + expected_properties: + - id: check.base + kind: no-deprecated-terms +contracts: +- id: contract.c + kind: interface-contract + operations: + - id: operation.a + representations: + - fiam.representation.json diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/08-inline-shape-fields.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/08-inline-shape-fields.yaml new file mode 100644 index 0000000..639d21d --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/08-inline-shape-fields.yaml @@ -0,0 +1,16 @@ +fiam_version: '0.2' +instance: + id: adversarial.inline-shape-fields + kind: specimen + title: Inline fields on InformationShape + status: provisional +tests: + expected_properties: + - id: check.base + kind: no-deprecated-terms +information_shapes: +- id: shape.bad + kind: information-shape + shape_kind: fiam.information-shape.object + fields: + - name: x diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/09-unexplained-operation-binding-mismatch.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/09-unexplained-operation-binding-mismatch.yaml new file mode 100644 index 0000000..252b456 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/09-unexplained-operation-binding-mismatch.yaml @@ -0,0 +1,43 @@ +fiam_version: '0.2' +instance: + id: adversarial.operation-binding-mismatch + kind: specimen + title: Unexplained operation/binding mismatch + status: provisional +nodes: +- id: node.s + kind: system-node + node_type: fiam.node-type.service +ports: +- id: port.s.a + owner: node.s + participations: + - contract: contract.a + mode: offers +- id: port.s.b + owner: node.s + participations: + - contract: contract.b + mode: offers +contracts: +- id: contract.a + kind: interface-contract + operations: + - id: operation.a +- id: contract.b + kind: interface-contract + operations: + - id: operation.b +bindings: +- id: binding.a + contract: contract.a + provider_port: port.s.a +interactions: +- id: interaction.bad + kind: interaction + operation: operation.b + binding: binding.a +tests: + expected_properties: + - id: check.base + kind: no-deprecated-terms diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/10-collection-conforms-object.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/10-collection-conforms-object.yaml new file mode 100644 index 0000000..bc163fa --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/10-collection-conforms-object.yaml @@ -0,0 +1,252 @@ +fiam_version: '0.2' +instance: + id: adversarial.collection-conforms-object + kind: model + title: Kubernetes Pod collection and object + status: provisional + intent: Test API resource collection/object modeling while keeping representation kind/schema distinct from resource identity. +nodes: +- id: node.kubectl + kind: system-node + name: kubectl / API client + node_type: fiam.node-type.application +- id: node.apiserver + kind: system-node + name: Kubernetes API Server + node_type: fiam.node-type.service +ports: +- id: port.apiserver.api + owner: node.apiserver + participations: + - contract: contract.k8s-api + mode: offers +- id: port.kubectl.api + owner: node.kubectl + participations: + - contract: contract.k8s-api + mode: requires +contracts: +- id: contract.k8s-api + kind: interface-contract + purpose: + - fiam.purpose.transactional-data-access + - fiam.purpose.mutation + operations: + - id: operation.k8s.list-pods + name: list pods + effect: fiam.effect.read + - id: operation.k8s.watch-pods + name: watch pods + interaction_style: fiam.interaction-style.subscribe + - id: operation.k8s.patch-pod + name: patch pod + effect: fiam.effect.write +endpoints: +- id: endpoint.apiserver + kind: endpoint + address: https://cluster.example.invalid + address_scheme: fiam.address-scheme.https-url +bindings: +- id: binding.k8s-api + contract: contract.k8s-api + provider_port: port.apiserver.api + consumer_ports: + - port.kubectl.api + endpoints: + - endpoint.apiserver + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls +information_resources: +- id: resource.k8s.default-pods + kind: information-resource + name: default namespace Pods collection + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.concrete-collection + owner: node.apiserver + selectors: + - kind: fiam.resource-selector.kubernetes-resource-path + value: /api/v1/namespaces/default/pods + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +- id: resource.k8s.pod.demo + kind: information-resource + name: Pod default/demo + resource_kind: fiam.information-resource.api-resource-object + resource_scope: fiam.resource-scope.concrete-instance + owner: node.apiserver + selectors: + - kind: fiam.resource-selector.kubernetes-object-ref + value: + apiVersion: v1 + kind: Pod + namespace: default + name: demo + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +interactions: +- id: interaction.k8s.list + kind: interaction + operation: operation.k8s.list-pods + binding: binding.k8s-api +- id: interaction.k8s.watch + kind: interaction + operation: operation.k8s.watch-pods + binding: binding.k8s-api + temporal_semantics: fiam.temporal.asynchronous +- id: interaction.k8s.patch + kind: interaction + operation: operation.k8s.patch-pod + binding: binding.k8s-api +assertions: +- id: assertion.pod.in-collection + assertion_kind: relation + subject: resource.k8s.pod.demo + predicate: fiam.relation.contained-in + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.list.reads + assertion_kind: relation + subject: interaction.k8s.list + predicate: fiam.relation.reads-from + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.watch.watches + assertion_kind: relation + subject: interaction.k8s.watch + predicate: fiam.relation.watches + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.patch.writes + assertion_kind: relation + subject: interaction.k8s.patch + predicate: fiam.relation.writes-to + polarity: asserted + object_ref: resource.k8s.pod.demo + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.k8s.collection-conforms + assertion_kind: relation + subject: resource.k8s.default-pods + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.k8s.collection-element + assertion_kind: relation + subject: resource.k8s.default-pods + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.element + slot: items +- id: assertion.k8s.listshape-element + assertion_kind: relation + subject: shape.k8s.pod-list + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.element + slot: items +- id: assertion.k8s.object-conforms + assertion_kind: relation + subject: resource.k8s.pod.demo + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.k8s.list-produces + assertion_kind: relation + subject: operation.k8s.list-pods + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response +- id: assertion.k8s.list-binding-json + assertion_kind: relation + subject: binding.k8s-api + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json + operation_ref: operation.k8s.list-pods +- id: assertion.k8s.list-interaction-json + assertion_kind: relation + subject: interaction.k8s.list + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +x-references: +- https://kubernetes.io/docs/reference/using-api/api-concepts/ +- https://kubernetes.io/docs/reference/kubernetes-api/definitions/api-resource-v1-meta/ +information_shapes: +- id: shape.k8s.pod + kind: information-shape + name: Kubernetes Pod + shape_kind: fiam.information-shape.object +- id: shape.k8s.pod-list + kind: information-shape + name: Kubernetes Pod collection representation + shape_kind: fiam.information-shape.collection +artifacts: +- id: artifact.k8s.openapi + kind: artifact + name: Kubernetes OpenAPI schema/discovery + artifact_type: fiam.artifact.api-description + describes: + - contract.k8s-api + - shape.k8s.pod + - shape.k8s.pod-list + locator: cluster://openapi diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/11-element-shape-on-object.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/11-element-shape-on-object.yaml new file mode 100644 index 0000000..6440edc --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/11-element-shape-on-object.yaml @@ -0,0 +1,252 @@ +fiam_version: '0.2' +instance: + id: adversarial.element-on-object-shape + kind: model + title: Kubernetes Pod collection and object + status: provisional + intent: Test API resource collection/object modeling while keeping representation kind/schema distinct from resource identity. +nodes: +- id: node.kubectl + kind: system-node + name: kubectl / API client + node_type: fiam.node-type.application +- id: node.apiserver + kind: system-node + name: Kubernetes API Server + node_type: fiam.node-type.service +ports: +- id: port.apiserver.api + owner: node.apiserver + participations: + - contract: contract.k8s-api + mode: offers +- id: port.kubectl.api + owner: node.kubectl + participations: + - contract: contract.k8s-api + mode: requires +contracts: +- id: contract.k8s-api + kind: interface-contract + purpose: + - fiam.purpose.transactional-data-access + - fiam.purpose.mutation + operations: + - id: operation.k8s.list-pods + name: list pods + effect: fiam.effect.read + - id: operation.k8s.watch-pods + name: watch pods + interaction_style: fiam.interaction-style.subscribe + - id: operation.k8s.patch-pod + name: patch pod + effect: fiam.effect.write +endpoints: +- id: endpoint.apiserver + kind: endpoint + address: https://cluster.example.invalid + address_scheme: fiam.address-scheme.https-url +bindings: +- id: binding.k8s-api + contract: contract.k8s-api + provider_port: port.apiserver.api + consumer_ports: + - port.kubectl.api + endpoints: + - endpoint.apiserver + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls +information_resources: +- id: resource.k8s.default-pods + kind: information-resource + name: default namespace Pods collection + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.concrete-collection + owner: node.apiserver + selectors: + - kind: fiam.resource-selector.kubernetes-resource-path + value: /api/v1/namespaces/default/pods + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +- id: resource.k8s.pod.demo + kind: information-resource + name: Pod default/demo + resource_kind: fiam.information-resource.api-resource-object + resource_scope: fiam.resource-scope.concrete-instance + owner: node.apiserver + selectors: + - kind: fiam.resource-selector.kubernetes-object-ref + value: + apiVersion: v1 + kind: Pod + namespace: default + name: demo + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +interactions: +- id: interaction.k8s.list + kind: interaction + operation: operation.k8s.list-pods + binding: binding.k8s-api +- id: interaction.k8s.watch + kind: interaction + operation: operation.k8s.watch-pods + binding: binding.k8s-api + temporal_semantics: fiam.temporal.asynchronous +- id: interaction.k8s.patch + kind: interaction + operation: operation.k8s.patch-pod + binding: binding.k8s-api +assertions: +- id: assertion.pod.in-collection + assertion_kind: relation + subject: resource.k8s.pod.demo + predicate: fiam.relation.contained-in + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.list.reads + assertion_kind: relation + subject: interaction.k8s.list + predicate: fiam.relation.reads-from + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.watch.watches + assertion_kind: relation + subject: interaction.k8s.watch + predicate: fiam.relation.watches + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.patch.writes + assertion_kind: relation + subject: interaction.k8s.patch + predicate: fiam.relation.writes-to + polarity: asserted + object_ref: resource.k8s.pod.demo + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.k8s.collection-conforms + assertion_kind: relation + subject: resource.k8s.default-pods + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.k8s.collection-element + assertion_kind: relation + subject: resource.k8s.default-pods + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.element + slot: items +- id: assertion.k8s.listshape-element + assertion_kind: relation + subject: shape.k8s.pod + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.element + slot: items +- id: assertion.k8s.object-conforms + assertion_kind: relation + subject: resource.k8s.pod.demo + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.k8s.list-produces + assertion_kind: relation + subject: operation.k8s.list-pods + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response +- id: assertion.k8s.list-binding-json + assertion_kind: relation + subject: binding.k8s-api + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json + operation_ref: operation.k8s.list-pods +- id: assertion.k8s.list-interaction-json + assertion_kind: relation + subject: interaction.k8s.list + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +x-references: +- https://kubernetes.io/docs/reference/using-api/api-concepts/ +- https://kubernetes.io/docs/reference/kubernetes-api/definitions/api-resource-v1-meta/ +information_shapes: +- id: shape.k8s.pod + kind: information-shape + name: Kubernetes Pod + shape_kind: fiam.information-shape.object +- id: shape.k8s.pod-list + kind: information-shape + name: Kubernetes Pod collection representation + shape_kind: fiam.information-shape.collection +artifacts: +- id: artifact.k8s.openapi + kind: artifact + name: Kubernetes OpenAPI schema/discovery + artifact_type: fiam.artifact.api-description + describes: + - contract.k8s-api + - shape.k8s.pod + - shape.k8s.pod-list + locator: cluster://openapi diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/12-binding-unrelated-shape.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/12-binding-unrelated-shape.yaml new file mode 100644 index 0000000..7f44b3e --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/12-binding-unrelated-shape.yaml @@ -0,0 +1,256 @@ +fiam_version: '0.2' +instance: + id: adversarial.binding-unrelated-shape + kind: model + title: Kubernetes Pod collection and object + status: provisional + intent: Test API resource collection/object modeling while keeping representation kind/schema distinct from resource identity. +nodes: +- id: node.kubectl + kind: system-node + name: kubectl / API client + node_type: fiam.node-type.application +- id: node.apiserver + kind: system-node + name: Kubernetes API Server + node_type: fiam.node-type.service +ports: +- id: port.apiserver.api + owner: node.apiserver + participations: + - contract: contract.k8s-api + mode: offers +- id: port.kubectl.api + owner: node.kubectl + participations: + - contract: contract.k8s-api + mode: requires +contracts: +- id: contract.k8s-api + kind: interface-contract + purpose: + - fiam.purpose.transactional-data-access + - fiam.purpose.mutation + operations: + - id: operation.k8s.list-pods + name: list pods + effect: fiam.effect.read + - id: operation.k8s.watch-pods + name: watch pods + interaction_style: fiam.interaction-style.subscribe + - id: operation.k8s.patch-pod + name: patch pod + effect: fiam.effect.write +endpoints: +- id: endpoint.apiserver + kind: endpoint + address: https://cluster.example.invalid + address_scheme: fiam.address-scheme.https-url +bindings: +- id: binding.k8s-api + contract: contract.k8s-api + provider_port: port.apiserver.api + consumer_ports: + - port.kubectl.api + endpoints: + - endpoint.apiserver + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls +information_resources: +- id: resource.k8s.default-pods + kind: information-resource + name: default namespace Pods collection + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.concrete-collection + owner: node.apiserver + selectors: + - kind: fiam.resource-selector.kubernetes-resource-path + value: /api/v1/namespaces/default/pods + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +- id: resource.k8s.pod.demo + kind: information-resource + name: Pod default/demo + resource_kind: fiam.information-resource.api-resource-object + resource_scope: fiam.resource-scope.concrete-instance + owner: node.apiserver + selectors: + - kind: fiam.resource-selector.kubernetes-object-ref + value: + apiVersion: v1 + kind: Pod + namespace: default + name: demo + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +interactions: +- id: interaction.k8s.list + kind: interaction + operation: operation.k8s.list-pods + binding: binding.k8s-api +- id: interaction.k8s.watch + kind: interaction + operation: operation.k8s.watch-pods + binding: binding.k8s-api + temporal_semantics: fiam.temporal.asynchronous +- id: interaction.k8s.patch + kind: interaction + operation: operation.k8s.patch-pod + binding: binding.k8s-api +assertions: +- id: assertion.pod.in-collection + assertion_kind: relation + subject: resource.k8s.pod.demo + predicate: fiam.relation.contained-in + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.list.reads + assertion_kind: relation + subject: interaction.k8s.list + predicate: fiam.relation.reads-from + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.watch.watches + assertion_kind: relation + subject: interaction.k8s.watch + predicate: fiam.relation.watches + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.patch.writes + assertion_kind: relation + subject: interaction.k8s.patch + predicate: fiam.relation.writes-to + polarity: asserted + object_ref: resource.k8s.pod.demo + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.k8s.collection-conforms + assertion_kind: relation + subject: resource.k8s.default-pods + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.k8s.collection-element + assertion_kind: relation + subject: resource.k8s.default-pods + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.element + slot: items +- id: assertion.k8s.listshape-element + assertion_kind: relation + subject: shape.k8s.pod-list + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.element + slot: items +- id: assertion.k8s.object-conforms + assertion_kind: relation + subject: resource.k8s.pod.demo + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.k8s.list-produces + assertion_kind: relation + subject: operation.k8s.list-pods + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response +- id: assertion.k8s.list-binding-json + assertion_kind: relation + subject: binding.k8s-api + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.unrelated + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json + operation_ref: operation.k8s.list-pods +- id: assertion.k8s.list-interaction-json + assertion_kind: relation + subject: interaction.k8s.list + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +x-references: +- https://kubernetes.io/docs/reference/using-api/api-concepts/ +- https://kubernetes.io/docs/reference/kubernetes-api/definitions/api-resource-v1-meta/ +information_shapes: +- id: shape.k8s.pod + kind: information-shape + name: Kubernetes Pod + shape_kind: fiam.information-shape.object +- id: shape.k8s.pod-list + kind: information-shape + name: Kubernetes Pod collection representation + shape_kind: fiam.information-shape.collection +- id: shape.unrelated + kind: information-shape + name: Unrelated object + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.k8s.openapi + kind: artifact + name: Kubernetes OpenAPI schema/discovery + artifact_type: fiam.artifact.api-description + describes: + - contract.k8s-api + - shape.k8s.pod + - shape.k8s.pod-list + locator: cluster://openapi diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/13-interaction-unrelated-shape.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/13-interaction-unrelated-shape.yaml new file mode 100644 index 0000000..1d6bdf3 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/13-interaction-unrelated-shape.yaml @@ -0,0 +1,256 @@ +fiam_version: '0.2' +instance: + id: adversarial.interaction-unrelated-shape + kind: model + title: Kubernetes Pod collection and object + status: provisional + intent: Test API resource collection/object modeling while keeping representation kind/schema distinct from resource identity. +nodes: +- id: node.kubectl + kind: system-node + name: kubectl / API client + node_type: fiam.node-type.application +- id: node.apiserver + kind: system-node + name: Kubernetes API Server + node_type: fiam.node-type.service +ports: +- id: port.apiserver.api + owner: node.apiserver + participations: + - contract: contract.k8s-api + mode: offers +- id: port.kubectl.api + owner: node.kubectl + participations: + - contract: contract.k8s-api + mode: requires +contracts: +- id: contract.k8s-api + kind: interface-contract + purpose: + - fiam.purpose.transactional-data-access + - fiam.purpose.mutation + operations: + - id: operation.k8s.list-pods + name: list pods + effect: fiam.effect.read + - id: operation.k8s.watch-pods + name: watch pods + interaction_style: fiam.interaction-style.subscribe + - id: operation.k8s.patch-pod + name: patch pod + effect: fiam.effect.write +endpoints: +- id: endpoint.apiserver + kind: endpoint + address: https://cluster.example.invalid + address_scheme: fiam.address-scheme.https-url +bindings: +- id: binding.k8s-api + contract: contract.k8s-api + provider_port: port.apiserver.api + consumer_ports: + - port.kubectl.api + endpoints: + - endpoint.apiserver + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls +information_resources: +- id: resource.k8s.default-pods + kind: information-resource + name: default namespace Pods collection + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.concrete-collection + owner: node.apiserver + selectors: + - kind: fiam.resource-selector.kubernetes-resource-path + value: /api/v1/namespaces/default/pods + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +- id: resource.k8s.pod.demo + kind: information-resource + name: Pod default/demo + resource_kind: fiam.information-resource.api-resource-object + resource_scope: fiam.resource-scope.concrete-instance + owner: node.apiserver + selectors: + - kind: fiam.resource-selector.kubernetes-object-ref + value: + apiVersion: v1 + kind: Pod + namespace: default + name: demo + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +interactions: +- id: interaction.k8s.list + kind: interaction + operation: operation.k8s.list-pods + binding: binding.k8s-api +- id: interaction.k8s.watch + kind: interaction + operation: operation.k8s.watch-pods + binding: binding.k8s-api + temporal_semantics: fiam.temporal.asynchronous +- id: interaction.k8s.patch + kind: interaction + operation: operation.k8s.patch-pod + binding: binding.k8s-api +assertions: +- id: assertion.pod.in-collection + assertion_kind: relation + subject: resource.k8s.pod.demo + predicate: fiam.relation.contained-in + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.list.reads + assertion_kind: relation + subject: interaction.k8s.list + predicate: fiam.relation.reads-from + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.watch.watches + assertion_kind: relation + subject: interaction.k8s.watch + predicate: fiam.relation.watches + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.patch.writes + assertion_kind: relation + subject: interaction.k8s.patch + predicate: fiam.relation.writes-to + polarity: asserted + object_ref: resource.k8s.pod.demo + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.k8s.collection-conforms + assertion_kind: relation + subject: resource.k8s.default-pods + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.k8s.collection-element + assertion_kind: relation + subject: resource.k8s.default-pods + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.element + slot: items +- id: assertion.k8s.listshape-element + assertion_kind: relation + subject: shape.k8s.pod-list + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.element + slot: items +- id: assertion.k8s.object-conforms + assertion_kind: relation + subject: resource.k8s.pod.demo + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.k8s.list-produces + assertion_kind: relation + subject: operation.k8s.list-pods + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response +- id: assertion.k8s.list-binding-json + assertion_kind: relation + subject: binding.k8s-api + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json + operation_ref: operation.k8s.list-pods +- id: assertion.k8s.list-interaction-json + assertion_kind: relation + subject: interaction.k8s.list + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.unrelated + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +x-references: +- https://kubernetes.io/docs/reference/using-api/api-concepts/ +- https://kubernetes.io/docs/reference/kubernetes-api/definitions/api-resource-v1-meta/ +information_shapes: +- id: shape.k8s.pod + kind: information-shape + name: Kubernetes Pod + shape_kind: fiam.information-shape.object +- id: shape.k8s.pod-list + kind: information-shape + name: Kubernetes Pod collection representation + shape_kind: fiam.information-shape.collection +- id: shape.unrelated + kind: information-shape + name: Unrelated object + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.k8s.openapi + kind: artifact + name: Kubernetes OpenAPI schema/discovery + artifact_type: fiam.artifact.api-description + describes: + - contract.k8s-api + - shape.k8s.pod + - shape.k8s.pod-list + locator: cluster://openapi diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/14-manual-family-label.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/14-manual-family-label.yaml new file mode 100644 index 0000000..fa09ad6 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/14-manual-family-label.yaml @@ -0,0 +1,281 @@ +fiam_version: '0.2' +instance: + id: adversarial.manual-family-label + kind: model + title: MCP server over stdio + status: provisional + intent: Model a local agent-to-tool interface using MCP over JSON-RPC and stdio. +nodes: +- id: node.agent-host + kind: system-node + name: Agent Host + node_type: fiam.node-type.application +- id: node.mcp-server + kind: system-node + name: Local MCP Server + node_type: fiam.node-type.process +ports: +- id: port.agent.mcp-client + owner: node.agent-host + participations: + - contract: contract.mcp.tools + mode: requires + roles: + - fiam.role.client +- id: port.server.mcp + owner: node.mcp-server + participations: + - contract: contract.mcp.tools + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.mcp.tools + kind: interface-contract + purpose: + - fiam.purpose.tool-invocation + contract_forms: + - fiam.contract-form.mcp + operations: + - id: operation.mcp.tools-list + name: tools/list + interaction_style: fiam.interaction-style.rpc + - id: operation.mcp.tools-call + name: tools/call + interaction_style: fiam.interaction-style.rpc + family_labels: + - fiam.family.agent-tool-interface +- id: contract.tool.read-file + kind: interface-contract + name: read_file tool + purpose: + - fiam.purpose.tool-invocation + operations: + - id: operation.tool.read-file + name: read_file + interaction_style: fiam.interaction-style.rpc +bindings: +- id: binding.mcp.stdio + contract: contract.mcp.tools + provider_port: port.server.mcp + consumer_ports: + - port.agent.mcp-client + binding_profile: fiam.binding-profile.mcp-stdio + communication_stack: + - role: fiam.stack-role.application-protocol + term: fiam.protocol.mcp + - role: fiam.stack-role.messaging-protocol + term: fiam.protocol.json-rpc-2.0 + - role: fiam.stack-role.ipc-process-carrier + term: fiam.carrier.stdio + addressing: + kind: fiam.addressing.process-spawn + value: command invocation + session_model: fiam.session.long-lived-process +channels: +- id: channel.mcp.stdio + kind: channel + channel_type: fiam.channel.bidirectional-byte-stream + mediation: fiam.mediation.direct +interactions: +- id: interaction.tools-call + operation: operation.mcp.tools-call + binding: binding.mcp.stdio + channel: channel.mcp.stdio + temporal_semantics: fiam.temporal.synchronous + participants: + initiator: node.agent-host + responder: node.mcp-server +- id: interaction.read-file + kind: interaction + operation: operation.tool.read-file + binding: binding.mcp.stdio + channel: channel.mcp.stdio + temporal_semantics: fiam.temporal.synchronous + participants: + initiator: node.agent-host + responder: node.mcp-server + realization_status: fiam.interaction-status.executed +assertions: +- id: assertion.mcp.protocol + subject: binding.mcp.stdio + predicate: fiam.property.communication-protocol + value: fiam.protocol.mcp + evidence: + mode: fiam.evidence.declared + source: MCP specification + confidence: 1.0 + assertion_kind: property + polarity: asserted +- id: assertion.local-boundary + subject: binding.mcp.stdio + predicate: fiam.property.execution-boundary + value: fiam.execution-boundary.local-process + evidence: + mode: fiam.evidence.inferred + source: stdio binding semantics + confidence: 0.99 + assertion_kind: property + polarity: asserted +- id: assertion.mcp.catalog-elements + assertion_kind: relation + subject: shape.mcp.tool-catalog + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.mcp.tool-descriptor + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + slot: tools + role: fiam.shape-role.element +- id: assertion.mcp.tools-list-produces + assertion_kind: relation + subject: operation.mcp.tools-list + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.mcp.tool-catalog + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.mcp.tool-discovered + assertion_kind: relation + subject: operation.tool.read-file + predicate: fiam.relation.discovered-via + polarity: asserted + object_ref: operation.mcp.tools-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.mcp.tool-contract-embedded + assertion_kind: relation + subject: contract.tool.read-file + predicate: fiam.relation.embedded-in + polarity: asserted + object_ref: operation.mcp.tools-call + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + slot: params.arguments +- id: assertion.read-file.accepts + assertion_kind: relation + subject: operation.tool.read-file + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.read-file.args + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.request +- id: assertion.read-file.produces + assertion_kind: relation + subject: operation.tool.read-file + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.read-file.result + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response +- id: assertion.read-file.actual-input + assertion_kind: relation + subject: interaction.read-file + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.read-file.args + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.request + representation: fiam.representation.json +- id: assertion.read-file.actual-output + assertion_kind: relation + subject: interaction.read-file + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.read-file.result + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.mcp.tools-call-accepts + assertion_kind: relation + subject: operation.mcp.tools-call + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.mcp.tool-call-request + evidence: + mode: fiam.evidence.declared + source: MCP contract fixture + confidence: 0.98 + facets: + role: fiam.shape-role.request + representation: fiam.representation.json +- id: assertion.mcp.tools-call-produces + assertion_kind: relation + subject: operation.mcp.tools-call + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.mcp.tool-call-result + evidence: + mode: fiam.evidence.declared + source: MCP contract fixture + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.mcp.call-embeds-tool-args + assertion_kind: relation + subject: shape.mcp.tool-call-request + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.read-file.args + evidence: + mode: fiam.evidence.declared + source: MCP contract fixture + confidence: 0.98 + facets: + slot: params.arguments + role: fiam.shape-role.payload +information_shapes: +- id: shape.mcp.tool-catalog + kind: information-shape + name: MCP tool catalog + shape_kind: fiam.information-shape.collection +- id: shape.mcp.tool-descriptor + kind: information-shape + name: MCP tool descriptor + shape_kind: fiam.information-shape.object +- id: shape.read-file.args + kind: information-shape + name: read_file arguments + shape_kind: fiam.information-shape.object +- id: shape.read-file.result + kind: information-shape + name: read_file result + shape_kind: fiam.information-shape.object +- id: shape.mcp.tool-call-request + kind: information-shape + name: MCP tools/call request + shape_kind: fiam.information-shape.object +- id: shape.mcp.tool-call-result + kind: information-shape + name: MCP tools/call result + shape_kind: fiam.information-shape.object diff --git a/history/FIAM_v0.2_Draft6/adversarial-cases/15-inferred-same-entity-one-signal.yaml b/history/FIAM_v0.2_Draft6/adversarial-cases/15-inferred-same-entity-one-signal.yaml new file mode 100644 index 0000000..8455310 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-cases/15-inferred-same-entity-one-signal.yaml @@ -0,0 +1,56 @@ +fiam_version: '0.2' +instance: + id: adversarial.inferred-same-entity-one-signal + kind: model + title: Shape identity across OpenAPI and source declarations + status: provisional + intent: Exercise candidate alignment versus confirmed shape identity without destructive merge. +nodes: +- id: node.user-service + kind: system-node + name: User service + node_type: fiam.node-type.service +information_shapes: +- id: shape.customer.openapi + kind: information-shape + name: Customer discovered from OpenAPI + shape_kind: fiam.information-shape.object +- id: shape.customer.java + kind: information-shape + name: Customer discovered from Java source + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.openapi + kind: artifact + name: openapi.yaml + artifact_type: fiam.artifact.api-description + describes: shape.customer.openapi +- id: artifact.customer-java + kind: artifact + name: Customer.java + artifact_type: fiam.artifact.source-code-type + describes: shape.customer.java +assertions: +- id: assertion.customer-corresponds + assertion_kind: relation + subject: shape.customer.openapi + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: shape.customer.java + evidence: + mode: fiam.evidence.inferred + source: static analyzers matched names and structure + confidence: 0.78 +- id: assertion.customer-same + assertion_kind: relation + subject: shape.customer.openapi + predicate: fiam.relation.same-entity-as + polarity: asserted + object_ref: shape.customer.java + evidence: + mode: fiam.evidence.inferred + source: + type: schema-structural-fingerprint + ref: one-signal + locator: fixture + confidence: 0.995 diff --git a/history/FIAM_v0.2_Draft6/adversarial-inputs/otel-kind-string.json b/history/FIAM_v0.2_Draft6/adversarial-inputs/otel-kind-string.json new file mode 100644 index 0000000..dd94ed6 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/adversarial-inputs/otel-kind-string.json @@ -0,0 +1,11 @@ +{ + "resourceSpans": [{ + "resource": {"attributes": [{"key":"service.name","value":{"stringValue":"bad.service"}}]}, + "scopeSpans": [{"scope": {"name":"bad"}, "spans": [{ + "traceId":"5B8EFFF798038103D269B633813FC60C", + "spanId":"EEE19B7EC3C1B174", + "name":"invalid OTLP JSON enum", + "kind":"SPAN_KIND_SERVER" + }]}] + }] +} diff --git a/history/FIAM_v0.2_Draft6/canon/FIAM-Canon-v0.2.yaml b/history/FIAM_v0.2_Draft6/canon/FIAM-Canon-v0.2.yaml new file mode 100644 index 0000000..3bcddd6 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/canon/FIAM-Canon-v0.2.yaml @@ -0,0 +1,3064 @@ +fiam_canon_version: '0.2' +id: urn:fiam:canon:0.2 +title: "FIAM Canon v0.2 Draft Baseline \u2014 Architecture Intelligence Queries" +status: provisional +compatible_core_versions: +- '0.2' +intent: Provisional canonical vocabulary for FIAM v0.2, semantically revalidated after promotion of InformationResource and + InformationShape. +principles: +- Core structure and Canon vocabulary evolve independently. +- Canonical term identifiers are stable and are never silently repurposed. +- Terms move through candidate, provisional, canonical, and deprecated lifecycle states. +- Local namespaced extensions are allowed; repeated useful terms can later be promoted into the FIAM Canon. +- Compound interface types are discouraged when meaning can be represented by orthogonal facets. +- Evidence mode describes how a fact became known; evidence source describes where the evidence came from. +- Architectural relationships are represented as evidence-backed relation assertions rather than proliferating Core fields. +- Facet schemes declare allowed scopes and a resolution mode so inheritance/refinement is explicit rather than implicit. +- Identity relations never authorize destructive merge by themselves; source records and evidence remain preserved. +- Port offers/requires semantics are contract participation, not information-flow direction. +term_lifecycle: +- candidate +- provisional +- canonical +- deprecated +schemes: +- id: fiam.scheme.addressing-discovery + name: Addressing / Discovery + definition: Mechanism used to locate, select, or instantiate an interface realization. + allowed_scopes: + - binding + - endpoint + resolution: + mode: override + precedence: + - endpoint + - binding +- id: fiam.scheme.addressing-scheme + name: Addressing Scheme + definition: Form used to locate or select a concrete endpoint. + allowed_scopes: + - endpoint + resolution: + mode: none +- id: fiam.scheme.artifact-type + name: Artifact Type + definition: Kind of file, descriptor, source construct, or other artifact associated with FIAM entities. + allowed_scopes: + - artifact + resolution: + mode: none +- id: fiam.scheme.authentication-mechanism + name: Authentication Mechanism + definition: Authentication mode or mechanism applied to an interface or flow. + allowed_scopes: + - security-profile + - binding + - interaction-flow + - interaction + resolution: + mode: refine + precedence: + - interaction + - interaction-flow + - binding + - security-profile +- id: fiam.scheme.binding-profile + name: Binding Profile + definition: Named mapping of a higher-level contract or semantic model to concrete communication mechanisms. + allowed_scopes: + - binding + resolution: + mode: none +- id: fiam.scheme.carrier + name: Invocation / Process Carrier + definition: Local runtime or process carrier used to move information or invoke behavior. + allowed_scopes: + - stack-item + - binding + resolution: + mode: none +- id: fiam.scheme.channel-type + name: Channel Type + definition: Kind of communication locus or mediation channel. + allowed_scopes: + - channel + resolution: + mode: none +- id: fiam.scheme.communication-layer-role + name: Communication Stack Role + definition: Semantic role played by a technology item in an ordered FIAM communication stack. + allowed_scopes: + - stack-item + resolution: + mode: none +- id: fiam.scheme.contract-form + name: Contract Form + definition: Machine-readable, language-level, or conventional form in which an interface contract is expressed. + allowed_scopes: + - interface-contract + - artifact + resolution: + mode: accumulate +- id: fiam.scheme.credential-artifact + name: Credential Artifact + definition: Credential, token, or proof artifact used in a security interaction. + allowed_scopes: + - security-profile + - interaction-flow + - interaction + resolution: + mode: accumulate +- id: fiam.scheme.delivery-semantics + name: Delivery Semantics + definition: Delivery guarantee or expectation for mediated communication. + allowed_scopes: + - channel + - binding + - interaction + resolution: + mode: refine + precedence: + - interaction + - binding + - channel +- id: fiam.scheme.discovery-mechanism + name: Discovery Mechanism + definition: Mechanism used to discover providers, endpoints, or implementations. + allowed_scopes: + - binding + - endpoint + - operation + - interface-contract + resolution: + mode: refine + precedence: + - operation + - endpoint + - binding + - interface-contract +- id: fiam.scheme.durability + name: Durability + definition: Persistence/lifetime characteristic of an information resource. + allowed_scopes: + - information-resource + - channel + resolution: + mode: override +- id: fiam.scheme.evidence-mode + name: Evidence Mode + definition: 'How an assertion became known: declared, statically observed, runtime observed, or inferred.' + allowed_scopes: + - evidence + resolution: + mode: none +- id: fiam.scheme.execution-boundary + name: Execution Boundary + definition: Boundary crossed by an interaction or binding. + allowed_scopes: + - binding + - interaction + - flow-step + resolution: + mode: refine + precedence: + - interaction + - binding +- id: fiam.scheme.family-label + name: Derived Family Label + definition: Convenience classification derived from orthogonal FIAM facts; not a primitive structural type. + allowed_scopes: + - interface-contract + resolution: + mode: derived +- id: fiam.scheme.flow-type + name: Interaction Flow Type + definition: Kind of multi-step choreography or orchestration. + allowed_scopes: + - interaction-flow + resolution: + mode: none +- id: fiam.scheme.identity-propagation + name: Identity Propagation + definition: Mechanism by which identity or authority context is propagated. + allowed_scopes: + - security-profile + - binding + - interaction-flow + - interaction + resolution: + mode: refine + precedence: + - interaction + - interaction-flow + - binding + - security-profile +- id: fiam.scheme.information-resource-kind + name: Information Resource Kind + definition: Kind of information-bearing locus, state, object, or collection represented by InformationResource. + allowed_scopes: + - information-resource + resolution: + mode: none +- id: fiam.scheme.information-shape-kind + name: Information Shape Kind + definition: Technology-independent coarse kind of an InformationShape. Fine-grained members and constraints remain in external + schema/type artifacts. + allowed_scopes: + - information-shape + resolution: + mode: none +- id: fiam.scheme.interaction-realization-status + name: Interaction Realization Status + definition: Status describing whether an interaction is proposed, authorized, attempted, executed, rejected, failed, or + completed. + allowed_scopes: + - interaction + - flow-step + resolution: + mode: override + precedence: + - interaction + - flow-step +- id: fiam.scheme.interaction-style + name: Interaction Style + definition: Logical shape or conversational style of an operation or interaction. + allowed_scopes: + - interface-contract + - operation + - interaction + resolution: + mode: refine + precedence: + - interaction + - operation + - interface-contract +- id: fiam.scheme.mediation + name: Mediation + definition: Whether and how communication is mediated between participants. + allowed_scopes: + - channel + - binding + resolution: + mode: override + precedence: + - binding + - channel +- id: fiam.scheme.mutability + name: Mutability + definition: Allowed change pattern of an information resource. + allowed_scopes: + - information-resource + resolution: + mode: override +- id: fiam.scheme.node-type + name: System Node Type + definition: Technical or logical kind of information-processing node. + allowed_scopes: + - system-node + resolution: + mode: none +- id: fiam.scheme.operation-effect + name: Operation Effect + definition: Abstract effect of an operation on information or system state. + allowed_scopes: + - operation + resolution: + mode: none +- id: fiam.scheme.ordering-scope + name: Ordering Scope + definition: Scope within which message/event ordering is defined. + allowed_scopes: + - channel + - binding + - interaction + resolution: + mode: refine + precedence: + - interaction + - binding + - channel +- id: fiam.scheme.participant-role + name: Participant Role + definition: Contextual role played by a participant in an interaction or interface relationship. + allowed_scopes: + - contract-participation + - interaction + - flow-step + resolution: + mode: contextual +- id: fiam.scheme.property + name: Assertion Property + definition: Predicate vocabulary used by FIAM assertions. + allowed_scopes: + - property-assertion + resolution: + mode: none +- id: fiam.scheme.protocol + name: Protocol / Framework + definition: Named communication protocol, protocol framework, or protocol profile. + allowed_scopes: + - stack-item + - binding + resolution: + mode: none +- id: fiam.scheme.purpose + name: Purpose + definition: Why an interface, operation, or interaction exists. + allowed_scopes: + - interface-contract + - operation + - interaction-flow + - interaction + resolution: + mode: accumulate + precedence: + - interaction + - operation + - interface-contract +- id: fiam.scheme.relation + name: Architectural Relation + definition: Predicate vocabulary for evidence-backed relation assertions between FIAM entities. + allowed_scopes: + - relation-assertion + resolution: + mode: none +- id: fiam.scheme.representation + name: Representation + definition: Concrete serialization, notation, or runtime representation used at a binding, interaction, resource, stack + layer, or shape participation. Not shape identity. + allowed_scopes: + - stack-item + - binding + - interaction + - relation-assertion + - information-resource + resolution: + mode: refine + precedence: + - interaction + - binding + - relation-assertion +- id: fiam.scheme.resource-scope + name: Information Resource Scope + definition: Whether an InformationResource denotes a concrete instance, collection, logical selection, or shared state surface. + allowed_scopes: + - information-resource + resolution: + mode: none +- id: fiam.scheme.resource-selector + name: Information Resource Selector + definition: Mechanism/value form used to identify a resource within its provider or namespace; distinct from a Binding Endpoint. + allowed_scopes: + - information-resource + resolution: + mode: accumulate +- id: fiam.scheme.runtime + name: Runtime + definition: Execution runtime used as part of an interface realization. + allowed_scopes: + - stack-item + - system-node + resolution: + mode: none +- id: fiam.scheme.shape-role + name: Shape Participation / Composition Role + definition: Coarse semantic role played by an InformationShape in a participation or composition relation. + allowed_scopes: + - relation-assertion + resolution: + mode: contextual +- id: fiam.scheme.state-session + name: State / Session Model + definition: Statefulness or session model associated with an interface realization. + allowed_scopes: + - binding + - interaction + resolution: + mode: override + precedence: + - interaction + - binding +- id: fiam.scheme.technology + name: Technology / Semantic Standard + definition: Named interface technology or semantic standard that is not accurately classified as a transport protocol. + allowed_scopes: + - stack-item + - binding + - interface-contract + resolution: + mode: none +- id: fiam.scheme.temporal-semantics + name: Temporal Semantics + definition: Timing, lifetime, or streaming/session semantics of an interaction. + allowed_scopes: + - operation + - binding + - interaction + resolution: + mode: refine + precedence: + - interaction + - binding + - operation +- id: fiam.scheme.transport + name: Transport / IPC Mechanism + definition: Lower-level network transport or inter-process communication mechanism. + allowed_scopes: + - stack-item + - binding + resolution: + mode: none +- id: fiam.scheme.transport-security + name: Transport Security + definition: Security property or mechanism protecting a communication channel. + allowed_scopes: + - security-profile + - binding + - interaction-flow + - interaction + resolution: + mode: refine + precedence: + - interaction + - interaction-flow + - binding + - security-profile +- id: fiam.scheme.zone-type + name: Zone Type + definition: Kind of logical/deployment/trust grouping used to scope FIAM entities. + allowed_scopes: + - zone + resolution: + mode: none +terms: +- id: fiam.address-scheme.host-port + scheme: fiam.scheme.addressing-scheme + preferred_label: host and port + definition: Endpoint addressed by a host or service address plus optional network port, without asserting a higher-level + URI scheme. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/general/attributes/ +- id: fiam.address-scheme.http-url + scheme: fiam.scheme.addressing-scheme + preferred_label: HTTP URL + definition: Endpoint addressed by an HTTP URL. + status: provisional + introduced_in: '0.2' +- id: fiam.address-scheme.https-url + scheme: fiam.scheme.addressing-scheme + preferred_label: HTTPS URL + definition: Endpoint addressed by an HTTPS URL. + status: provisional + introduced_in: '0.1' +- id: fiam.address-scheme.unix-socket-path + scheme: fiam.scheme.addressing-scheme + preferred_label: Unix-domain socket path + definition: Endpoint addressed by a filesystem-like Unix-domain socket path. + status: provisional + introduced_in: '0.1' +- id: fiam.addressing.process-spawn + scheme: fiam.scheme.addressing-discovery + preferred_label: process spawn + definition: Addressing/selection mechanism in which a provider interface is reached by spawning or invoking a process. + status: provisional + introduced_in: '0.1' +- id: fiam.artifact.api-description + scheme: fiam.scheme.artifact-type + preferred_label: API description + definition: A machine-readable API description artifact such as an OpenAPI document. + status: provisional + introduced_in: '0.2' +- id: fiam.artifact.architecture-declaration + scheme: fiam.scheme.artifact-type + preferred_label: architecture declaration + definition: Artifact declaring an intended or expected architecture property. + status: provisional + introduced_in: '0.2' +- id: fiam.artifact.cli-contract-description + scheme: fiam.scheme.artifact-type + preferred_label: CLI contract description + definition: A help, grammar, completion, manpage, or similar artifact describing a command-line contract. + status: provisional + introduced_in: '0.2' +- id: fiam.artifact.graphql-schema + scheme: fiam.scheme.artifact-type + preferred_label: GraphQL schema artifact + definition: A GraphQL schema definition artifact. + status: provisional + introduced_in: '0.2' +- id: fiam.artifact.protobuf-source + scheme: fiam.scheme.artifact-type + preferred_label: Protocol Buffers schema source + definition: A .proto source artifact defining messages and/or services. + status: provisional + introduced_in: '0.2' +- id: fiam.artifact.schema-document + scheme: fiam.scheme.artifact-type + preferred_label: schema document + definition: An artifact whose primary purpose is to declare one or more information shapes. + status: provisional + introduced_in: '0.2' +- id: fiam.artifact.service-provider-registration + scheme: fiam.scheme.artifact-type + preferred_label: service provider registration + definition: 'Artifact type: service provider registration.' + status: provisional + introduced_in: '0.1' +- id: fiam.artifact.source-code-interface + scheme: fiam.scheme.artifact-type + preferred_label: source code interface + definition: 'Artifact type: source code interface.' + status: provisional + introduced_in: '0.1' +- id: fiam.artifact.source-code-type + scheme: fiam.scheme.artifact-type + preferred_label: source-code type declaration + definition: A source-code declaration of a runtime/language-level type. + status: provisional + introduced_in: '0.2' +- id: fiam.artifact.sql-ddl + scheme: fiam.scheme.artifact-type + preferred_label: SQL DDL artifact + definition: A SQL data-definition artifact describing database structures. + status: provisional + introduced_in: '0.2' +- id: fiam.artifact.telemetry-trace-export + scheme: fiam.scheme.artifact-type + preferred_label: telemetry trace export + definition: Exported trace telemetry used as runtime observation evidence. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/otlp/ +- id: fiam.binding-profile.graphql-over-http + scheme: fiam.scheme.binding-profile + preferred_label: graphql over http + definition: Binding profile realizing GraphQL operations over HTTP. + status: provisional + introduced_in: '0.1' + related: + - fiam.tech.graphql + - fiam.protocol.http +- id: fiam.binding-profile.grpc-http2 + scheme: fiam.scheme.binding-profile + preferred_label: grpc http2 + definition: Binding profile realizing gRPC RPC semantics over HTTP/2. + status: provisional + introduced_in: '0.1' + related: + - fiam.protocol.grpc + - fiam.protocol.http2 +- id: fiam.binding-profile.java-serviceloader + scheme: fiam.scheme.binding-profile + preferred_label: java serviceloader + definition: In-process Java service-provider binding discovered and loaded through ServiceLoader conventions. + status: provisional + introduced_in: '0.1' + related: + - fiam.runtime.jvm + - fiam.carrier.in-process-method-call +- id: fiam.binding-profile.kafka + scheme: fiam.scheme.binding-profile + preferred_label: kafka + definition: Binding profile using Apache Kafka broker/channel mechanics. + status: provisional + introduced_in: '0.1' + related: + - fiam.protocol.kafka +- id: fiam.binding-profile.mcp-stdio + scheme: fiam.scheme.binding-profile + preferred_label: mcp stdio + definition: Binding profile realizing MCP messages over standard input/output of a locally managed process. + status: provisional + introduced_in: '0.1' + related: + - fiam.protocol.mcp + - fiam.carrier.stdio +- id: fiam.binding-profile.mcp-streamable-http + scheme: fiam.scheme.binding-profile + preferred_label: mcp streamable http + definition: Binding profile realizing MCP over Streamable HTTP. + status: provisional + introduced_in: '0.1' + related: + - fiam.protocol.mcp + - fiam.protocol.http +- id: fiam.binding-profile.oidc-http + scheme: fiam.scheme.binding-profile + preferred_label: oidc http + definition: HTTP-based binding used by OpenID Connect / OAuth interactions. + status: provisional + introduced_in: '0.1' + related: + - fiam.protocol.openid-connect + - fiam.protocol.oauth2 + - fiam.protocol.http +- id: fiam.binding-profile.postgresql-unix-socket + scheme: fiam.scheme.binding-profile + preferred_label: postgresql unix socket + definition: Binding profile carrying PostgreSQL frontend/backend protocol over a Unix-domain socket. + status: provisional + introduced_in: '0.1' + related: + - fiam.protocol.postgresql-frontend-backend + - fiam.transport.unix-domain-socket +- id: fiam.carrier.in-process-method-call + scheme: fiam.scheme.carrier + preferred_label: in process method call + definition: Direct in-process invocation through language/runtime call semantics. + status: provisional + introduced_in: '0.1' +- id: fiam.carrier.stdio + scheme: fiam.scheme.carrier + preferred_label: stdio + definition: Standard input/output streams used as a process-level bidirectional carrier. + status: provisional + introduced_in: '0.1' +- id: fiam.channel.bidirectional-byte-stream + scheme: fiam.scheme.channel-type + preferred_label: bidirectional byte stream + definition: Logical channel carrying bytes in both directions. + status: provisional + introduced_in: '0.1' +- id: fiam.channel.bidirectional-message-stream + scheme: fiam.scheme.channel-type + preferred_label: bidirectional message stream + definition: Logical channel carrying framed messages in both directions. + status: provisional + introduced_in: '0.1' +- id: fiam.channel.durable-topic + scheme: fiam.scheme.channel-type + preferred_label: durable topic + definition: Broker-managed topic that retains records/events independently of immediate consumer availability. + status: provisional + introduced_in: '0.1' +- id: fiam.channel.http-exchange + scheme: fiam.scheme.channel-type + preferred_label: http exchange + definition: Logical channel representing HTTP request/response exchanges for a binding. + status: provisional + introduced_in: '0.1' +- id: fiam.channel.message-destination + scheme: fiam.scheme.channel-type + preferred_label: message destination + definition: Logical messaging destination such as a topic, queue, subscription target, or equivalent intermediary-managed + locus when stronger durability semantics are not established. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/ +- id: fiam.contract-form.database-wire-protocol + scheme: fiam.scheme.contract-form + preferred_label: database wire protocol + definition: 'Contract representation/form: database wire protocol.' + status: provisional + introduced_in: '0.1' +- id: fiam.contract-form.event-schema + scheme: fiam.scheme.contract-form + preferred_label: event schema + definition: 'Contract representation/form: event schema.' + status: provisional + introduced_in: '0.1' +- id: fiam.contract-form.graphql-schema + scheme: fiam.scheme.contract-form + preferred_label: graphql schema + definition: 'Contract representation/form: graphql schema.' + status: provisional + introduced_in: '0.1' +- id: fiam.contract-form.language-interface + scheme: fiam.scheme.contract-form + preferred_label: language interface + definition: 'Contract representation/form: language interface.' + status: provisional + introduced_in: '0.1' +- id: fiam.contract-form.mcp + scheme: fiam.scheme.contract-form + preferred_label: MCP + definition: 'Contract representation/form: MCP.' + status: provisional + introduced_in: '0.1' +- id: fiam.contract-form.oidc + scheme: fiam.scheme.contract-form + preferred_label: OIDC + definition: 'Contract representation/form: OIDC.' + status: provisional + introduced_in: '0.1' +- id: fiam.contract-form.openapi + scheme: fiam.scheme.contract-form + preferred_label: OpenAPI description + definition: An interface contract described using an OpenAPI Description document. + status: provisional + introduced_in: '0.2' +- id: fiam.contract-form.protobuf-service + scheme: fiam.scheme.contract-form + preferred_label: protobuf service + definition: 'Contract representation/form: protobuf service.' + status: provisional + introduced_in: '0.1' +- id: fiam.credential.access-token + scheme: fiam.scheme.credential-artifact + preferred_label: Access Token + definition: Token representing authorization to access protected resources. + status: provisional + introduced_in: '0.1' +- id: fiam.credential.api-key + scheme: fiam.scheme.credential-artifact + preferred_label: API key + definition: Opaque API key credential. + status: provisional + introduced_in: '0.2' +- id: fiam.credential.authorization-code + scheme: fiam.scheme.credential-artifact + preferred_label: Authorization Code + definition: Short-lived authorization code exchanged as part of an authorization-code flow. + status: provisional + introduced_in: '0.1' +- id: fiam.credential.basic-credentials + scheme: fiam.scheme.credential-artifact + preferred_label: Basic credentials + definition: Username/password or equivalent credential material used with HTTP Basic authentication. + status: provisional + introduced_in: '0.2' +- id: fiam.credential.bearer-token + scheme: fiam.scheme.credential-artifact + preferred_label: bearer token + definition: Bearer token credential. + status: provisional + introduced_in: '0.2' +- id: fiam.credential.client-certificate + scheme: fiam.scheme.credential-artifact + preferred_label: client certificate + definition: Client certificate credential used for mutual TLS authentication. + status: provisional + introduced_in: '0.2' +- id: fiam.credential.id-token + scheme: fiam.scheme.credential-artifact + preferred_label: ID Token + definition: OpenID Connect ID Token carrying authentication and identity claims. + status: provisional + introduced_in: '0.1' +- id: fiam.delivery.at-least-once + scheme: fiam.scheme.delivery-semantics + preferred_label: at least once + definition: Delivery semantics in which a message is expected to be delivered one or more times, permitting duplicates. + status: provisional + introduced_in: '0.1' +- id: fiam.discovery.runtime-service-provider-loading + scheme: fiam.scheme.discovery-mechanism + preferred_label: runtime service provider loading + definition: Runtime discovery and loading of a service/provider implementation from registered provider metadata. + status: provisional + introduced_in: '0.1' +- id: fiam.durability.durable + scheme: fiam.scheme.durability + preferred_label: durable + definition: Retains information beyond immediate producer/consumer interaction according to an explicit or implicit retention + mechanism. + status: candidate + introduced_in: '0.2' +- id: fiam.durability.ephemeral + scheme: fiam.scheme.durability + preferred_label: ephemeral + definition: Exists only for a bounded interaction/process/connection lifetime unless externalized. + status: candidate + introduced_in: '0.2' +- id: fiam.durability.persistent + scheme: fiam.scheme.durability + preferred_label: persistent + definition: Intended to persist until explicitly deleted or superseded. + status: candidate + introduced_in: '0.2' +- id: fiam.effect.read + scheme: fiam.scheme.operation-effect + preferred_label: read + definition: Operation effect characterized by read. + status: provisional + introduced_in: '0.1' +- id: fiam.effect.write + scheme: fiam.scheme.operation-effect + preferred_label: write + definition: Operation effect characterized by write. + status: provisional + introduced_in: '0.1' +- id: fiam.evidence.declared + scheme: fiam.scheme.evidence-mode + preferred_label: declared + definition: An assertion intentionally stated by an authoritative declaration such as an interface description, architecture + document, configuration owner, or standard. + status: provisional + introduced_in: '0.1' +- id: fiam.evidence.detected-files + scheme: fiam.scheme.evidence-mode + preferred_label: detected files + definition: Deprecated evidence mode that mixed observation mode with source type. Use static-observed and identify the + file/artifact as the evidence source. + status: deprecated + introduced_in: '0.1' + replaced_by: + - fiam.evidence.static-observed + migration_note: Record the detected file/artifact as evidence.source; evidence mode describes how the fact was acquired. +- id: fiam.evidence.inferred + scheme: fiam.scheme.evidence-mode + preferred_label: inferred + definition: An assertion derived from other observations or rules rather than directly observed or authoritatively declared. + status: provisional + introduced_in: '0.1' +- id: fiam.evidence.runtime-observed + scheme: fiam.scheme.evidence-mode + preferred_label: runtime observed + definition: An assertion directly observed during execution, for example in traces, packets, logs, process inspection, or + active probing. + status: provisional + introduced_in: '0.1' +- id: fiam.evidence.static-observed + scheme: fiam.scheme.evidence-mode + preferred_label: static observed + definition: An assertion directly observed in static artifacts such as source code, manifests, configuration, descriptors, + binaries, or files. + status: provisional + introduced_in: '0.1' +- id: fiam.execution-boundary.in-process + scheme: fiam.scheme.execution-boundary + preferred_label: in process + definition: Interaction remains inside one process/runtime address space. + status: provisional + introduced_in: '0.1' +- id: fiam.execution-boundary.local-process + scheme: fiam.scheme.execution-boundary + preferred_label: local process + definition: Interaction crosses a process boundary while remaining on the same host/local execution environment. + status: provisional + introduced_in: '0.1' +- id: fiam.execution-boundary.remote-network + scheme: fiam.scheme.execution-boundary + preferred_label: remote network + definition: Interaction crosses a host/network boundary to a remote execution environment. + status: provisional + introduced_in: '0.1' +- id: fiam.family.agent-tool-interface + scheme: fiam.scheme.family-label + preferred_label: agent tool interface + definition: Derived family label classifying an interface as agent tool interface for navigation or lens-specific analysis. + status: provisional + introduced_in: '0.1' +- id: fiam.family.cli + scheme: fiam.scheme.family-label + preferred_label: CLI + definition: Lens-derived command-line interface family label. + status: provisional + introduced_in: '0.2' +- id: fiam.family.data-access-interface + scheme: fiam.scheme.family-label + preferred_label: data access interface + definition: Derived family label classifying an interface as data access interface for navigation or lens-specific analysis. + status: provisional + introduced_in: '0.1' +- id: fiam.family.database-interface + scheme: fiam.scheme.family-label + preferred_label: database interface + definition: Derived family label classifying an interface as database interface for navigation or lens-specific analysis. + status: provisional + introduced_in: '0.1' + broader: + - fiam.family.data-access-interface +- id: fiam.family.event-interface + scheme: fiam.scheme.family-label + preferred_label: event interface + definition: Derived family label classifying an interface as event interface for navigation or lens-specific analysis. + status: provisional + introduced_in: '0.1' +- id: fiam.family.identity-interface + scheme: fiam.scheme.family-label + preferred_label: identity interface + definition: Derived family label classifying an interface as identity interface for navigation or lens-specific analysis. + status: provisional + introduced_in: '0.1' +- id: fiam.family.integration-interface + scheme: fiam.scheme.family-label + preferred_label: integration interface + definition: Derived family label classifying an interface as integration interface for navigation or lens-specific analysis. + status: provisional + introduced_in: '0.1' +- id: fiam.family.library-api + scheme: fiam.scheme.family-label + preferred_label: library api + definition: Derived family label classifying an interface as library api for navigation or lens-specific analysis. + status: provisional + introduced_in: '0.1' +- id: fiam.family.plugin-interface + scheme: fiam.scheme.family-label + preferred_label: plugin interface + definition: Derived family label classifying an interface as plugin interface for navigation or lens-specific analysis. + status: provisional + introduced_in: '0.1' + broader: + - fiam.family.library-api +- id: fiam.family.programmatic-api + scheme: fiam.scheme.family-label + preferred_label: programmatic api + definition: Derived family label classifying an interface as programmatic api for navigation or lens-specific analysis. + status: provisional + introduced_in: '0.1' +- id: fiam.flow.authentication-choreography + scheme: fiam.scheme.flow-type + preferred_label: authentication choreography + definition: Multi-step interaction flow whose combined semantics establish or verify authentication across several participants + and interfaces. + status: provisional + introduced_in: '0.1' +- id: fiam.flow.message-propagation + scheme: fiam.scheme.flow-type + preferred_label: message propagation + definition: A multi-step asynchronous flow linking message production or sending to later message consumption or processing, + normally through a mediated Channel. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/ +- id: fiam.flow.orchestration + scheme: fiam.scheme.flow-type + preferred_label: orchestration + definition: A multi-step flow coordinated by an initiating/control participant. + status: provisional + introduced_in: '0.2' +- id: fiam.information-resource.api-resource-collection + scheme: fiam.scheme.information-resource-kind + preferred_label: API resource collection + definition: An addressable collection of resource instances exposed through an API. + status: candidate + introduced_in: '0.2' +- id: fiam.information-resource.api-resource-object + scheme: fiam.scheme.information-resource-kind + preferred_label: API resource object + definition: A concrete addressable resource/object represented through an API. + status: candidate + introduced_in: '0.2' +- id: fiam.information-resource.append-log + scheme: fiam.scheme.information-resource-kind + preferred_label: append log + definition: An ordered or partitioned information log to which records/events are appended and from which they can be read. + status: candidate + introduced_in: '0.2' +- id: fiam.information-resource.configuration-object + scheme: fiam.scheme.information-resource-kind + preferred_label: configuration object + definition: A structured object whose information is consumed as configuration by another component. + status: candidate + introduced_in: '0.2' +- id: fiam.information-resource.database-collection + scheme: fiam.scheme.information-resource-kind + preferred_label: database collection + definition: A named collection-like information resource managed by a database system when a more specific relational/document/key-value + kind is not established. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/db/database-spans/ +- id: fiam.information-resource.database-namespace + scheme: fiam.scheme.information-resource-kind + preferred_label: database namespace + definition: Database-level namespace/catalog/schema locus when telemetry identifies a database namespace but no concrete + collection/table. + status: provisional + introduced_in: '0.2' +- id: fiam.information-resource.environment-entry + scheme: fiam.scheme.information-resource-kind + preferred_label: environment entry + definition: A process environment key/value information resource. + status: candidate + introduced_in: '0.2' +- id: fiam.information-resource.file + scheme: fiam.scheme.information-resource-kind + preferred_label: file + definition: A filesystem or file-like information object. + status: candidate + introduced_in: '0.2' +- id: fiam.information-resource.filesystem-directory + scheme: fiam.scheme.information-resource-kind + preferred_label: filesystem directory + definition: A filesystem directory serving as an identifiable information-bearing collection/locus. + status: candidate + introduced_in: '0.2' +- id: fiam.information-resource.key-value-map + scheme: fiam.scheme.information-resource-kind + preferred_label: key-value map + definition: A collection/state represented as key/value pairs. + status: candidate + introduced_in: '0.2' +- id: fiam.information-resource.object-collection + scheme: fiam.scheme.information-resource-kind + preferred_label: object collection + definition: A collection of objects selected or grouped within an object store or similar namespace. + status: candidate + introduced_in: '0.2' +- id: fiam.information-resource.object-store-bucket + scheme: fiam.scheme.information-resource-kind + preferred_label: object-store bucket + definition: A provider-native object-store bucket that contains named objects. + status: candidate + introduced_in: '0.2' +- id: fiam.information-resource.relational-table + scheme: fiam.scheme.information-resource-kind + preferred_label: relational table + definition: A named relational table containing rows under a defined column schema. + status: candidate + introduced_in: '0.2' +- id: fiam.information-shape.argument-set + scheme: fiam.scheme.information-shape-kind + preferred_label: argument-set shape + definition: A structured set of command/function input arguments or options. + status: provisional + introduced_in: '0.2' +- id: fiam.information-shape.collection + scheme: fiam.scheme.information-shape-kind + preferred_label: collection shape + definition: A shape representing a collection or sequence of element-shaped values. + status: provisional + introduced_in: '0.2' +- id: fiam.information-shape.envelope + scheme: fiam.scheme.information-shape-kind + preferred_label: envelope shape + definition: A structured wrapper shape that contains metadata and/or an embedded payload shape. + status: provisional + introduced_in: '0.2' +- id: fiam.information-shape.object + scheme: fiam.scheme.information-shape-kind + preferred_label: object shape + definition: A structured information shape composed of named members or properties. + status: provisional + introduced_in: '0.2' +- id: fiam.information-shape.opaque + scheme: fiam.scheme.information-shape-kind + preferred_label: opaque shape + definition: A known information boundary whose internal structure is intentionally unspecified or unknown. + status: provisional + introduced_in: '0.2' +- id: fiam.information-shape.record + scheme: fiam.scheme.information-shape-kind + preferred_label: record shape + definition: A structured record/row-like information shape with named fields. + status: deprecated + introduced_in: '0.2' + replaced_by: + - fiam.information-shape.object + deprecated_reason: object and record both represented structured named-member shapes and caused a technology/culture-specific + distinction in the Core vocabulary. +- id: fiam.information-shape.scalar + scheme: fiam.scheme.information-shape-kind + preferred_label: scalar shape + definition: A shape representing an atomic or scalar value domain. + status: provisional + introduced_in: '0.2' +- id: fiam.information-shape.union + scheme: fiam.scheme.information-shape-kind + preferred_label: union shape + definition: A shape whose admissible values may conform to one of multiple alternative shapes. + status: provisional + introduced_in: '0.2' +- id: fiam.interaction-status.attempted + scheme: fiam.scheme.interaction-realization-status + preferred_label: attempted + definition: Execution of an interaction was attempted. + status: provisional + introduced_in: 0.1.1 +- id: fiam.interaction-status.authorized + scheme: fiam.scheme.interaction-realization-status + preferred_label: authorized + definition: An interaction has been authorized to proceed but execution is not yet asserted. + status: provisional + introduced_in: 0.1.1 +- id: fiam.interaction-status.completed + scheme: fiam.scheme.interaction-realization-status + preferred_label: completed + definition: The interaction completed according to its modeled success semantics. + status: provisional + introduced_in: 0.1.1 +- id: fiam.interaction-status.executed + scheme: fiam.scheme.interaction-realization-status + preferred_label: executed + definition: The interaction was actually executed. + status: provisional + introduced_in: 0.1.1 +- id: fiam.interaction-status.failed + scheme: fiam.scheme.interaction-realization-status + preferred_label: failed + definition: Execution was attempted but did not complete successfully. + status: provisional + introduced_in: 0.1.1 +- id: fiam.interaction-status.proposed + scheme: fiam.scheme.interaction-realization-status + preferred_label: proposed + definition: An interaction has been proposed or requested but has not yet been authorized/executed. + status: provisional + introduced_in: 0.1.1 +- id: fiam.interaction-status.rejected + scheme: fiam.scheme.interaction-realization-status + preferred_label: rejected + definition: The proposed/requested interaction was intentionally rejected or denied. + status: provisional + introduced_in: 0.1.1 +- id: fiam.interaction-style.command + scheme: fiam.scheme.interaction-style + preferred_label: command + definition: An interaction whose primary semantic intent is to request an action or state change. + status: provisional + introduced_in: '0.1' +- id: fiam.interaction-style.function-call + scheme: fiam.scheme.interaction-style + preferred_label: function call + definition: An in-process or language-runtime invocation of a callable contract. + status: provisional + introduced_in: '0.1' +- id: fiam.interaction-style.publish + scheme: fiam.scheme.interaction-style + preferred_label: publish + definition: An interaction that emits a message or event to a channel without targeting a single coupled consumer. + status: provisional + introduced_in: '0.1' +- id: fiam.interaction-style.query + scheme: fiam.scheme.interaction-style + preferred_label: query + definition: An interaction whose primary semantic intent is to retrieve or compute information without a commanded state + mutation. + status: provisional + introduced_in: '0.1' +- id: fiam.interaction-style.redirect-request + scheme: fiam.scheme.interaction-style + preferred_label: redirect request + definition: Interaction style characterized by redirect request. + status: provisional + introduced_in: '0.1' +- id: fiam.interaction-style.redirect-response + scheme: fiam.scheme.interaction-style + preferred_label: redirect response + definition: Interaction style characterized by redirect response. + status: provisional + introduced_in: '0.1' +- id: fiam.interaction-style.request-response + scheme: fiam.scheme.interaction-style + preferred_label: request response + definition: A correlated exchange in which an initiator sends a request and expects a corresponding response. + status: provisional + introduced_in: '0.1' +- id: fiam.interaction-style.rpc + scheme: fiam.scheme.interaction-style + preferred_label: rpc + definition: Invocation semantics in which a participant requests execution of a named remote or abstract procedure/method. + status: provisional + introduced_in: '0.1' +- id: fiam.interaction-style.session-command-response + scheme: fiam.scheme.interaction-style + preferred_label: session command response + definition: Interaction style characterized by session command response. + status: provisional + introduced_in: '0.1' +- id: fiam.interaction-style.subscribe + scheme: fiam.scheme.interaction-style + preferred_label: subscribe + definition: An interaction that establishes or represents interest in messages/events from a channel or publisher. + status: provisional + introduced_in: '0.1' +- id: fiam.mediation.brokered + scheme: fiam.scheme.mediation + preferred_label: brokered + definition: Communication is mediated by a broker or equivalent intermediary resource that decouples producers from consumers. + status: provisional + introduced_in: '0.1' +- id: fiam.mediation.direct + scheme: fiam.scheme.mediation + preferred_label: direct + definition: Participants communicate without an independent brokered mediation resource. + status: provisional + introduced_in: '0.1' +- id: fiam.mutability.append-only + scheme: fiam.scheme.mutability + preferred_label: append-only + definition: New information is appended while existing ordered entries are not updated in place. + status: candidate + introduced_in: '0.2' +- id: fiam.mutability.immutable + scheme: fiam.scheme.mutability + preferred_label: immutable + definition: Existing contents/state are not intended to change after creation. + status: candidate + introduced_in: '0.2' +- id: fiam.mutability.mutable + scheme: fiam.scheme.mutability + preferred_label: mutable + definition: Existing contents/state may be changed. + status: candidate + introduced_in: '0.2' +- id: fiam.mutability.replaceable + scheme: fiam.scheme.mutability + preferred_label: replaceable + definition: The resource value/object may be replaced as a whole. + status: candidate + introduced_in: '0.2' +- id: fiam.node-type.application + scheme: fiam.scheme.node-type + preferred_label: application + definition: System node type representing application. + status: provisional + introduced_in: '0.1' +- id: fiam.node-type.broker + scheme: fiam.scheme.node-type + preferred_label: broker + definition: System node type representing broker. + status: provisional + introduced_in: '0.1' +- id: fiam.node-type.database + scheme: fiam.scheme.node-type + preferred_label: database + definition: System node type representing database. + status: provisional + introduced_in: '0.1' +- id: fiam.node-type.identity-provider + scheme: fiam.scheme.node-type + preferred_label: identity provider + definition: System node type representing identity provider. + status: provisional + introduced_in: '0.1' +- id: fiam.node-type.library-module + scheme: fiam.scheme.node-type + preferred_label: library module + definition: System node type representing library module. + status: provisional + introduced_in: '0.1' +- id: fiam.node-type.process + scheme: fiam.scheme.node-type + preferred_label: process + definition: System node type representing process. + status: provisional + introduced_in: '0.1' +- id: fiam.node-type.service + scheme: fiam.scheme.node-type + preferred_label: service + definition: System node type representing service. + status: provisional + introduced_in: '0.1' +- id: fiam.node-type.user-agent + scheme: fiam.scheme.node-type + preferred_label: user agent + definition: System node type representing user agent. + status: provisional + introduced_in: '0.1' +- id: fiam.ordering.partition + scheme: fiam.scheme.ordering-scope + preferred_label: partition + definition: Ordering is defined only within a partition or equivalent ordered substream. + status: provisional + introduced_in: '0.1' +- id: fiam.property.availability + scheme: fiam.scheme.property + preferred_label: availability + definition: Current or time-bounded availability/existence of a dynamically discovered operation, endpoint, or realization. + status: provisional + introduced_in: 0.1.1 +- id: fiam.property.communication-protocol + scheme: fiam.scheme.property + preferred_label: communication protocol + definition: 'Assertion predicate/property: communication protocol.' + status: provisional + introduced_in: '0.1' +- id: fiam.property.database-collection-name + scheme: fiam.scheme.property + preferred_label: database collection name + definition: Named database collection or table observed for a database client operation. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/db/database-spans/ +- id: fiam.property.database-namespace + scheme: fiam.scheme.property + preferred_label: database namespace + definition: Database namespace observed for a database client operation. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/db/database-spans/ +- id: fiam.property.database-operation-name + scheme: fiam.scheme.property + preferred_label: database operation name + definition: Database operation or command name observed for a database client operation. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/db/database-spans/ +- id: fiam.property.database-response-status-code + scheme: fiam.scheme.property + preferred_label: database response status code + definition: Database response status code observed for an interaction. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/db/database-spans/ +- id: fiam.property.database-system-name + scheme: fiam.scheme.property + preferred_label: database system name + definition: Database management system product identified by client instrumentation. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/db/database-spans/ +- id: fiam.property.deployment-environment-name + scheme: fiam.scheme.property + preferred_label: deployment environment name + definition: Observed deployment environment/tier name. + status: provisional + introduced_in: '0.2' +- id: fiam.property.execution-boundary + scheme: fiam.scheme.property + preferred_label: execution boundary + definition: 'Assertion predicate/property: execution boundary.' + status: provisional + introduced_in: '0.1' +- id: fiam.property.family-label + scheme: fiam.scheme.property + preferred_label: family label + definition: Derived family classification value emitted by a Lens; when stored, evidence mode should be inferred. + status: provisional + introduced_in: 0.1.1 +- id: fiam.property.http-method + scheme: fiam.scheme.property + preferred_label: HTTP method + definition: HTTP request method associated with an operation or interaction. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/ +- id: fiam.property.http-response-status-code + scheme: fiam.scheme.property + preferred_label: HTTP response status code + definition: HTTP response status code observed for an interaction. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/ +- id: fiam.property.http-route + scheme: fiam.scheme.property + preferred_label: HTTP route + definition: Normalized HTTP route template or route associated with an operation. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/ +- id: fiam.property.k8s-cluster-name + scheme: fiam.scheme.property + preferred_label: Kubernetes cluster name + definition: Observed Kubernetes cluster name. + status: provisional + introduced_in: '0.2' +- id: fiam.property.k8s-cluster-uid + scheme: fiam.scheme.property + preferred_label: Kubernetes cluster UID + definition: Observed Kubernetes cluster UID or proxy UID. + status: provisional + introduced_in: '0.2' +- id: fiam.property.k8s-namespace-name + scheme: fiam.scheme.property + preferred_label: Kubernetes namespace name + definition: Observed Kubernetes namespace name. + status: provisional + introduced_in: '0.2' +- id: fiam.property.mediation + scheme: fiam.scheme.property + preferred_label: mediation + definition: 'Assertion predicate/property: mediation.' + status: provisional + introduced_in: '0.1' +- id: fiam.property.messaging-destination-name + scheme: fiam.scheme.property + preferred_label: messaging destination name + definition: Logical destination name observed for a messaging interaction. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/ +- id: fiam.property.messaging-operation-name + scheme: fiam.scheme.property + preferred_label: messaging operation name + definition: System-specific messaging operation name observed for an interaction. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/ +- id: fiam.property.messaging-operation-type + scheme: fiam.scheme.property + preferred_label: messaging operation type + definition: Normalized OpenTelemetry messaging operation type such as create, send, receive, process, or settle. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/ +- id: fiam.property.messaging-system + scheme: fiam.scheme.property + preferred_label: messaging system + definition: Messaging system identified by runtime instrumentation, such as kafka or rabbitmq. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/ +- id: fiam.property.multi-party + scheme: fiam.scheme.property + preferred_label: multi party + definition: 'Assertion predicate/property: multi party.' + status: provisional + introduced_in: '0.1' +- id: fiam.property.network-peer-address + scheme: fiam.scheme.property + preferred_label: network peer address + definition: Observed peer address of the actual network connection; supplementary locator evidence, not normally the primary + logical endpoint identity. + status: provisional + introduced_in: '0.2' +- id: fiam.property.network-protocol-version + scheme: fiam.scheme.property + preferred_label: network protocol version + definition: Observed or declared actual protocol version string, such as 1.1, 2, or 3. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/ +- id: fiam.property.network-required + scheme: fiam.scheme.property + preferred_label: network required + definition: 'Assertion predicate/property: network required.' + status: provisional + introduced_in: '0.1' +- id: fiam.property.otel-span-kind + scheme: fiam.scheme.property + preferred_label: OpenTelemetry span kind + definition: OpenTelemetry SpanKind observed for an interaction, retained as runtime evidence rather than used as a FIAM + interface family. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/otel/trace/api/ +- id: fiam.property.rpc-method + scheme: fiam.scheme.property + preferred_label: RPC method + definition: Fully-qualified logical RPC method name observed from the RPC interface perspective. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/rpc/rpc-spans/ +- id: fiam.property.rpc-response-status-code + scheme: fiam.scheme.property + preferred_label: RPC response status code + definition: RPC response status code observed for an interaction. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/rpc/rpc-spans/ +- id: fiam.property.rpc-system-name + scheme: fiam.scheme.property + preferred_label: RPC system name + definition: RPC system identified by runtime instrumentation, such as grpc, dubbo, connectrpc, or jsonrpc. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/rpc/rpc-spans/ +- id: fiam.property.runtime-active + scheme: fiam.scheme.property + preferred_label: runtime active + definition: Whether an aggregate is considered active under the ingest source coverage semantics. + status: provisional + introduced_in: '0.2' +- id: fiam.property.runtime-error-count + scheme: fiam.scheme.property + preferred_label: runtime error count + definition: Number of error occurrences folded into one architectural observation aggregate. + status: provisional + introduced_in: '0.2' +- id: fiam.property.runtime-first-seen + scheme: fiam.scheme.property + preferred_label: runtime first seen + definition: Earliest observation time retained for an architectural runtime aggregate. + status: provisional + introduced_in: '0.2' +- id: fiam.property.runtime-last-seen + scheme: fiam.scheme.property + preferred_label: runtime last seen + definition: Latest observation time retained for an architectural runtime aggregate. + status: provisional + introduced_in: '0.2' +- id: fiam.property.runtime-observation-count + scheme: fiam.scheme.property + preferred_label: runtime observation count + definition: Number of runtime occurrences folded into one architectural observation aggregate. + status: provisional + introduced_in: '0.2' +- id: fiam.property.security-override + scheme: fiam.scheme.property + preferred_label: security override + definition: Declared operation-level security override state such as none or operation-specific. + status: provisional + introduced_in: '0.2' +- id: fiam.property.server-address + scheme: fiam.scheme.property + preferred_label: server address + definition: Server address associated with an endpoint or observed interaction. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/ +- id: fiam.property.server-port + scheme: fiam.scheme.property + preferred_label: server port + definition: Server port associated with an endpoint or observed interaction. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/ +- id: fiam.property.service-name + scheme: fiam.scheme.property + preferred_label: service name + definition: Runtime service name, typically mapped from OpenTelemetry service.name. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/ +- id: fiam.property.service-namespace + scheme: fiam.scheme.property + preferred_label: service namespace + definition: Runtime service namespace, typically mapped from OpenTelemetry service.namespace. + status: provisional + introduced_in: '0.2' + sources: + - https://opentelemetry.io/docs/specs/semconv/ +- id: fiam.property.service-peer-name + scheme: fiam.scheme.property + preferred_label: service peer name + definition: Observed logical peer service name, preferably mapped from OpenTelemetry service.peer.name. + status: provisional + introduced_in: '0.2' +- id: fiam.property.transport-independent + scheme: fiam.scheme.property + preferred_label: transport independent + definition: 'Assertion predicate/property: transport independent.' + status: provisional + introduced_in: '0.1' +- id: fiam.protocol.graphql + scheme: fiam.scheme.protocol + preferred_label: GraphQL + definition: Deprecated classification of GraphQL as a protocol. Use fiam.tech.graphql; transport is modeled independently. + status: deprecated + introduced_in: '0.1' + replaced_by: + - fiam.tech.graphql + migration_note: GraphQL semantics are transport-independent and should not be classified as the transport/application protocol + layer. +- id: fiam.protocol.grpc + scheme: fiam.scheme.protocol + preferred_label: gRPC + definition: gRPC RPC framework/protocol supporting unary and streaming method invocation. + status: provisional + introduced_in: '0.1' +- id: fiam.protocol.http + scheme: fiam.scheme.protocol + preferred_label: HTTP + definition: Hypertext Transfer Protocol family used as an application transfer protocol. + status: provisional + introduced_in: '0.1' +- id: fiam.protocol.http1.1 + scheme: fiam.scheme.protocol + preferred_label: HTTP/1.1 + definition: HTTP/1.1 protocol version. + status: provisional + introduced_in: '0.2' + broader: + - fiam.protocol.http +- id: fiam.protocol.http2 + scheme: fiam.scheme.protocol + preferred_label: HTTP/2 + definition: HTTP/2 protocol version. + status: provisional + introduced_in: '0.1' + broader: + - fiam.protocol.http +- id: fiam.protocol.http3 + scheme: fiam.scheme.protocol + preferred_label: HTTP/3 + definition: HTTP/3 protocol version. + status: provisional + introduced_in: '0.2' + broader: + - fiam.protocol.http +- id: fiam.protocol.json-rpc-2.0 + scheme: fiam.scheme.protocol + preferred_label: '0' + definition: JSON-RPC 2.0 request/response and notification protocol encoded with JSON data structures. + status: provisional + introduced_in: '0.1' +- id: fiam.protocol.kafka + scheme: fiam.scheme.protocol + preferred_label: kafka + definition: Apache Kafka client/broker protocol used for durable brokered record exchange. + status: provisional + introduced_in: '0.1' +- id: fiam.protocol.mcp + scheme: fiam.scheme.protocol + preferred_label: MCP + definition: Model Context Protocol, an application protocol for contextual interaction between AI hosts/clients and servers + exposing tools, resources, prompts, and related capabilities. + status: provisional + introduced_in: '0.1' +- id: fiam.protocol.oauth2 + scheme: fiam.scheme.protocol + preferred_label: OAuth 2.0 + definition: OAuth 2.0 authorization framework used for delegated authorization and token issuance. + status: provisional + introduced_in: '0.1' +- id: fiam.protocol.openid-connect + scheme: fiam.scheme.protocol + preferred_label: OpenID Connect + definition: OpenID Connect identity protocol/profile layered on OAuth 2.0. + status: provisional + introduced_in: '0.1' +- id: fiam.protocol.postgresql-frontend-backend + scheme: fiam.scheme.protocol + preferred_label: PostgreSQL frontend/backend protocol + definition: PostgreSQL frontend/backend wire protocol used between database clients and PostgreSQL servers. + status: provisional + introduced_in: '0.1' +- id: fiam.protocol.tls + scheme: fiam.scheme.protocol + preferred_label: TLS + definition: Transport Layer Security protocol used to protect communication channels. + status: provisional + introduced_in: '0.1' +- id: fiam.purpose.authentication + scheme: fiam.scheme.purpose + preferred_label: authentication + definition: Purpose facet indicating authentication. + status: provisional + introduced_in: '0.1' +- id: fiam.purpose.domain-event-publication + scheme: fiam.scheme.purpose + preferred_label: domain event publication + definition: Purpose facet indicating domain event publication. + status: provisional + introduced_in: '0.1' +- id: fiam.purpose.extension-point + scheme: fiam.scheme.purpose + preferred_label: extension point + definition: Purpose facet indicating extension point. + status: provisional + introduced_in: '0.1' +- id: fiam.purpose.identity-federation + scheme: fiam.scheme.purpose + preferred_label: identity federation + definition: Purpose facet indicating identity federation. + status: provisional + introduced_in: '0.1' +- id: fiam.purpose.mutation + scheme: fiam.scheme.purpose + preferred_label: mutation + definition: Purpose facet indicating mutation. + status: provisional + introduced_in: '0.1' +- id: fiam.purpose.query + scheme: fiam.scheme.purpose + preferred_label: query + definition: Purpose facet indicating query. + status: provisional + introduced_in: '0.1' +- id: fiam.purpose.telemetry-exchange + scheme: fiam.scheme.purpose + preferred_label: telemetry exchange + definition: Purpose facet indicating telemetry exchange. + status: provisional + introduced_in: '0.1' +- id: fiam.purpose.tool-invocation + scheme: fiam.scheme.purpose + preferred_label: tool invocation + definition: Purpose facet indicating tool invocation. + status: provisional + introduced_in: '0.1' +- id: fiam.purpose.transactional-data-access + scheme: fiam.scheme.purpose + preferred_label: transactional data access + definition: Purpose facet indicating transactional data access. + status: provisional + introduced_in: '0.1' +- id: fiam.relation.accepts-shape + scheme: fiam.scheme.relation + preferred_label: accepts shape + definition: Relates an Operation, Binding, or Interaction to an InformationShape accepted as input. + status: provisional + introduced_in: '0.2' + domain_kinds: + - operation + - binding + - interaction + range_kinds: + - information-shape +- id: fiam.relation.alias-of + scheme: fiam.scheme.relation + preferred_label: alias of + definition: Subject identifier/name is an alias for the object record; this does not authorize record merging. + status: provisional + introduced_in: 0.1.1 + relation_family: identity + domain_kinds: &id001 + - participant + - system-node + - port + - interface-contract + - operation + - binding + - endpoint + - channel + - information-resource + - information-shape + - interaction + - interaction-flow + - artifact + - zone + - security-profile + range_kinds: *id001 +- id: fiam.relation.appends-to + scheme: fiam.scheme.relation + preferred_label: appends to + definition: Subject Interaction appends information to the object InformationResource. + status: candidate + introduced_in: '0.2' + domain_kinds: + - interaction + range_kinds: + - information-resource +- id: fiam.relation.backed-by + scheme: fiam.scheme.relation + preferred_label: backed by + definition: Subject Channel or InformationResource is materially backed by the object InformationResource. + status: candidate + introduced_in: '0.2' + domain_kinds: + - channel + - information-resource + range_kinds: + - information-resource +- id: fiam.relation.carries + scheme: fiam.scheme.relation + preferred_label: carries + definition: Subject lower-level binding or interface carries interactions of the object higher-level binding/interface. + status: provisional + introduced_in: 0.1.1 + relation_family: composition + domain_kinds: + - binding + - channel + range_kinds: + - binding + - interaction +- id: fiam.relation.client-of + scheme: fiam.scheme.relation + preferred_label: client of + definition: Subject acts as a client/consumer of the object contract or binding in the modeled context. + status: provisional + introduced_in: 0.1.1 + relation_family: dependency + domain_kinds: + - system-node + - port + - binding + range_kinds: + - system-node + - port + - binding +- id: fiam.relation.conforms-to-shape + scheme: fiam.scheme.relation + preferred_label: conforms to shape + definition: Relates an InformationResource to the InformationShape governing the resource as a whole. + status: provisional + introduced_in: '0.2' + domain_kinds: + - information-resource + range_kinds: + - information-shape +- id: fiam.relation.contained-in + scheme: fiam.scheme.relation + preferred_label: contained in + definition: Subject InformationResource is logically/structurally contained in the object InformationResource. + status: candidate + introduced_in: '0.2' + domain_kinds: + - information-resource + range_kinds: + - information-resource +- id: fiam.relation.corresponds-to + scheme: fiam.scheme.relation + preferred_label: corresponds to + definition: Subject and object have a modeled correspondence that is weaker than identity. + status: provisional + introduced_in: 0.1.1 + relation_family: identity + domain_kinds: *id001 + range_kinds: *id001 +- id: fiam.relation.derived-from + scheme: fiam.scheme.relation + preferred_label: derived from + definition: Subject was derived from the object artifact, model element, or observation without asserting identity. + status: provisional + introduced_in: 0.1.1 + relation_family: provenance + domain_kinds: + - interface-contract + - operation + - information-resource + - information-shape + - artifact + range_kinds: + - interface-contract + - operation + - information-resource + - information-shape + - artifact +- id: fiam.relation.discovered-via + scheme: fiam.scheme.relation + preferred_label: discovered via + definition: Subject entity or capability is discovered through the object operation, artifact, binding, or discovery surface. + status: provisional + introduced_in: 0.1.1 + relation_family: discovery + domain_kinds: + - interface-contract + - operation + - binding + - endpoint + - information-resource + - information-shape + range_kinds: + - operation + - binding + - endpoint + - artifact +- id: fiam.relation.element-shape + scheme: fiam.scheme.relation + preferred_label: element shape + definition: Relates a collection-like InformationResource or InformationShape to the InformationShape of its elements. + status: provisional + introduced_in: '0.2' + domain_kinds: + - information-resource + - information-shape + range_kinds: + - information-shape +- id: fiam.relation.embedded-in + scheme: fiam.scheme.relation + preferred_label: embedded in + definition: Subject contract/interface description is embedded within the object operation, contract, or artifact. + status: provisional + introduced_in: 0.1.1 + relation_family: composition + domain_kinds: + - interface-contract + - information-shape + range_kinds: + - operation + - information-shape +- id: fiam.relation.embeds + scheme: fiam.scheme.relation + preferred_label: embeds + definition: Subject contract, operation, or artifact embeds the object contract or interface description as part of its + information surface. + status: provisional + introduced_in: 0.1.1 + relation_family: composition + domain_kinds: + - operation + - information-shape + range_kinds: + - interface-contract + - information-shape +- id: fiam.relation.embeds-shape + scheme: fiam.scheme.relation + preferred_label: embeds shape + definition: Relates an InformationShape to another InformationShape embedded as a nested payload or member. + status: provisional + introduced_in: '0.2' + domain_kinds: + - information-shape + range_kinds: + - information-shape +- id: fiam.relation.errors-with-shape + scheme: fiam.scheme.relation + preferred_label: errors with shape + definition: Relates an Operation, Binding, or Interaction to an InformationShape used for an error/failure result. + status: provisional + introduced_in: '0.2' + domain_kinds: + - operation + - binding + - interaction + range_kinds: + - information-shape +- id: fiam.relation.exposure-of + scheme: fiam.scheme.relation + preferred_label: exposure of + definition: Subject is a concrete exposure/realization of the object logical contract or capability. + status: provisional + introduced_in: 0.1.1 + relation_family: identity + domain_kinds: + - port + - binding + - endpoint + range_kinds: + - interface-contract + - port + - binding +- id: fiam.relation.fulfills + scheme: fiam.scheme.relation + preferred_label: fulfills + definition: Subject realized/executed interaction fulfills, realizes, or discharges the object proposed or requested interaction/intention. + status: provisional + introduced_in: 0.1.1 + relation_family: realization + domain_kinds: + - interaction + - interaction-flow + range_kinds: + - interaction + - interaction-flow +- id: fiam.relation.instance-of + scheme: fiam.scheme.relation + preferred_label: instance of + definition: Subject is a concrete deployed/runtime instance of the object definition, template, or contract family. + status: provisional + introduced_in: 0.1.1 + relation_family: identity + domain_kinds: *id001 + range_kinds: *id001 +- id: fiam.relation.materializes-as + scheme: fiam.scheme.relation + preferred_label: materializes as + definition: Subject InformationResource is projected/materialized as the object InformationResource. + status: candidate + introduced_in: '0.2' + domain_kinds: + - information-resource + range_kinds: + - information-resource +- id: fiam.relation.negotiates + scheme: fiam.scheme.relation + preferred_label: negotiates + definition: Subject interaction or binding negotiates the object contract, capability, protocol, or realization. + status: provisional + introduced_in: 0.1.1 + relation_family: discovery + domain_kinds: + - operation + - binding + - interaction + range_kinds: + - interface-contract + - binding + - information-shape +- id: fiam.relation.observationally-equivalent-to + scheme: fiam.scheme.relation + preferred_label: observationally equivalent to + definition: Subject and object are equivalent under a stated observation/lens, without asserting underlying entity identity. + status: provisional + introduced_in: 0.1.1 + relation_family: identity + domain_kinds: *id001 + range_kinds: *id001 +- id: fiam.relation.produces-shape + scheme: fiam.scheme.relation + preferred_label: produces shape + definition: Relates an Operation, Binding, or Interaction to an InformationShape produced as successful output. + status: provisional + introduced_in: '0.2' + domain_kinds: + - operation + - binding + - interaction + range_kinds: + - information-shape +- id: fiam.relation.projection-of + scheme: fiam.scheme.relation + preferred_label: projection of + definition: Relates an InformationShape to a distinct source InformationShape from which it is intentionally projected or + selected. + status: provisional + introduced_in: '0.2' + domain_kinds: + - information-shape + range_kinds: + - information-shape + relation_family: identity-derivation +- id: fiam.relation.reads-from + scheme: fiam.scheme.relation + preferred_label: reads from + definition: Subject Interaction reads information from the object InformationResource. + status: candidate + introduced_in: '0.2' + domain_kinds: + - interaction + range_kinds: + - information-resource +- id: fiam.relation.same-entity-as + scheme: fiam.scheme.relation + preferred_label: same entity as + definition: Subject and object are asserted to denote the same real-world entity. Preserve both source records and evidence; + do not auto-merge. + status: provisional + introduced_in: 0.1.1 + relation_family: identity + domain_kinds: *id001 + range_kinds: *id001 +- id: fiam.relation.selection-of + scheme: fiam.scheme.relation + preferred_label: selection of + definition: Subject InformationResource is a logical selection/view over the object InformationResource. + status: candidate + introduced_in: '0.2' + domain_kinds: + - information-resource + range_kinds: + - information-resource +- id: fiam.relation.targets + scheme: fiam.scheme.relation + preferred_label: targets + definition: Subject Interaction/Operation targets the object InformationResource in a generic sense. + status: candidate + introduced_in: '0.2' + domain_kinds: + - interaction + - operation + range_kinds: + - information-resource +- id: fiam.relation.tunneled-through + scheme: fiam.scheme.relation + preferred_label: tunneled through + definition: Subject interface/binding is tunneled through the object interface/binding. + status: provisional + introduced_in: 0.1.1 + relation_family: composition + domain_kinds: + - binding + - interaction + range_kinds: + - binding +- id: fiam.relation.upgraded-from + scheme: fiam.scheme.relation + preferred_label: upgraded from + definition: Subject binding/protocol state is established by upgrading from the object binding/protocol state. + status: provisional + introduced_in: 0.1.1 + relation_family: composition + domain_kinds: + - binding + range_kinds: + - binding +- id: fiam.relation.uses + scheme: fiam.scheme.relation + preferred_label: uses + definition: Subject depends on or uses the object architectural element without implying transport encapsulation. + status: provisional + introduced_in: 0.1.1 + relation_family: dependency + domain_kinds: + - system-node + - port + - interface-contract + - operation + - binding + - interaction + - interaction-flow + range_kinds: + - port + - interface-contract + - operation + - binding + - endpoint + - channel + - information-resource +- id: fiam.relation.version-of + scheme: fiam.scheme.relation + preferred_label: version of + definition: Subject is a version/revision of the object architectural element. + status: provisional + introduced_in: 0.1.1 + relation_family: identity + domain_kinds: *id001 + range_kinds: *id001 +- id: fiam.relation.watches + scheme: fiam.scheme.relation + preferred_label: watches + definition: Subject Interaction observes changes to the object InformationResource over time. + status: candidate + introduced_in: '0.2' + domain_kinds: + - interaction + range_kinds: + - information-resource +- id: fiam.relation.writes-to + scheme: fiam.scheme.relation + preferred_label: writes to + definition: Subject Interaction writes or mutates information in the object InformationResource. + status: candidate + introduced_in: '0.2' + domain_kinds: + - interaction + range_kinds: + - information-resource +- id: fiam.representation.binary + scheme: fiam.scheme.representation + preferred_label: binary + definition: Opaque binary/octet-stream information representation. + status: provisional + introduced_in: '0.2' +- id: fiam.representation.cbor + scheme: fiam.scheme.representation + preferred_label: CBOR + definition: Concise Binary Object Representation (CBOR) encoding. + status: provisional + introduced_in: '0.2' +- id: fiam.representation.command-tokens + scheme: fiam.scheme.representation + preferred_label: command tokens + definition: Command-line token/argument representation such as argv/options. + status: provisional + introduced_in: '0.2' +- id: fiam.representation.form-urlencoded + scheme: fiam.scheme.representation + preferred_label: form URL encoded + definition: application/x-www-form-urlencoded representation. + status: provisional + introduced_in: '0.2' +- id: fiam.representation.graphql-document + scheme: fiam.scheme.representation + preferred_label: graphql document + definition: 'Information representation or serialization: graphql document.' + status: provisional + introduced_in: '0.1' +- id: fiam.representation.json + scheme: fiam.scheme.representation + preferred_label: json + definition: 'Information representation or serialization: json.' + status: provisional + introduced_in: '0.1' +- id: fiam.representation.language-native-object + scheme: fiam.scheme.representation + preferred_label: language-native object + definition: In-process runtime/native language object representation. + status: provisional + introduced_in: '0.2' +- id: fiam.representation.protobuf + scheme: fiam.scheme.representation + preferred_label: Protocol Buffers + definition: 'Information representation or serialization: Protocol Buffers.' + status: provisional + introduced_in: '0.1' +- id: fiam.representation.sql-row + scheme: fiam.scheme.representation + preferred_label: SQL row values + definition: Database row/value representation as exposed through a SQL/database interface. + status: provisional + introduced_in: '0.2' +- id: fiam.representation.text + scheme: fiam.scheme.representation + preferred_label: text + definition: Plain textual representation. + status: provisional + introduced_in: '0.2' +- id: fiam.representation.xml + scheme: fiam.scheme.representation + preferred_label: XML + definition: XML information representation. + status: provisional + introduced_in: '0.2' +- id: fiam.resource-scope.concrete-collection + scheme: fiam.scheme.resource-scope + preferred_label: concrete collection + definition: A concrete provider-native collection of information objects or records. + status: candidate + introduced_in: '0.2' +- id: fiam.resource-scope.concrete-instance + scheme: fiam.scheme.resource-scope + preferred_label: concrete instance + definition: A specific concrete information resource instance. + status: candidate + introduced_in: '0.2' +- id: fiam.resource-scope.logical-selection + scheme: fiam.scheme.resource-scope + preferred_label: logical selection + definition: A modeled selection/view over another information resource that may not itself be a provider-native object. + status: candidate + introduced_in: '0.2' +- id: fiam.resource-scope.shared-state + scheme: fiam.scheme.resource-scope + preferred_label: shared state + definition: An information resource used as shared state by multiple participants. + status: candidate + introduced_in: '0.2' +- id: fiam.resource-selector.environment-key + scheme: fiam.scheme.resource-selector + preferred_label: environment key + definition: Selects an environment variable/entry by key. + status: candidate + introduced_in: '0.2' +- id: fiam.resource-selector.filesystem-path + scheme: fiam.scheme.resource-selector + preferred_label: filesystem path + definition: Selects a filesystem resource by path. + status: candidate + introduced_in: '0.2' +- id: fiam.resource-selector.http-path-template + scheme: fiam.scheme.resource-selector + preferred_label: HTTP path template + definition: A logical API resource selected by an HTTP/OpenAPI path template. + status: provisional + introduced_in: '0.2' +- id: fiam.resource-selector.kafka-topic-name + scheme: fiam.scheme.resource-selector + preferred_label: Kafka topic name + definition: Selects a Kafka topic/log by topic name. + status: candidate + introduced_in: '0.2' +- id: fiam.resource-selector.kubernetes-object-ref + scheme: fiam.scheme.resource-selector + preferred_label: Kubernetes object reference + definition: Selects a Kubernetes object by group/version/kind/namespace/name identity. + status: candidate + introduced_in: '0.2' +- id: fiam.resource-selector.kubernetes-resource-path + scheme: fiam.scheme.resource-selector + preferred_label: Kubernetes resource path + definition: Selects a Kubernetes API resource collection/object by API path. + status: candidate + introduced_in: '0.2' +- id: fiam.resource-selector.s3-bucket-name + scheme: fiam.scheme.resource-selector + preferred_label: S3 bucket name + definition: Selects an S3 bucket by bucket name. + status: candidate + introduced_in: '0.2' +- id: fiam.resource-selector.s3-prefix + scheme: fiam.scheme.resource-selector + preferred_label: S3 key prefix + definition: Selects the logical set of S3 objects whose object keys begin with a prefix. + status: candidate + introduced_in: '0.2' +- id: fiam.resource-selector.sql-qualified-name + scheme: fiam.scheme.resource-selector + preferred_label: SQL qualified name + definition: Selects a database relation/table by qualified database/schema/name identity. + status: candidate + introduced_in: '0.2' +- id: fiam.role.authorization-server + scheme: fiam.scheme.participant-role + preferred_label: authorization server + definition: Participant role representing authorization server in a particular interaction or interface relationship. + status: provisional + introduced_in: '0.1' +- id: fiam.role.client + scheme: fiam.scheme.participant-role + preferred_label: client + definition: Participant role representing client in a particular interaction or interface relationship. + status: provisional + introduced_in: '0.1' +- id: fiam.role.consumer + scheme: fiam.scheme.participant-role + preferred_label: consumer + definition: Participant role representing consumer in a particular interaction or interface relationship. + status: provisional + introduced_in: '0.1' +- id: fiam.role.database-client + scheme: fiam.scheme.participant-role + preferred_label: database client + definition: Participant role representing database client in a particular interaction or interface relationship. + status: provisional + introduced_in: '0.1' + broader: + - fiam.role.client +- id: fiam.role.database-server + scheme: fiam.scheme.participant-role + preferred_label: database server + definition: Participant role representing database server in a particular interaction or interface relationship. + status: provisional + introduced_in: '0.1' + broader: + - fiam.role.server +- id: fiam.role.oidc-client + scheme: fiam.scheme.participant-role + preferred_label: oidc client + definition: Participant role representing oidc client in a particular interaction or interface relationship. + status: provisional + introduced_in: '0.1' + broader: + - fiam.role.client +- id: fiam.role.producer + scheme: fiam.scheme.participant-role + preferred_label: producer + definition: Participant role representing producer in a particular interaction or interface relationship. + status: provisional + introduced_in: '0.1' +- id: fiam.role.server + scheme: fiam.scheme.participant-role + preferred_label: server + definition: Participant role representing server in a particular interaction or interface relationship. + status: provisional + introduced_in: '0.1' +- id: fiam.role.service-consumer + scheme: fiam.scheme.participant-role + preferred_label: service consumer + definition: Participant role representing service consumer in a particular interaction or interface relationship. + status: provisional + introduced_in: '0.1' +- id: fiam.role.service-provider + scheme: fiam.scheme.participant-role + preferred_label: service provider + definition: Participant role representing service provider in a particular interaction or interface relationship. + status: provisional + introduced_in: '0.1' +- id: fiam.role.token-issuer + scheme: fiam.scheme.participant-role + preferred_label: token issuer + definition: Participant role representing token issuer in a particular interaction or interface relationship. + status: provisional + introduced_in: '0.1' +- id: fiam.runtime.jvm + scheme: fiam.scheme.runtime + preferred_label: JVM + definition: 'Execution runtime: JVM.' + status: provisional + introduced_in: '0.1' +- id: fiam.security.authentication.api-key + scheme: fiam.scheme.authentication-mechanism + preferred_label: API key + definition: Authentication or caller recognition using an API key credential. + status: provisional + introduced_in: '0.2' +- id: fiam.security.authentication.bearer-token + scheme: fiam.scheme.authentication-mechanism + preferred_label: bearer token + definition: Bearer-token authentication carried by an HTTP authentication scheme or equivalent. + status: provisional + introduced_in: '0.2' +- id: fiam.security.authentication.federated + scheme: fiam.scheme.authentication-mechanism + preferred_label: federated + definition: Authentication in which identity is established through a separate identity provider or federation relationship. + status: provisional + introduced_in: '0.1' +- id: fiam.security.authentication.http-basic + scheme: fiam.scheme.authentication-mechanism + preferred_label: HTTP Basic + definition: HTTP Basic authentication. + status: provisional + introduced_in: '0.2' +- id: fiam.security.authentication.mutual-tls + scheme: fiam.scheme.authentication-mechanism + preferred_label: mutual TLS + definition: Mutual TLS client authentication using a client certificate. + status: provisional + introduced_in: '0.2' +- id: fiam.security.authentication.oauth2 + scheme: fiam.scheme.authentication-mechanism + preferred_label: OAuth 2.0 + definition: Authentication/authorization access based on OAuth 2.0 authorization framework credentials. + status: provisional + introduced_in: '0.2' +- id: fiam.security.authentication.openid-connect + scheme: fiam.scheme.authentication-mechanism + preferred_label: OpenID Connect + definition: Authentication using OpenID Connect identity semantics. + status: provisional + introduced_in: '0.2' +- id: fiam.security.authentication.unspecified + scheme: fiam.scheme.authentication-mechanism + preferred_label: unspecified + definition: Authentication is known to be relevant but its concrete mechanism is not asserted. + status: provisional + introduced_in: '0.1' +- id: fiam.security.identity-propagation.token + scheme: fiam.scheme.identity-propagation + preferred_label: token + definition: Identity or authority context is propagated using a token artifact. + status: provisional + introduced_in: '0.1' +- id: fiam.security.tls + scheme: fiam.scheme.transport-security + preferred_label: TLS + definition: Transport-security profile indicating TLS protection. + status: provisional + introduced_in: '0.1' + related: + - fiam.protocol.tls +- id: fiam.session.long-lived-process + scheme: fiam.scheme.state-session + preferred_label: long lived process + definition: State/session model characterized by long lived process. + status: provisional + introduced_in: '0.1' +- id: fiam.shape-role.element + scheme: fiam.scheme.shape-role + preferred_label: element + definition: Shape describes members/elements of a collection-like resource or shape. + status: provisional + introduced_in: '0.2' +- id: fiam.shape-role.envelope-member + scheme: fiam.scheme.shape-role + preferred_label: envelope member + definition: Shape is embedded as a named coarse member of an envelope. + status: provisional + introduced_in: '0.2' +- id: fiam.shape-role.error + scheme: fiam.scheme.shape-role + preferred_label: error + definition: Shape participates as an error/failure result. + status: provisional + introduced_in: '0.2' +- id: fiam.shape-role.payload + scheme: fiam.scheme.shape-role + preferred_label: payload + definition: Shape is embedded as the primary semantic payload of an envelope/container. + status: provisional + introduced_in: '0.2' +- id: fiam.shape-role.projection + scheme: fiam.scheme.shape-role + preferred_label: projection + definition: Shape is a projection/view derived from another shape. + status: provisional + introduced_in: '0.2' +- id: fiam.shape-role.request + scheme: fiam.scheme.shape-role + preferred_label: request + definition: Shape participates as request/input information. + status: provisional + introduced_in: '0.2' +- id: fiam.shape-role.response + scheme: fiam.scheme.shape-role + preferred_label: response + definition: Shape participates as successful response/output information. + status: provisional + introduced_in: '0.2' +- id: fiam.stack-role.application-protocol + scheme: fiam.scheme.communication-layer-role + preferred_label: application protocol + definition: Communication-stack layer role representing application protocol. + status: provisional + introduced_in: '0.1' +- id: fiam.stack-role.application-semantics + scheme: fiam.scheme.communication-layer-role + preferred_label: application semantics + definition: Communication-stack layer role representing application semantics. + status: provisional + introduced_in: '0.1' +- id: fiam.stack-role.application-transfer-protocol + scheme: fiam.scheme.communication-layer-role + preferred_label: application transfer protocol + definition: Communication-stack layer role representing application transfer protocol. + status: provisional + introduced_in: '0.1' +- id: fiam.stack-role.authorization-framework + scheme: fiam.scheme.communication-layer-role + preferred_label: authorization framework + definition: Communication-stack layer role representing authorization framework. + status: provisional + introduced_in: '0.1' +- id: fiam.stack-role.broker-protocol + scheme: fiam.scheme.communication-layer-role + preferred_label: broker protocol + definition: Communication-stack layer role representing broker protocol. + status: provisional + introduced_in: '0.1' +- id: fiam.stack-role.database-protocol + scheme: fiam.scheme.communication-layer-role + preferred_label: database protocol + definition: Communication-stack layer role representing database protocol. + status: provisional + introduced_in: '0.1' +- id: fiam.stack-role.framing + scheme: fiam.scheme.communication-layer-role + preferred_label: framing + definition: Communication-stack role that frames or delimits messages/records without defining their higher-level application + semantics. + status: provisional + introduced_in: 0.1.1 +- id: fiam.stack-role.handshake + scheme: fiam.scheme.communication-layer-role + preferred_label: handshake + definition: Communication-stack role that establishes, upgrades, or negotiates a communication context before normal interaction. + status: provisional + introduced_in: 0.1.1 +- id: fiam.stack-role.identity-protocol + scheme: fiam.scheme.communication-layer-role + preferred_label: identity protocol + definition: Communication-stack layer role representing identity protocol. + status: provisional + introduced_in: '0.1' +- id: fiam.stack-role.invocation-mechanism + scheme: fiam.scheme.communication-layer-role + preferred_label: invocation mechanism + definition: Communication-stack layer role representing invocation mechanism. + status: provisional + introduced_in: '0.1' +- id: fiam.stack-role.ipc-process-carrier + scheme: fiam.scheme.communication-layer-role + preferred_label: ipc process carrier + definition: Communication-stack layer role representing ipc process carrier. + status: provisional + introduced_in: '0.1' +- id: fiam.stack-role.messaging-protocol + scheme: fiam.scheme.communication-layer-role + preferred_label: messaging protocol + definition: Communication-stack layer role representing messaging protocol. + status: provisional + introduced_in: '0.1' +- id: fiam.stack-role.rpc-protocol + scheme: fiam.scheme.communication-layer-role + preferred_label: rpc protocol + definition: Communication-stack layer role representing rpc protocol. + status: provisional + introduced_in: '0.1' +- id: fiam.stack-role.runtime + scheme: fiam.scheme.communication-layer-role + preferred_label: runtime + definition: Communication-stack layer role representing runtime. + status: provisional + introduced_in: '0.1' +- id: fiam.stack-role.security-protocol + scheme: fiam.scheme.communication-layer-role + preferred_label: security protocol + definition: Communication-stack layer role representing security protocol. + status: provisional + introduced_in: '0.1' +- id: fiam.stack-role.serialization + scheme: fiam.scheme.communication-layer-role + preferred_label: serialization + definition: Communication-stack layer role representing serialization. + status: provisional + introduced_in: '0.1' +- id: fiam.stack-role.transport + scheme: fiam.scheme.communication-layer-role + preferred_label: transport + definition: Communication-stack layer role representing transport. + status: provisional + introduced_in: '0.1' +- id: fiam.tech.cloudevents + scheme: fiam.scheme.technology + preferred_label: CloudEvents + definition: The CloudEvents event information model and related format/binding specifications. + status: provisional + introduced_in: '0.2' +- id: fiam.tech.graphql + scheme: fiam.scheme.technology + preferred_label: GraphQL + definition: GraphQL query language, type system, and execution semantics, modeled independently of any concrete transport. + status: provisional + introduced_in: '0.1' + related: + - fiam.representation.graphql-document +- id: fiam.tech.json-schema + scheme: fiam.scheme.technology + preferred_label: JSON Schema + definition: The JSON Schema vocabulary/specification family for describing JSON-compatible data. + status: provisional + introduced_in: '0.2' +- id: fiam.tech.openapi + scheme: fiam.scheme.technology + preferred_label: OpenAPI + definition: The OpenAPI specification/description language for HTTP APIs. + status: provisional + introduced_in: '0.2' +- id: fiam.temporal.asynchronous + scheme: fiam.scheme.temporal-semantics + preferred_label: asynchronous + definition: Interaction semantics in which production and consumption or completion are temporally decoupled. + status: provisional + introduced_in: '0.1' +- id: fiam.temporal.bidirectional-stream + scheme: fiam.scheme.temporal-semantics + preferred_label: bidirectional stream + definition: A long-lived interaction in which both sides may send a sequence of messages over the same logical interaction. + status: provisional + introduced_in: '0.1' +- id: fiam.temporal.request-response + scheme: fiam.scheme.temporal-semantics + preferred_label: request response + definition: Deprecated temporal term that mixed exchange shape with timing semantics. Use interaction-style.request-response + for exchange shape and an appropriate temporal term such as synchronous separately. + status: deprecated + introduced_in: '0.1' + replaced_by: + - fiam.temporal.synchronous + - fiam.interaction-style.request-response + migration_note: Split exchange shape from temporal coupling. +- id: fiam.temporal.stateful-session + scheme: fiam.scheme.temporal-semantics + preferred_label: stateful session + definition: A multi-exchange interaction whose semantics depend on state retained across exchanges. + status: provisional + introduced_in: '0.1' +- id: fiam.temporal.synchronous + scheme: fiam.scheme.temporal-semantics + preferred_label: synchronous + definition: Interaction semantics in which progress of the initiating context is directly coupled to completion or response + of the invoked interaction. + status: provisional + introduced_in: '0.1' +- id: fiam.transport.tcp + scheme: fiam.scheme.transport + preferred_label: TCP + definition: Transmission Control Protocol used as a network transport. + status: provisional + introduced_in: '0.1' +- id: fiam.transport.unix-domain-socket + scheme: fiam.scheme.transport + preferred_label: unix domain socket + definition: Unix-domain socket IPC mechanism for local process communication. + status: provisional + introduced_in: '0.1' +- id: fiam.zone-type.cluster + scheme: fiam.scheme.zone-type + preferred_label: cluster + definition: Zone representing a compute/orchestration cluster or equivalent deployment boundary. + status: provisional + introduced_in: '0.2' +- id: fiam.zone-type.deployment-environment + scheme: fiam.scheme.zone-type + preferred_label: deployment environment + definition: Zone representing a deployment environment such as production, staging, test, or development. + status: provisional + introduced_in: '0.2' +- id: fiam.zone-type.kubernetes-namespace + scheme: fiam.scheme.zone-type + preferred_label: Kubernetes namespace + definition: Zone representing a Kubernetes namespace within a cluster. + status: provisional + introduced_in: '0.2' +- id: fiam.zone-type.unscoped + scheme: fiam.scheme.zone-type + preferred_label: unscoped + definition: Placeholder zone for runtime evidence that lacks usable deployment scope attributes. + status: provisional + introduced_in: '0.2' +- id: fiam.zone-type.trust-zone + scheme: fiam.scheme.zone-type + preferred_label: trust zone + definition: Zone representing a security/trust domain within which a common trust posture is assumed for architectural analysis. + status: provisional + introduced_in: '0.2' +- id: fiam.zone-type.organization + scheme: fiam.scheme.zone-type + preferred_label: organization + definition: Zone representing an organizational or legal-entity boundary relevant to architecture and governance. + status: provisional + introduced_in: '0.2' +- id: fiam.zone-type.network-segment + scheme: fiam.scheme.zone-type + preferred_label: network segment + definition: Zone representing a network segmentation boundary such as VPC, subnet, security segment, or equivalent. + status: provisional + introduced_in: '0.2' +term_usage_constraints: +- path: nodes[].node_type + schemes: + - fiam.scheme.node-type +- path: ports[].participations[].roles[] + schemes: + - fiam.scheme.participant-role +- path: contracts[].family_labels[] + schemes: + - fiam.scheme.family-label +- path: contracts[].purpose[] + schemes: + - fiam.scheme.purpose +- path: contracts[].contract_forms[] + schemes: + - fiam.scheme.contract-form +- path: contracts[].operations[].interaction_style + schemes: + - fiam.scheme.interaction-style +- path: contracts[].operations[].temporal_semantics + schemes: + - fiam.scheme.temporal-semantics +- path: contracts[].operations[].effect + schemes: + - fiam.scheme.operation-effect +- path: contracts[].operations[].purpose[] + schemes: + - fiam.scheme.purpose +- path: endpoints[].address_scheme + schemes: + - fiam.scheme.addressing-scheme +- path: bindings[].binding_profile + schemes: + - fiam.scheme.binding-profile +- path: bindings[].communication_stack[].role + schemes: + - fiam.scheme.communication-layer-role +- path: bindings[].communication_stack[].term + schemes: + - fiam.scheme.protocol + - fiam.scheme.technology + - fiam.scheme.transport + - fiam.scheme.carrier + - fiam.scheme.representation + - fiam.scheme.runtime +- path: bindings[].addressing.kind + schemes: + - fiam.scheme.addressing-discovery +- path: bindings[].session_model + schemes: + - fiam.scheme.state-session +- path: bindings[].discovery.kind + schemes: + - fiam.scheme.discovery-mechanism +- path: channels[].channel_type + schemes: + - fiam.scheme.channel-type +- path: channels[].mediation + schemes: + - fiam.scheme.mediation +- path: channels[].delivery_semantics + schemes: + - fiam.scheme.delivery-semantics +- path: channels[].ordering_scope + schemes: + - fiam.scheme.ordering-scope +- path: information_resources[].resource_kind + schemes: + - fiam.scheme.information-resource-kind +- path: information_resources[].resource_scope + schemes: + - fiam.scheme.resource-scope +- path: information_resources[].selectors[].kind + schemes: + - fiam.scheme.resource-selector +- path: information_shapes[].shape_kind + schemes: + - fiam.scheme.information-shape-kind +- path: interactions[].interaction_style + schemes: + - fiam.scheme.interaction-style +- path: interactions[].temporal_semantics + schemes: + - fiam.scheme.temporal-semantics +- path: interactions[].execution_boundary + schemes: + - fiam.scheme.execution-boundary +- path: interactions[].realization_status + schemes: + - fiam.scheme.interaction-realization-status +- path: interaction_flows[].flow_type + schemes: + - fiam.scheme.flow-type +- path: artifacts[].artifact_type + schemes: + - fiam.scheme.artifact-type +- path: security[].transport_security + schemes: + - fiam.scheme.transport-security +- path: security[].authentication + schemes: + - fiam.scheme.authentication-mechanism +- path: security[].credential_artifacts[] + schemes: + - fiam.scheme.credential-artifact +- path: security[].identity_propagation + schemes: + - fiam.scheme.identity-propagation +- path: zones[].zone_type + schemes: + - fiam.scheme.zone-type +assertion_predicate_constraints: +- predicate: fiam.property.communication-protocol + value_schemes: + - fiam.scheme.protocol +- predicate: fiam.property.execution-boundary + value_schemes: + - fiam.scheme.execution-boundary +- predicate: fiam.property.mediation + value_schemes: + - fiam.scheme.mediation +- predicate: fiam.property.multi-party + value_type: boolean +- predicate: fiam.property.network-required + value_type: boolean +- predicate: fiam.property.transport-independent + value_type: boolean +- predicate: fiam.property.network-protocol-version + value_type: string +- predicate: fiam.property.http-method + value_type: string +- predicate: fiam.property.http-route + value_type: string +- predicate: fiam.property.server-address + value_type: string +- predicate: fiam.property.server-port + value_type: integer +- predicate: fiam.property.http-response-status-code + value_type: integer +- predicate: fiam.property.service-name + value_type: string +- predicate: fiam.property.service-namespace + value_type: string +- predicate: fiam.property.rpc-system-name + value_type: string +- predicate: fiam.property.rpc-method + value_type: string +- predicate: fiam.property.rpc-response-status-code + value_type: string +- predicate: fiam.property.messaging-system + value_type: string +- predicate: fiam.property.messaging-destination-name + value_type: string +- predicate: fiam.property.messaging-operation-type + value_type: string +- predicate: fiam.property.messaging-operation-name + value_type: string +- predicate: fiam.property.database-system-name + value_type: string +- predicate: fiam.property.database-namespace + value_type: string +- predicate: fiam.property.database-collection-name + value_type: string +- predicate: fiam.property.database-operation-name + value_type: string +- predicate: fiam.property.database-response-status-code + value_type: string +- predicate: fiam.property.otel-span-kind + value_type: string +- predicate: fiam.property.runtime-observation-count + value_type: integer +- predicate: fiam.property.runtime-error-count + value_type: integer +- predicate: fiam.property.runtime-first-seen + value_type: string +- predicate: fiam.property.runtime-last-seen + value_type: string +- predicate: fiam.property.runtime-active + value_type: boolean +- predicate: fiam.property.network-peer-address + value_type: string +- predicate: fiam.property.service-peer-name + value_type: string +- predicate: fiam.property.deployment-environment-name + value_type: string +- predicate: fiam.property.k8s-cluster-name + value_type: string +- predicate: fiam.property.k8s-cluster-uid + value_type: string +- predicate: fiam.property.k8s-namespace-name + value_type: string +- predicate: fiam.property.security-override + value_type: string +migration_notes: +- from: fiam.evidence.detected-files + to: + - fiam.evidence.static-observed + reason: Separate evidence acquisition mode from evidence source type. +- from: fiam.temporal.request-response + to: + - fiam.temporal.synchronous + - fiam.interaction-style.request-response + reason: Separate temporal semantics from interaction/exchange shape. +- from: fiam.protocol.graphql + to: + - fiam.tech.graphql + reason: GraphQL is transport-independent semantic/execution technology rather than a transport protocol. +- FIAM v0.2 promotes InformationResource and InformationShape into the Core. +- fiam.information-shape.record is deprecated; use fiam.information-shape.object for structured named-member shapes. +- Operation/Contract representations fields remain parseable for migration but are non-authoritative and produce validation + warnings; use relation-scoped representation. +- Assertions require evidence in v0.2. +- Specimen tests use executable expected_properties; old free-text expectations belong under tests.notes. +semantic_policies: + shape_identity: + principle: Shape identity follows intended semantic/structural admissibility, not artifact identity or representation. + same_shape_when: + - Multiple artifacts intentionally describe the same admissible information form. + - The same logical shape is encoded using different representations or used by different bindings. + - A source/runtime/schema declaration is authoritative evidence for an already identified shape rather than a separately + versioned contract. + new_shape_when: + - Admissible structure or constraints change materially and the distinction matters architecturally. + - A projection/subset/view intentionally exposes a different admissible form. + - Two independently discovered candidates cannot yet be asserted to be the same entity. + relations: + confirmed_identity: fiam.relation.same-entity-as + version_lineage: fiam.relation.version-of + projection: fiam.relation.projection-of + candidate_alignment: fiam.relation.corresponds-to + observational_equivalence: fiam.relation.observationally-equivalent-to + merge_rule: Identity relations never delete or merge evidence. Physical/entity reconciliation is a separate repository + operation outside the Core model. + shape_participation: + relations: + - fiam.relation.accepts-shape + - fiam.relation.produces-shape + - fiam.relation.errors-with-shape + scope_order: + - operation + - binding + - interaction + rule: Operation-level relations state semantic defaults; Binding-level relations refine a realization; Interaction-level + relations record the actual observed/selected participation. + multi_operation_binding: A Binding-level shape participation on a Binding that realizes multiple operations MUST use facets.operation_ref + to disambiguate the operation it refines. + representation: Representation belongs on the most specific relevant shape-participation relation. Legacy Operation/Contract + representations are non-authoritative. + refinement_relations: + - fiam.relation.projection-of + - fiam.relation.version-of + identity_equivalence_relation: fiam.relation.same-entity-as + enforcement: When an Operation declares a shape for a participation relation, a Binding refinement for that operation + MUST use that shape or a shape related to it by projection-of/version-of (same-entity-as is treated as identity equivalence). + An Interaction refines the most specific Binding shape if one exists, otherwise the Operation default. Missing parent + declarations remain valid under open-world semantics. + resource_shape: + conforms_to_shape: The InformationResource as addressed has the stated overall form. + element_shape: Members/elements of a collection-like InformationResource or InformationShape have the stated form. It + is not a substitute for the resource overall shape. + collection_rule: A collection-like resource may conform to a collection shape and separately declare an element-shape; + the collection shape may itself declare the same element-shape. + collection_shape_kind: fiam.information-shape.collection + collection_resource_kinds: + - fiam.information-resource.api-resource-collection + - fiam.information-resource.object-collection + - fiam.information-resource.object-store-bucket + - fiam.information-resource.filesystem-directory + - fiam.information-resource.relational-table + - fiam.information-resource.append-log + element_shape_subject_shape_kinds: + - fiam.information-shape.collection + enforcement: Collection-like resources that assert conforms-to-shape MUST point to a collection shape. element-shape on + an InformationShape requires collection shape_kind; on an InformationResource it requires a collection-like resource + kind or concrete/logical collection scope. + composition_slots: + rule: embeds-shape and element-shape MAY use facets.slot for a coarse stable location/name and facets.role for a Canon + shape role. This is not a field-list schema language. + identity_relations: + same_entity_kind: same-entity-as, alias-of, version-of, and observationally-equivalent-to require subject and object to + have the same FIAM entity kind. + self_relation: Identity relations MUST NOT point from an entity to itself. + query_semantics: Asserted same-entity-as edges define an equivalence view for queries. Source entity ids remain intact; + query engines MAY collapse the equivalence class for traversal/display but MUST expose all member ids and evidence on + request. + automatic_promotion: Structural equality or fingerprint equality alone MUST NOT produce same-entity-as. Automated discovery + SHOULD emit corresponds-to. same-entity-as requires explicit authoritative declaration or a governed reconciliation + decision with no conflicting version-of/projection-of evidence. + default_reconciliation_threshold: 0.98 + required_independent_signals_for_inferred_promotion: 2 + default_tool_behavior: No automatic promotion from corresponds-to to same-entity-as. + family_label_cache: + rule: family_labels is an optional denormalized cache only. Every cached label MUST be backed by an asserted property + assertion using fiam.property.family-label whose evidence mode is fiam.evidence.inferred. + authoritative_source: Lens-derived inferred assertion + runtime_observation: + otel_semconv_version_basis: 1.44.0 + otlp_spec_version_basis: 1.11.0 + principles: + - Runtime ingest MUST preserve unknowns and MUST NOT infer payload shapes from ordinary HTTP spans. + - network.protocol.version is observation evidence for the actually used protocol version when present. + - A runtime-to-declared match creates corresponds-to unless governed identity evidence justifies same-entity-as. + - Runtime observations do not overwrite declared assertions; disagreement is retained for lenses. + runtime_catalog: + principle: Runtime telemetry updates an architecture catalog; it is not stored as a one-Interaction-per-span trace warehouse + by default. + default_occurrence_retention: sample + aggregation_tuple: + - operation + - binding + - role/direction + - channel-or-resource + - local-node + - remote-node-when-known + statistics: + - runtime-observation-count + - runtime-error-count + - runtime-first-seen + - runtime-last-seen + - runtime-active + idempotency: Runtime property/relation assertion ids are deterministic. Catalogs track processed batch hashes so replay + of the same batch does not increment aggregates. + absence_rule: No observation is not absence. runtime-active may be closed from missing data only when ingest is explicitly + marked authoritative_snapshot. + high_cardinality_rule: Raw url.path, message ids, query text, query parameters, and span names MUST NOT be used as stable + architectural entity identity keys. + runtime_identity: + node_tuple: + - entity-kind + - service.namespace + - service.name + - deployment.environment.name + - k8s.cluster.uid-or-name + - k8s.namespace.name + - cloud.account.id + - cloud.region + endpoint_tuple: + - logical server.address + - server.port + - addressing scheme + - deployment zone tuple + channel_tuple: + - messaging.system + - logical broker address when present + - destination name + - deployment zone tuple + resource_tuple: + - database system + - logical server address + - db.namespace + - db.collection.name + - deployment zone tuple + http_operation_rule: Use http.route as the stable path template. If absent, map to one low-cardinality unknown-route operation; + do not promote url.path into an Operation id. + network_peer_rule: network.peer.* describes the actual connection peer and is competing locator evidence, not the default + logical endpoint identity. + peer_service_rule: service.peer.name/service.peer.namespace are preferred peer-service signals; deprecated peer.service + may be accepted only as a compatibility input. + reconciliation_candidates: + principle: Ambiguity is surfaced, not silently discarded. Adapters record scored candidate lists before creating corresponds-to. + auto_correspondence: Only a unique high-scoring candidate creates corresponds-to; near-matches and ties remain candidate + findings. + working_set: Tools may project observed records onto a declared-preferred working-set id through corresponds-to without + asserting identity or deleting source ids. +relation_facet_constraints: +- predicates: + - fiam.relation.accepts-shape + - fiam.relation.produces-shape + - fiam.relation.errors-with-shape + allowed_facets: + representation: + scheme: fiam.scheme.representation + role: + scheme: fiam.scheme.shape-role + operation_ref: + entity_kind: operation +- predicates: + - fiam.relation.embeds-shape + - fiam.relation.element-shape + allowed_facets: + slot: + type: string + role: + scheme: fiam.scheme.shape-role +- predicates: + - fiam.relation.embedded-in + - fiam.relation.embeds + allowed_facets: + slot: + type: string +runtime_ingest_policy: + version: 0.2-draft.4 + principle: Estate-oriented runtime telemetry updates stable, zone-scoped architecture records and idempotent observation + aggregates; sampled traces do not imply architectural absence. + domains: + - http + - rpc + - messaging + - database + sources: + - https://opentelemetry.io/docs/specs/otlp/ + - https://opentelemetry.io/docs/specs/semconv/ + - https://opentelemetry.io/docs/specs/semconv/general/attributes/ + - https://opentelemetry.io/docs/specs/semconv/resource/service/ diff --git a/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft1.md b/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft1.md new file mode 100644 index 0000000..dcd60e0 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft1.md @@ -0,0 +1,219 @@ +# FIAM v0.2-draft.1 — Implementation-Hardened Baseline + +## Status + +**Draft implementation baseline.** `fiam_version` remains `0.2`; `draft.1` identifies this package/revision of the v0.2 specification work. No new Core entity is introduced in this pass. + +This revision responds to implementation review by hardening the semantics of the existing spine and exercising it through a real declared-source ingest. + +## Stable structural spine + +```text +Participant / SystemNode + ↓ owns / participates through +Port → InterfaceContract → Operation + ↓ realization + Binding → Endpoint + │ + ├──────── Channel + │ + └──────── Interaction → InteractionFlow + │ + ├── targets / reads / writes → InformationResource + └── accepts / produces / errors-with → InformationShape + +Artifact ── describes / implements ──> Core entities +Assertion + Evidence ── qualifies facts and graph relations +``` + +The v0.2 distinctions remain unchanged: + +```text +Endpoint = how/where a Binding is reached +Channel = exchange/mediation locus +InformationResource = identifiable information-bearing locus/state/collection +InformationShape = admissible semantic/structural form +Artifact = concrete description or implementation +Representation = encoding/notation selected for a participation +``` + +Channel and Resource remain orthogonal. Shape remains distinct from Artifact and Representation. Family labels remain lens-derived caches, not Core types. + +## draft.1 hardening decisions + +### 1. MCP bindings share one semantic contract graph + +The stdio and Streamable HTTP specimens now use the same contract, operations, dynamically discovered tool contract and InformationShapes. Only realization-specific entities differ: processes/nodes, bindings, endpoint/channel and communication stack. + +The shared dynamic pattern is: + +```text +operation.mcp.tools-list + ↑ discovered-via +operation.tool.read-file + +contract.tool.read-file + ── embedded-in ──> operation.mcp.tools-call + +ToolCallRequest ── embeds-shape(params.arguments) ──> ReadFileArgs +``` + +This makes "same contract, multiple bindings" executable rather than rhetorical. + +### 2. Kafka duplicate collapsed + +The older dual-role Kafka specimen was removed. One regression specimen now carries all relevant facts together: + +```text +Kafka topic as Channel + │ + └── backed-by ──> retained-log InformationResource + +publish / consume ── shape participation ──> OrderCreated +``` + +### 3. Shape-kind coherence is enforced + +The validator now rejects, among other cases: + +- collection-like Resources that `conforms-to-shape` a non-collection Shape; +- `element-shape` on a non-collection InformationShape; +- `element-shape` on an InformationResource that is not collection-like. + +The normative distinction remains: + +- `conforms-to-shape`: the Resource *as addressed* has that overall form; +- `element-shape`: members/elements of a collection-like Resource or Shape have that form. + +### 4. Shape participation refinement is enforced + +Shape participation follows: + +```text +Operation semantic default + ↓ refine +Binding realization + ↓ refine +Interaction actual selection/observation +``` + +A lower-level participation must use the same Shape, an identity-equivalent Shape, or an evidenced `projection-of` / `version-of` Shape. Missing parent declarations remain valid under open-world semantics. + +A multi-operation Binding must use `facets.operation_ref` to identify which Operation a Binding-level shape participation refines. + +### 5. Representation stays relation-scoped + +Representation is authoritative on the most specific relevant `accepts-shape`, `produces-shape` or `errors-with-shape` assertion. Contract/Operation `representations` fields remain migration-readable but warn as non-authoritative. + +### 6. Cached family labels require provenance + +Manual `family_labels` were removed from the positive corpus. A cached family label is now valid only when backed by an asserted `fiam.property.family-label` whose evidence mode is `fiam.evidence.inferred`. + +This preserves the rule: + +> family labels are results of lenses, not primitive classification supplied by specimen authors. + +### 7. Identity is operational but non-destructive + +`same-entity-as` defines a **query-time equivalence class**. It never deletes either entity or its evidence. + +Automated discovery must not turn structural similarity into identity. The default policy is: + +```text +one structural/fingerprint signal + → corresponds-to + +same-entity-as + → explicit declared/governed identity decision + OR, for inferred promotion eligibility, + at least 2 independent signals + each meeting confidence >= 0.98 +``` + +Even if the inferred eligibility threshold is met, default tooling does **not** auto-promote; it requests governed reconciliation. + +The validator rejects a purely inferred `same-entity-as` with insufficient independent evidence. `tools/identity_view.py` implements the corresponding query view without merging IDs. + +### 8. Specimen tests and discovered models are separated + +`tests.expected_properties` is mandatory for `instance.kind: specimen` fixtures and is executed by the validator. + +Ordinary ingested architecture models (`instance.kind: model`) do not need to pretend to be test fixtures. Their confidence comes from schema/Canon/semantic validation plus real provenance. + +## First declared ingest: OpenAPI → FIAM + +`tools/openapi_to_fiam.py` is the first ingestion adapter. It currently accepts OpenAPI 3.x YAML/JSON and produces a declared FIAM model containing, where available: + +- provider SystemNode, Port and InterfaceContract; +- Operations with HTTP method/path provenance; +- HTTP/TLS/TCP Binding and server Endpoint; +- HTTP path-template InformationResources; +- component and inline InformationShapes; +- coarse shape composition (`embeds-shape`, `element-shape`), without schema fields in Core; +- Operation semantic shape defaults; +- Binding-level representation refinements with `operation_ref`; +- OpenAPI Artifact with source URL and version metadata; +- per-assertion evidence with JSON-pointer-like source locators; +- structural-fingerprint candidate identity as `corresponds-to`, never automatic `same-entity-as`. + +The adapter is architecture-oriented rather than a lossless OpenAPI translator. The OpenAPI Artifact remains authoritative for detailed parameter/property/schema semantics. + +## Real-world identity run + +The package includes a normalized excerpt from the Swagger Petstore OpenAPI document, retaining the live source URL and the `Category`, `Tag`, and `Pet` schemas. + +`Category` and `Tag` normalize to the same structural fingerprint (`id:int64`, `name:string`). The importer therefore emits: + +```text +Category ── corresponds-to ──> Tag +confidence = 0.75 +mode = inferred +``` + +It emits **no `same-entity-as`**. `identity_view.py` consequently reports no equivalence class and recommends that the pair remain correspondence candidates. + +This is the desired behavior: schema duplication/similarity is evidence for reconciliation, not identity proof. + +## Validation meaning in draft.1 + +A positive PASS checks: + +- JSON Schema validity; +- entity-reference resolution; +- Canon term resolution and deprecation; +- Canon term-usage constraints; +- assertion predicate scheme/type constraints; +- relation domain/range constraints; +- relation-facet constraints; +- assertion evidence presence; +- contract participation and Binding consistency; +- dynamic embedded-contract Operation/Binding consistency; +- shape-kind coherence; +- Operation → Binding → Interaction shape refinement; +- family-label cache provenance; +- identity same-kind/self-edge rules; +- inferred `same-entity-as` promotion eligibility; +- executable specimen expectations. + +The current results are: + +```text +Synthetic positive specimen corpus: 26 PASS, 0 errors, 0 warnings +Real-world OpenAPI ingest model: 1 PASS, 0 errors, 0 warnings +Adversarial suite: 14 rejected as intended +Migration-warning case: 1 accepted with 1 warning +``` + +## Deliberate exclusions remain + +No new Core entity was introduced. In particular: + +- no `Session`; +- no fields/member lists inside InformationShape; +- no business/domain ontology; +- no RDF requirement; +- no destructive merge engine; +- no automatic family labels; +- no automatic identity promotion. + +The next implementation pressure should come from additional ingest/observation adapters and useful lenses, not from ontology expansion. diff --git a/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft2.md b/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft2.md new file mode 100644 index 0000000..c9f6bfb --- /dev/null +++ b/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft2.md @@ -0,0 +1,171 @@ +# FIAM v0.2-draft.2 + +## Status + +`v0.2-draft.2` is the first FIAM baseline with **independent declared and runtime-observed ingest paths plus an executable comparison Lens**. + +It intentionally introduces **no new Core entity and no Core schema change**. The `FIAM-Core-v0.2.schema.json` file is byte-identical to draft.1. This revision pressures the stable spine through ingestion, reconciliation and analysis instead of extending the metamodel. + +## What changed + +### 1. OpenTelemetry / OTLP runtime ingest + +`tools/otel_to_fiam.py` accepts OTLP/JSON trace exports. It can emit a standalone partial runtime model or enrich a declared FIAM model supplied with `--base`. + +The first supported high-value mapping is an HTTP `SERVER` span: + +```text +OTel resource service.name + -> observed SystemNode + +HTTP SERVER span + -> observed Contract / Operation + -> observed Binding / Endpoint + -> Interaction + -> runtime-observed Assertions + Evidence +``` + +Ordinary spans without enough interface semantics still become partial runtime Interactions. Incomplete runtime models remain valid. + +The adapter deliberately does **not** infer payload `InformationShape`s from HTTP spans. + +### 2. Runtime facts are assertions + +The Canon gains runtime-oriented properties including: + +- `fiam.property.service-name` +- `fiam.property.service-namespace` +- `fiam.property.http-method` +- `fiam.property.http-route` +- `fiam.property.server-address` +- `fiam.property.server-port` +- `fiam.property.network-protocol-version` +- `fiam.property.http-response-status-code` + +Observed protocol versions map to versioned protocol terms (`HTTP/1.1`, `HTTP/2`, `HTTP/3`) while retaining the raw `network.protocol.version` observation. + +### 3. Reconciliation remains weaker than identity + +When a runtime HTTP span matches a declared operation by host + method + normalized route, the adapter emits evidenced: + +```text +observed Operation --corresponds-to--> declared Operation +observed Binding --corresponds-to--> declared Binding +observed Endpoint --corresponds-to--> declared Endpoint +``` + +It does **not** emit `same-entity-as` automatically and does not merge source records. + +### 4. First executable Lens + +`lenses/declared-vs-observed.yaml` plus `tools/declared_observed_lens.py` compare declared and runtime-observed facts over `corresponds-to` pairs. + +Current finding classes: + +- `exact` +- `compatible-refinement` +- `observed-less-specific` +- `declared-only` +- `observed-only` +- `conflict` + +Protocol comparison understands the Canon hierarchy. Therefore: + +```text +declared HTTP +observed HTTP/2 +=> compatible-refinement +``` + +while: + +```text +declared HTTP/1.1 +observed HTTP/2 +=> conflict +``` + +The Lens resolves the architectural owner through the declared Binding's provider Port and owning SystemNode. + +### 5. OpenAPI ingest became more conservative + +Runtime comparison exposed one overstatement in draft.1: an OpenAPI `https://` server URL does not justify declaring TCP because HTTP/3 may use QUIC. The OpenAPI adapter now declares generic HTTP + TLS from HTTPS, but no transport unless a source actually provides one. + +This is a useful example of FIAM's intended learning loop: **the Core did not change; ingest semantics became more accurate.** + +## Demonstration + +The package combines: + +- the normalized Swagger Petstore OpenAPI excerpt already used in draft.1; +- an OTLP/JSON HTTP server-span fixture following current OpenTelemetry semantic-convention field names; +- the generated composite FIAM graph; +- two Lens runs. + +### Run A — ordinary OpenAPI declaration + +The OpenAPI source declares generic HTTP. The observed trace records protocol version `2`. + +Result: + +```text +compatible-refinement: 1 +exact: 2 +observed-only: 2 +conflict: 0 +``` + +The observed-only facts are useful rather than errors: OpenAPI does not declare the actual negotiated network protocol version or the default port as an explicit fact. + +### Run B — controlled operational expectation + +A separate architecture declaration states that the same Binding is expected to use HTTP/1.1. This is explicitly a test fixture, not a claim about Swagger's public service. + +The runtime observation remains HTTP/2. + +Result: + +```text +conflict: 1 +exact: 2 +observed-only: 2 +``` + +The conflict contains both evidence chains and resolves the declared owning service node. + +## Conformance meaning in draft.2 + +`make check` now covers: + +1. Core byte stability against draft.1; +2. all JSON Schemas plus the new Lens schema; +3. Canon validation; +4. all 26 positive semantic specimens; +5. deterministic OpenAPI ingest; +6. OTLP/JSON format ingest; +7. deterministic runtime ingest; +8. declared/runtime reconciliation; +9. conservative no-Shape runtime behavior; +10. deterministic Lens execution; +11. expected compatible-refinement behavior; +12. expected HTTP/1.1 vs HTTP/2 conflict behavior; +13. OTLP/JSON adapter-level rejection of invalid enum encoding; +14. the existing FIAM adversarial corpus. + +A green draft.2 therefore exercises an actual **declare -> observe -> reconcile -> analyze** loop. + +## Core posture + +The Core remains closed. No `Session`, schema fields, business ontology, merge entity or additional family type has been added. + +The next Core change should require a real ingestion or analysis failure that cannot be represented with the current spine. + +## Standards basis + +The runtime profile is based on: + +- OpenTelemetry Semantic Conventions 1.44.0: https://opentelemetry.io/docs/specs/semconv/ +- HTTP span semantic conventions: https://opentelemetry.io/docs/specs/semconv/http/http-spans/ +- OpenTelemetry Trace API / SpanKind: https://opentelemetry.io/docs/specs/otel/trace/api/ +- OTLP 1.11.0: https://opentelemetry.io/docs/specs/otlp/ +- official OTLP/JSON trace example repository: https://github.com/open-telemetry/opentelemetry-proto/tree/main/examples diff --git a/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft3.md b/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft3.md new file mode 100644 index 0000000..175f198 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft3.md @@ -0,0 +1,200 @@ +# FIAM v0.2-draft.3 — Cross-Domain Runtime Architecture + +## Status + +FIAM v0.2-draft.3 keeps the **Core schema closed and byte-identical to draft.1**. The revision extends runtime ingestion and analysis across three additional architectural domains: + +- RPC / gRPC; +- messaging producer/consumer/client operations; +- database client operations. + +The purpose is not to add more interface types. It is to test whether one FIAM Core can reconstruct materially different runtime topologies from one telemetry substrate. + +## Result + +The Core survives the cross-domain pressure test without modification. + +The same structural vocabulary produces three distinct runtime structures: + +```text +RPC +Service A ───────────────> Service B + direct call + +Messaging +Producer ──> Channel ──> Consumer + brokered + +Database +Application ─────────────> InformationResource + reads/writes +``` + +This distinction is intentional. A runtime topology lens must not flatten a Kafka flow, a gRPC call and a table read into the same generic `service -> service` edge. + +## Standards basis + +The runtime adapter targets: + +- OpenTelemetry Semantic Conventions 1.44.0 — https://opentelemetry.io/docs/specs/semconv/ +- RPC spans — https://opentelemetry.io/docs/specs/semconv/rpc/rpc-spans/ +- gRPC conventions — https://opentelemetry.io/docs/specs/semconv/rpc/grpc/ +- Messaging spans — https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/ +- Database client spans — https://opentelemetry.io/docs/specs/semconv/db/database-spans/ +- OTLP 1.11.0 — https://opentelemetry.io/docs/specs/otlp/ + +The maturity of those conventions is not uniform. Database client span conventions are Stable; RPC/gRPC are currently Release Candidate; messaging span conventions remain Development. FIAM therefore preserves raw OTel semantic values as evidence properties instead of treating every convention detail as permanent FIAM ontology. + +## Runtime mappings + +### RPC / gRPC + +An RPC `CLIENT` or `SERVER` span with `rpc.system.name` and `rpc.method` can create or enrich: + +```text +SystemNode +Port (requires/offers) +InterfaceContract +Operation (RPC) +Binding +Endpoint, where server.address is available +Interaction +``` + +`rpc.system.name=grpc` maps to the canonical gRPC protocol term. FIAM does **not** infer HTTP/2 or a transport merely from the fact that the RPC system is gRPC unless another observation establishes that lower layer. + +Client/server spans in one trace can be correlated by parent span identity. This is used by the Runtime Topology Lens to produce a direct dependency without merging the two independently observed interface records. + +### Messaging + +OpenTelemetry messaging semantics distinguish operation type from SpanKind. In particular: + +```text +create -> PRODUCER +send -> PRODUCER or CLIENT depending on creation context +receive -> CLIENT +process -> CONSUMER +settle -> CLIENT +``` + +FIAM therefore preserves both: + +```text +OTel SpanKind +messaging.operation.type +``` + +and derives the architectural producer/consumer participation from the messaging operation semantics rather than assuming that every consumer operation must have SpanKind `CONSUMER`. + +A messaging destination becomes a FIAM `Channel`; producer and consumer bindings remain separate. Span links can create an `InteractionFlow` of type `message-propagation` while retaining the Channel as the mediation locus. + +### Database clients + +A database client span can create: + +```text +local application Node +required database Port +observed database Contract/Operation +client Binding +database Endpoint +remote database placeholder Node, when address is known +InformationResource, when db.collection.name is known +Interaction +``` + +For PostgreSQL, an observed collection is modeled as a relational-table InformationResource. `SELECT`-like operations can infer `reads-from`; mutation operations can infer `writes-to`. The inference is separately evidenced from the directly observed `db.operation.name`. + +FIAM does not ingest `db.query.text` into the architecture model. Queries may contain sensitive or high-cardinality application data and are not required to establish the architectural relationship. + +## Reconciliation + +The runtime adapter can reconcile against existing FIAM declarations without destructive identity merge. + +The draft.3 conformance suite exercises: + +- gRPC runtime observations against the pre-existing bidirectional-stream specimen; +- Kafka producer/consumer observations against the durable-topic specimen; +- PostgreSQL client observations against the shared-table specimen. + +Successful matches emit `corresponds-to` assertions with reconciliation evidence. Current checked outcomes are: + +```text +gRPC 6 correspondence edges +Kafka 7 correspondence edges +Postgres 8 correspondence edges +``` + +The PostgreSQL case includes Resource and Endpoint correspondence in addition to Binding/Operation/Node reconciliation. + +## Runtime Topology Lens + +Draft.3 introduces `fiam.lens.runtime-topology`. + +It intentionally projects domains differently: + +- RPC: client service -> server service, using trace parentage; +- Messaging: producer -> Channel -> consumer, using message-propagation InteractionFlows derived from span links; +- Database: application -> InformationResource, preserving read/write semantics and resource ownership. + +The combined fixture yields: + +```text +1 RPC direct-call edge +2 mediated messaging edges +2 database resource edges +0 unresolved correlations +``` + +A pull-based Kafka `receive` span is deliberately included with SpanKind `CLIENT`; FIAM still gives it a consumer participation role and reconstructs its message flow through the span link. + +## Canon additions + +No Core entity was added. The Canon gained only runtime vocabulary required to preserve observed facts and selectors, including: + +- host/port endpoint addressing; +- generic message destination Channel type; +- message-propagation Flow type; +- generic database collection resource kind; +- RPC system/method/status properties; +- messaging system/destination/operation properties; +- database system/namespace/collection/operation/status properties; +- raw OpenTelemetry SpanKind property. + +These terms capture evidence; they are not new interface families. + +## Conformance posture + +`make check` now verifies: + +- Core byte stability; +- eight schemas; +- Canon and two Lens definitions; +- 26 semantic specimens; +- deterministic OpenAPI ingest; +- deterministic HTTP and generic OTLP ingest; +- declared-vs-observed HTTP refinement/conflict behavior; +- deterministic multi-domain OTLP ingest; +- conservative no-Shape runtime behavior; +- database query-text exclusion; +- OTel messaging CLIENT-vs-consumer semantics; +- message-link flow reconstruction; +- Runtime Topology Lens output and result schema; +- gRPC/Kafka/Postgres declared-runtime reconciliation; +- adversarial OTLP and FIAM cases. + +## Design conclusion + +The runtime pass strengthens the decision to keep the Core closed. + +FIAM now has evidence that one structural spine can describe: + +```text +synchronous service invocation +asynchronous mediated communication +shared/persistent data access +``` + +without minting `GrpcInterface`, `KafkaInterface`, `DatabaseInterface`, or another domain-specific Core branch. + +The next productive pressure is operational rather than ontological: consume larger heterogeneous trace sets, improve entity reconciliation across incomplete observations, and build architecture questions/lenses on top of the resulting graph. diff --git a/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft4-root-copy.md b/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft4-root-copy.md new file mode 100644 index 0000000..e512834 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft4-root-copy.md @@ -0,0 +1,266 @@ +# FIAM v0.2-draft.4 — Estate Hardening + +## Status + +FIAM v0.2-draft.4 hardens the Faceted Interface Architecture Model for **estate-scale, incomplete, incremental and multi-environment discovery**. + +The Core is frozen. `schemas/FIAM-Core-v0.2.schema.json` is byte-identical to the v0.2-draft.1 and draft.3 Core. No new structural entity was introduced in this revision. + +The work is concentrated in five operational contracts: + +1. runtime aggregation and incremental catalog update; +2. stable runtime identity tuples and Zones; +3. scored reconciliation plus a non-destructive working-set projection; +4. coverage, ambiguity and gateway-aware lenses; +5. declared security ingest from OpenAPI. + +## The architectural posture + +The estate catalog is **not a trace warehouse**. + +```text +telemetry occurrences + | + | aggregate by architectural participation + v +runtime observation class + operation + binding + role + + channel/resource where relevant + | + +--> count / error_count + +--> first_seen / last_seen + +--> bounded evidence samples + | + v +FIAM architecture catalog +``` + +Full span occurrences remain in the telemetry backend. FIAM may retain a bounded sample of trace/span identifiers so an operator can return to the source evidence. + +## Runtime identity + +Runtime discovery now constructs explicit identity tuples rather than using labels such as `service.name` as catalog keys. + +A deployed service node is keyed from: + +```text +service namespace ++ service name ++ deployment environment ++ cluster identity ++ Kubernetes namespace ++ cloud account / region where supplied +``` + +FIAM deliberately distinguishes **OpenTelemetry logical service identity** from **architectural deployment identity**. OpenTelemetry specifies that `deployment.environment.name` does not change logical service identity; FIAM nevertheless uses deployment/cluster context to keep production and staging architecture records separate. + +Zones are created for deployment environment, cluster and Kubernetes namespace when evidence supplies them. + +## Runtime aggregation + +Default OTLP ingest aggregates spans by an architectural tuple containing: + +```text +domain +role +operation +binding +local node +remote node where known +channel or InformationResource where relevant +``` + +The aggregate stores: + +- observation count; +- error count; +- first seen; +- last seen; +- bounded sample trace/span references. + +The same values are materialized as idempotent evidence-backed assertions so lenses can query them through normal FIAM semantics. + +`--occurrences sample` is the default. `none` and `all` are explicit diagnostic alternatives. + +## Incremental catalog semantics + +`otel_to_fiam.py --base catalog.yaml` updates an existing FIAM catalog instead of rebuilding the declared model. + +Properties: + +- stable entity identities across batches; +- hash-derived assertion identifiers; +- exact-batch replay idempotency; +- evidence timestamps update rather than duplicate; +- processed batch hashes are retained; +- sampled absence does **not** imply architectural absence; +- only `--authoritative-snapshot` may close a runtime-active observation interval. + +Exactly-once detection of spans that are repackaged into a semantically different OTLP batch remains the responsibility of a production ingestion/checkpoint layer. FIAM's file reference implementation guarantees exact replay idempotency for identical batches and stable architectural aggregation; it does not turn the YAML catalog into an unbounded event-deduplication database. + +## Cardinality and privacy boundaries + +The runtime adapter does not use high-cardinality occurrence values as architecture identity when a low-cardinality semantic attribute is unavailable. + +Examples: + +- missing `http.route` -> one `unknown-route` Operation; +- raw `url.path` is not promoted to an Operation or identifier; +- raw span names are not persisted in the architecture catalog; +- `db.query.text` and query parameters are not copied; +- trace/span ids are retained only as bounded evidence references. + +This deliberately prefers an explicit partial model over a falsely precise, high-cardinality catalog. + +## Partial telemetry is a first-class result + +A green conformance run does not require `unresolved = 0`. + +Fixtures now cover: + +- RPC client span without the server span; +- messaging producer without a downstream span link; +- database span without a stable namespace/collection; +- HTTP span without `http.route`; +- ambiguous declared HTTP candidates. + +Each remains a valid partial FIAM model with an explicit unresolved/candidate finding. + +## Reconciliation + +Runtime reconciliation now builds candidate indexes and records scored candidates. + +Possible states: + +```text +matched +ambiguous +near-match +unmatched +``` + +Only a sufficiently strong unique match produces `fiam.relation.corresponds-to`. + +Ambiguity is therefore visible architecture intelligence rather than a silent no-match. + +## Working-set projection + +`working_set_view.py` makes conservative identity usable without destructive merge. + +```text +observed record + -- corresponds-to --> declared record + | + v +working-set preferred reference = declared record +``` + +The observed record, evidence and correspondence remain present. Ambiguous correspondences remain separate. + +Runtime topology uses this projection so operators do not see unnecessary duplicate nodes when high-confidence declared/runtime correspondence already exists. + +## Gateways and proxies + +Runtime ingest considers semantic destination evidence and network-peer evidence separately. `server.address` remains the logical destination when available; `network.peer.*` may identify the actually contacted intermediary. + +When runtime client evidence reconciles to a declared target but the observed responder is a different service, the topology edge may be marked: + +```text +via_gateway: true +gateway: +intended_target: +``` + +This avoids silently replacing the intended architecture with a mesh/sidecar topology. + +## Declared coverage + +The Declared-vs-Observed Lens now reports operation/channel coverage in addition to property differences: + +- `observed`; +- `declared-only`; +- `observed-only`; +- `ambiguous`. + +A deterministic security API fixture demonstrates one observed operation and three declared-but-unseen operations with architectural owner resolution. + +## OpenAPI security ingest + +The OpenAPI adapter now maps declared security schemes and requirements into FIAM Security profiles. + +Supported scheme families: + +- API key; +- HTTP Basic; +- HTTP Bearer; +- OAuth 2.0; +- OpenID Connect; +- mutual TLS. + +The adapter preserves OpenAPI Security Requirement semantics: + +- schemes inside one requirement object are conjunctive; +- separate requirement objects are alternatives; +- `{}` allows anonymous access as an alternative; +- an operation `security` field overrides top-level security; +- `security: []` explicitly removes inherited security. + +The Security Coverage Lens computes effective declared security per operation. Generic OTLP is deliberately **not** interpreted as proof that authentication is absent. + +## Estate conformance + +The draft.4 harness checks more than schema typing: + +- Core byte freeze; +- all package schemas and Canon; +- 26 semantic specimens; +- deterministic OpenAPI ingest; +- OpenAPI security semantics; +- 5,000-span runtime aggregation; +- 7,000-observation incremental update; +- byte-idempotent exact replay; +- authoritative-snapshot activity closure; +- production/staging identity separation; +- four partial-telemetry fixtures; +- ambiguous reconciliation with no unsafe correspondence; +- working-set projection and gateway topology; +- declared operation coverage; +- cross-domain RPC/messaging/database topology; +- database privacy boundary; +- deterministic domain ingest; +- adversarial FIAM and OTLP cases. + +Run: + +```bash +make check +``` + +## What remains deliberately outside the Core + +Draft.4 does not add: + +- Session; +- span/Occurrence entities to the Core; +- field lists on InformationShape; +- business ontology; +- automatic identity merge; +- a new interface family type. + +Known adapter limitations include external OpenAPI `$ref` resolution, callbacks/webhooks, server-variable expansion and production-grade persistent indexing/checkpoint storage. These are adapter/catalog implementation work, not evidence for Core growth. + +## Conclusion + +The main FIAM question has shifted. + +It is no longer: + +> Can one Core represent HTTP, RPC, messaging and data access? + +Draft.3 answered that. + +The draft.4 question is: + +> Can that same Core remain useful when observations are numerous, incomplete, duplicated, ambiguous, environment-scoped and mediated by real infrastructure? + +The current conformance suite says yes, provided aggregation, identity, evidence and projection are treated as first-class operational contracts around the frozen Core. diff --git a/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft4.md b/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft4.md new file mode 100644 index 0000000..e512834 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft4.md @@ -0,0 +1,266 @@ +# FIAM v0.2-draft.4 — Estate Hardening + +## Status + +FIAM v0.2-draft.4 hardens the Faceted Interface Architecture Model for **estate-scale, incomplete, incremental and multi-environment discovery**. + +The Core is frozen. `schemas/FIAM-Core-v0.2.schema.json` is byte-identical to the v0.2-draft.1 and draft.3 Core. No new structural entity was introduced in this revision. + +The work is concentrated in five operational contracts: + +1. runtime aggregation and incremental catalog update; +2. stable runtime identity tuples and Zones; +3. scored reconciliation plus a non-destructive working-set projection; +4. coverage, ambiguity and gateway-aware lenses; +5. declared security ingest from OpenAPI. + +## The architectural posture + +The estate catalog is **not a trace warehouse**. + +```text +telemetry occurrences + | + | aggregate by architectural participation + v +runtime observation class + operation + binding + role + + channel/resource where relevant + | + +--> count / error_count + +--> first_seen / last_seen + +--> bounded evidence samples + | + v +FIAM architecture catalog +``` + +Full span occurrences remain in the telemetry backend. FIAM may retain a bounded sample of trace/span identifiers so an operator can return to the source evidence. + +## Runtime identity + +Runtime discovery now constructs explicit identity tuples rather than using labels such as `service.name` as catalog keys. + +A deployed service node is keyed from: + +```text +service namespace ++ service name ++ deployment environment ++ cluster identity ++ Kubernetes namespace ++ cloud account / region where supplied +``` + +FIAM deliberately distinguishes **OpenTelemetry logical service identity** from **architectural deployment identity**. OpenTelemetry specifies that `deployment.environment.name` does not change logical service identity; FIAM nevertheless uses deployment/cluster context to keep production and staging architecture records separate. + +Zones are created for deployment environment, cluster and Kubernetes namespace when evidence supplies them. + +## Runtime aggregation + +Default OTLP ingest aggregates spans by an architectural tuple containing: + +```text +domain +role +operation +binding +local node +remote node where known +channel or InformationResource where relevant +``` + +The aggregate stores: + +- observation count; +- error count; +- first seen; +- last seen; +- bounded sample trace/span references. + +The same values are materialized as idempotent evidence-backed assertions so lenses can query them through normal FIAM semantics. + +`--occurrences sample` is the default. `none` and `all` are explicit diagnostic alternatives. + +## Incremental catalog semantics + +`otel_to_fiam.py --base catalog.yaml` updates an existing FIAM catalog instead of rebuilding the declared model. + +Properties: + +- stable entity identities across batches; +- hash-derived assertion identifiers; +- exact-batch replay idempotency; +- evidence timestamps update rather than duplicate; +- processed batch hashes are retained; +- sampled absence does **not** imply architectural absence; +- only `--authoritative-snapshot` may close a runtime-active observation interval. + +Exactly-once detection of spans that are repackaged into a semantically different OTLP batch remains the responsibility of a production ingestion/checkpoint layer. FIAM's file reference implementation guarantees exact replay idempotency for identical batches and stable architectural aggregation; it does not turn the YAML catalog into an unbounded event-deduplication database. + +## Cardinality and privacy boundaries + +The runtime adapter does not use high-cardinality occurrence values as architecture identity when a low-cardinality semantic attribute is unavailable. + +Examples: + +- missing `http.route` -> one `unknown-route` Operation; +- raw `url.path` is not promoted to an Operation or identifier; +- raw span names are not persisted in the architecture catalog; +- `db.query.text` and query parameters are not copied; +- trace/span ids are retained only as bounded evidence references. + +This deliberately prefers an explicit partial model over a falsely precise, high-cardinality catalog. + +## Partial telemetry is a first-class result + +A green conformance run does not require `unresolved = 0`. + +Fixtures now cover: + +- RPC client span without the server span; +- messaging producer without a downstream span link; +- database span without a stable namespace/collection; +- HTTP span without `http.route`; +- ambiguous declared HTTP candidates. + +Each remains a valid partial FIAM model with an explicit unresolved/candidate finding. + +## Reconciliation + +Runtime reconciliation now builds candidate indexes and records scored candidates. + +Possible states: + +```text +matched +ambiguous +near-match +unmatched +``` + +Only a sufficiently strong unique match produces `fiam.relation.corresponds-to`. + +Ambiguity is therefore visible architecture intelligence rather than a silent no-match. + +## Working-set projection + +`working_set_view.py` makes conservative identity usable without destructive merge. + +```text +observed record + -- corresponds-to --> declared record + | + v +working-set preferred reference = declared record +``` + +The observed record, evidence and correspondence remain present. Ambiguous correspondences remain separate. + +Runtime topology uses this projection so operators do not see unnecessary duplicate nodes when high-confidence declared/runtime correspondence already exists. + +## Gateways and proxies + +Runtime ingest considers semantic destination evidence and network-peer evidence separately. `server.address` remains the logical destination when available; `network.peer.*` may identify the actually contacted intermediary. + +When runtime client evidence reconciles to a declared target but the observed responder is a different service, the topology edge may be marked: + +```text +via_gateway: true +gateway: +intended_target: +``` + +This avoids silently replacing the intended architecture with a mesh/sidecar topology. + +## Declared coverage + +The Declared-vs-Observed Lens now reports operation/channel coverage in addition to property differences: + +- `observed`; +- `declared-only`; +- `observed-only`; +- `ambiguous`. + +A deterministic security API fixture demonstrates one observed operation and three declared-but-unseen operations with architectural owner resolution. + +## OpenAPI security ingest + +The OpenAPI adapter now maps declared security schemes and requirements into FIAM Security profiles. + +Supported scheme families: + +- API key; +- HTTP Basic; +- HTTP Bearer; +- OAuth 2.0; +- OpenID Connect; +- mutual TLS. + +The adapter preserves OpenAPI Security Requirement semantics: + +- schemes inside one requirement object are conjunctive; +- separate requirement objects are alternatives; +- `{}` allows anonymous access as an alternative; +- an operation `security` field overrides top-level security; +- `security: []` explicitly removes inherited security. + +The Security Coverage Lens computes effective declared security per operation. Generic OTLP is deliberately **not** interpreted as proof that authentication is absent. + +## Estate conformance + +The draft.4 harness checks more than schema typing: + +- Core byte freeze; +- all package schemas and Canon; +- 26 semantic specimens; +- deterministic OpenAPI ingest; +- OpenAPI security semantics; +- 5,000-span runtime aggregation; +- 7,000-observation incremental update; +- byte-idempotent exact replay; +- authoritative-snapshot activity closure; +- production/staging identity separation; +- four partial-telemetry fixtures; +- ambiguous reconciliation with no unsafe correspondence; +- working-set projection and gateway topology; +- declared operation coverage; +- cross-domain RPC/messaging/database topology; +- database privacy boundary; +- deterministic domain ingest; +- adversarial FIAM and OTLP cases. + +Run: + +```bash +make check +``` + +## What remains deliberately outside the Core + +Draft.4 does not add: + +- Session; +- span/Occurrence entities to the Core; +- field lists on InformationShape; +- business ontology; +- automatic identity merge; +- a new interface family type. + +Known adapter limitations include external OpenAPI `$ref` resolution, callbacks/webhooks, server-variable expansion and production-grade persistent indexing/checkpoint storage. These are adapter/catalog implementation work, not evidence for Core growth. + +## Conclusion + +The main FIAM question has shifted. + +It is no longer: + +> Can one Core represent HTTP, RPC, messaging and data access? + +Draft.3 answered that. + +The draft.4 question is: + +> Can that same Core remain useful when observations are numerous, incomplete, duplicated, ambiguous, environment-scoped and mediated by real infrastructure? + +The current conformance suite says yes, provided aggregation, identity, evidence and projection are treated as first-class operational contracts around the frozen Core. diff --git a/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft5.md b/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft5.md new file mode 100644 index 0000000..689913a --- /dev/null +++ b/history/FIAM_v0.2_Draft6/history/FIAM-v0.2-Draft5.md @@ -0,0 +1,179 @@ +# FIAM v0.2-draft.5 — Architecture Intelligence Queries + +## Status + +FIAM v0.2-draft.5 moves the project from an estate-aware catalog toward an **architecture intelligence query system**. + +The Core remains frozen. `schemas/FIAM-Core-v0.2.schema.json` is byte-identical to the Core used since v0.2-draft.1. No structural entity was added. + +Draft.5 works above the Core in four areas: + +1. persistent but rebuildable indexing; +2. temporal topology state; +3. evidence-strength projection; +4. executable architecture-change and boundary-drift questions. + +## Persistent index, not another truth store + +FIAM YAML/JSON models retain evidence, provenance and open-world semantics. Repeated estate queries should not require scanning every model file, so draft.5 introduces a SQLite reference index. + +```text +FIAM declared/runtime models + | + | index / normalize + v +rebuildable SQLite projection + entities + historical versions + assertions + evidence scores + working identities + declared dependencies + Zone memberships + topology intervals + | + +--> temporal lenses + +--> boundary lenses + +--> evidence-ranked queries +``` + +The database is disposable. It is never permitted to become the only copy of evidence. + +## Temporal topology semantics + +A runtime topology edge has an observation interval. Append/sample ingestion can extend what has been seen, but absence has no meaning. Only an **authoritative snapshot** may close an active interval. + +```text +sample batch without edge + -> unknown; do not close + +authoritative snapshot without edge + -> close active interval at snapshot time +``` + +If the edge later reappears, the index opens another interval rather than erasing the prior one. The included September 10 fixture verifies that the Orders → Inventory dependency receives a second interval while the August/September interval remains closed and queryable. + +Declarations and Zone memberships are evaluated **as-of the query/edge time**, not using the latest estate state. A later deployment move therefore does not retroactively rewrite an old boundary crossing. + +## Architecture Changes Lens + +The first temporal Lens answers three concrete questions over a window: + +- which runtime dependencies appeared; +- which runtime dependencies disappeared; +- which newly appeared dependencies were not declared at that time. + +The deterministic estate-history fixture produces: + +```text +2026-09-01 +Orders -> Inventory declared + observed + +2026-09-08 authoritative snapshot +Orders -> Inventory absent -> interval closed +Orders -> Partner API newly observed, undeclared +``` + +For the September 7–9 window the Lens reports: + +```text +appeared: 1 + Orders -> Partner API + +disappeared: 1 + Orders -> Inventory [declared] + +newly undeclared: 1 + Orders -> Partner API +``` + +This is the first FIAM query that combines declaration, runtime history and temporal semantics rather than comparing one current model. + +## Boundary Drift Lens + +Zones remain normal FIAM Core entities. Draft.5 adds Canon terms for `trust-zone`, `organization`, and `network-segment` and a Lens that compares Zone membership on newly appearing topology edges. + +In the estate-history fixture: + +```text +Orders -> internal trust zone / internal organization +Partner API -> partner trust zone / partner organization +``` + +The newly observed dependency therefore yields: + +```text +new cross-Zone edges: 1 +new trust-boundary crossings: 1 +new organization crossings: 1 +``` + +The Lens is intentionally descriptive. Whether a crossing is acceptable belongs to a security/governance policy layered on top. + +## Evidence-strength policy + +FIAM already stores `confidence`, evidence mode, source, observer, stance and observation time. Draft.5 provides a query-time scoring policy so tools can rank claims without mutating them. + +The reference score combines: + +```text +source confidence +* evidence-mode weight +* source-type weight +* freshness factor where configured +``` + +Independent evidential sources combine using a bounded noisy-OR. Repeated records from the same source locator count once. + +Supporting and challenging evidence are scored separately. + +Important: **the resulting number is a ranking heuristic, not a calibrated probability that the assertion is true.** + +Conformance verifies that: + +- duplicating one source does not increase the score; +- an independent corroborating source does increase support; +- stale runtime evidence ranks below equally strong fresh runtime evidence; +- source assertions are not rewritten. + +## Working identity and temporal indexing + +The persistent index uses the existing non-destructive working-set policy. An observed record with one unambiguous declared correspondence may use the declared id as its preferred query identity, while both source records and all evidence remain available. + +The index additionally stores historical entity versions so temporal Zone/owner questions are not forced through the latest object serialization. + +## Scale fixture + +The query-index conformance generates a 5,000-edge FIAM topology snapshot and verifies: + +```text +entities: 5,001 +active topology: 5,000 +topology intervals: 5,000 +``` + +This is not presented as a performance benchmark. It verifies that the query contract is set-oriented and persistent rather than a collection of fixture-specific YAML scans. + +## What draft.5 deliberately does not do + +It does not introduce: + +- new Core entities; +- automatic deletion based on sampled absence; +- a truth-probability model; +- a graph database requirement; +- policy decisions about whether a boundary crossing is allowed; +- automatic destructive entity merge. + +SQLite is the reference query projection, not a mandated storage engine. The normalized contract can later be implemented in PostgreSQL, a graph store or another indexed backend without changing FIAM Core. + +## Next pressure + +The strongest next tests are now query/operations tests rather than ontology tests: + +- longer historical windows and reappearance of dependencies; +- evidence conflict/challenge queries; +- risk/governance policy over boundary crossings; +- declared-interface disappearance and reintroduction across releases; +- materialized estate summaries and incremental query serving; +- multiple source streams with overlapping scopes and different authority. + +The architectural question is no longer whether FIAM can describe the estate. It is whether it can support useful, explainable decisions over the estate's changing state while preserving uncertainty and evidence. diff --git a/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/boundary-drift.yaml b/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/boundary-drift.yaml new file mode 100644 index 0000000..57a06d7 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/boundary-drift.yaml @@ -0,0 +1,28 @@ +lens_id: fiam.lens.boundary-drift +window: + since: '2026-09-07T00:00:00Z' + until: '2026-09-09T00:00:00Z' + scope: prod-runtime +summary: + new_cross_zone: 1 + new_trust_boundary: 1 + new_organization_boundary: 1 +crossings: +- edge_key: edge.210c03e257e70068c68df0c0 + kind: direct-call + from: node.orders + target: node.partner + first_seen: '2026-09-08T00:00:00Z' + zone_crossings: + - zone_type: fiam.zone-type.trust-zone + from_zones: + - zone.trust.internal + target_zones: + - zone.trust.partner + - zone_type: fiam.zone-type.organization + from_zones: + - zone.org.internal + target_zones: + - zone.org.partner + trust_boundary: true + organization_boundary: true diff --git a/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/changes.yaml b/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/changes.yaml new file mode 100644 index 0000000..62c8b9f --- /dev/null +++ b/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/changes.yaml @@ -0,0 +1,54 @@ +lens_id: fiam.lens.architecture-changes +window: + since: '2026-09-07T00:00:00Z' + until: '2026-09-09T00:00:00Z' + scope: prod-runtime +summary: + appeared: 1 + disappeared: 1 + newly_undeclared: 1 +appeared: +- edge_key: edge.210c03e257e70068c68df0c0 + domain: rpc + kind: direct-call + from: node.orders + target: node.partner + target_kind: node + channel: null + first_seen: '2026-09-08T00:00:00Z' + last_seen: '2026-09-08T00:00:00Z' + valid_from: '2026-09-08T00:00:00Z' + valid_until: null + observation_count: 12 + declared: false + close_reason: null +disappeared: +- edge_key: edge.be323ef1b2f1274e52be419c + domain: rpc + kind: direct-call + from: node.orders + target: node.inventory + target_kind: node + channel: null + first_seen: '2026-08-25T00:00:00Z' + last_seen: '2026-09-01T00:00:00Z' + valid_from: '2026-08-25T00:00:00Z' + valid_until: '2026-09-08T00:00:00Z' + observation_count: 100 + declared: true + close_reason: absent-from-authoritative-snapshot +newly_undeclared: +- edge_key: edge.210c03e257e70068c68df0c0 + domain: rpc + kind: direct-call + from: node.orders + target: node.partner + target_kind: node + channel: null + first_seen: '2026-09-08T00:00:00Z' + last_seen: '2026-09-08T00:00:00Z' + valid_from: '2026-09-08T00:00:00Z' + valid_until: null + observation_count: 12 + declared: false + close_reason: null diff --git a/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/estate.sqlite b/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/estate.sqlite new file mode 100644 index 0000000..a7826e5 Binary files /dev/null and b/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/estate.sqlite differ diff --git a/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/evidence-scores.yaml b/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/evidence-scores.yaml new file mode 100644 index 0000000..fac2c17 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/evidence-scores.yaml @@ -0,0 +1,375 @@ +policy_id: fiam.policy.evidence-scoring.default +evaluated_at: '2026-09-09T08:00:00Z' +assertions: +- assertion_id: assertion.openapi.0001 + support_score: 1.0 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 1.0 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.declared + source_type: openapi-document + source_ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + strength: 1.0 +- assertion_id: assertion.openapi.0002 + support_score: 1.0 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 1.0 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.declared + source_type: openapi-document + source_ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + strength: 1.0 +- assertion_id: assertion.openapi.0003 + support_score: 1.0 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 1.0 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.declared + source_type: openapi-document + source_ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + strength: 1.0 +- assertion_id: assertion.openapi.0004 + support_score: 1.0 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 1.0 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.declared + source_type: openapi-document + source_ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + strength: 1.0 +- assertion_id: assertion.openapi.0005 + support_score: 1.0 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 1.0 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.declared + source_type: openapi-document + source_ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + strength: 1.0 +- assertion_id: assertion.openapi.0006 + support_score: 1.0 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 1.0 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.declared + source_type: openapi-document + source_ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + strength: 1.0 +- assertion_id: assertion.openapi.0007 + support_score: 1.0 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 1.0 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.declared + source_type: openapi-document + source_ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + strength: 1.0 +- assertion_id: assertion.openapi.0008 + support_score: 1.0 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 1.0 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.declared + source_type: openapi-document + source_ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + strength: 1.0 +- assertion_id: assertion.openapi.0009 + support_score: 1.0 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 1.0 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.declared + source_type: openapi-document + source_ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + strength: 1.0 +- assertion_id: assertion.openapi.0010 + support_score: 1.0 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 1.0 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.declared + source_type: openapi-document + source_ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + strength: 1.0 +- assertion_id: assertion.openapi.0011 + support_score: 1.0 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 1.0 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.declared + source_type: openapi-document + source_ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + strength: 1.0 +- assertion_id: assertion.openapi.0012 + support_score: 1.0 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 1.0 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.declared + source_type: openapi-document + source_ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + strength: 1.0 +- assertion_id: assertion.openapi.0013 + support_score: 0.1365 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.1365 + support_class: very-weak + evidence_sources: + - stance: supports + mode: fiam.evidence.inferred + source_type: schema-structural-fingerprint + source_ref: schema-structural-fingerprint + strength: 0.1365 +- assertion_id: assertion.otel.16f147bdd9999831cb01 + support_score: 0.889561 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.889561 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.runtime-observed + source_type: otlp-trace-stream + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.889561 +- assertion_id: assertion.otel.1b96a634e434b4917c7c + support_score: 0.394483 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.394483 + support_class: weak + evidence_sources: + - stance: supports + mode: fiam.evidence.inferred + source_type: reconciliation-rule + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.394483 +- assertion_id: assertion.otel.2d67c52ae9f110cd2ee1 + support_score: 0.889561 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.889561 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.runtime-observed + source_type: otlp-trace-stream + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.889561 +- assertion_id: assertion.otel.3a4db6ee91268ef5d9f9 + support_score: 0.917652 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.917652 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.runtime-observed + source_type: otlp-aggregate + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.917652 +- assertion_id: assertion.otel.3df6f40fdae3bb2fad5d + support_score: 0.889561 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.889561 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.runtime-observed + source_type: otlp-trace-stream + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.889561 +- assertion_id: assertion.otel.58c30a6371a6c8d18707 + support_score: 0.889561 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.889561 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.runtime-observed + source_type: otlp-trace-stream + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.889561 +- assertion_id: assertion.otel.61ee643dcd4ae2f35c1f + support_score: 0.398679 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.398679 + support_class: weak + evidence_sources: + - stance: supports + mode: fiam.evidence.inferred + source_type: reconciliation-rule + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.398679 +- assertion_id: assertion.otel.65f037d1b849a5deb24b + support_score: 0.917652 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.917652 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.runtime-observed + source_type: otlp-aggregate + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.917652 +- assertion_id: assertion.otel.8dab97bea0366143d688 + support_score: 0.889561 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.889561 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.runtime-observed + source_type: otlp-trace-stream + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.889561 +- assertion_id: assertion.otel.94ebba5afc8db554f52f + support_score: 0.917652 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.917652 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.runtime-observed + source_type: otlp-aggregate + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.917652 +- assertion_id: assertion.otel.a7000cafd39483a9ae54 + support_score: 0.407073 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.407073 + support_class: weak + evidence_sources: + - stance: supports + mode: fiam.evidence.inferred + source_type: reconciliation-rule + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.407073 +- assertion_id: assertion.otel.c16f4fe5d33d669cef5b + support_score: 0.889561 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.889561 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.runtime-observed + source_type: otlp-trace-stream + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.889561 +- assertion_id: assertion.otel.c39aee943e445c5b5bb2 + support_score: 0.889561 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.889561 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.runtime-observed + source_type: otlp-trace-stream + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.889561 +- assertion_id: assertion.otel.ce45dcb72eb26f2c19a0 + support_score: 0.917652 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.917652 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.runtime-observed + source_type: otlp-aggregate + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.917652 +- assertion_id: assertion.otel.dfa6f7f01d962e73b3d0 + support_score: 0.889561 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.889561 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.runtime-observed + source_type: otlp-trace-stream + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.889561 +- assertion_id: assertion.otel.f3415412240b68ce80e8 + support_score: 0.917652 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.917652 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.runtime-observed + source_type: otlp-aggregate + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.917652 +- assertion_id: assertion.otel.fc3df934322d8fddcd9d + support_score: 0.402876 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.402876 + support_class: weak + evidence_sources: + - stance: supports + mode: fiam.evidence.inferred + source_type: reconciliation-rule + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.402876 +- assertion_id: assertion.otel.fc7a428bfb9170e4c495 + support_score: 0.889561 + challenge_score: 0.0 + neutral_score: 0.0 + net_support: 0.889561 + support_class: strong + evidence_sources: + - stance: supports + mode: fiam.evidence.runtime-observed + source_type: otlp-trace-stream + source_ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + strength: 0.889561 diff --git a/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/snapshot-2026-09-01.yaml b/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/snapshot-2026-09-01.yaml new file mode 100644 index 0000000..0fd8163 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/snapshot-2026-09-01.yaml @@ -0,0 +1,111 @@ +fiam_version: '0.2' +instance: + id: model.estate-history.prod + kind: model + title: Estate history — production + status: provisional + intent: Temporal architecture-intelligence fixture. +nodes: + - id: node.orders + kind: system-node + name: Orders + node_type: fiam.node-type.service + - id: node.inventory + kind: system-node + name: Inventory + node_type: fiam.node-type.service + - id: node.partner + kind: system-node + name: Partner API + node_type: fiam.node-type.application +ports: + - id: port.inventory.api + kind: port + owner: node.inventory + participations: + - contract: contract.inventory + mode: offers + roles: [fiam.role.server] +contracts: + - id: contract.inventory + kind: interface-contract + name: Inventory API + purpose: [fiam.purpose.query] + operations: + - id: operation.inventory.get + kind: operation + name: getInventory + interaction_style: fiam.interaction-style.request-response +bindings: + - id: binding.inventory + kind: binding + contract: contract.inventory + provider_port: port.inventory.api + operations: [operation.inventory.get] +zones: + - id: zone.environment.prod + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: [node.orders, node.inventory, node.partner] + - id: zone.trust.internal + kind: zone + name: internal trust domain + zone_type: fiam.zone-type.trust-zone + members: [node.orders, node.inventory] + - id: zone.trust.partner + kind: zone + name: partner trust domain + zone_type: fiam.zone-type.trust-zone + members: [node.partner] + - id: zone.org.internal + kind: zone + name: internal organization + zone_type: fiam.zone-type.organization + members: [node.orders, node.inventory] + - id: zone.org.partner + kind: zone + name: partner organization + zone_type: fiam.zone-type.organization + members: [node.partner] +assertions: + - id: assertion.declared.orders-uses-inventory + assertion_kind: relation + subject: node.orders + predicate: fiam.relation.uses + polarity: asserted + object_ref: binding.inventory + evidence: + mode: fiam.evidence.declared + source: + type: architecture-declaration + ref: fixture://estate-history/declared + locator: dependency/orders-inventory + observer: fixture.owner + confidence: 1.0 + stance: supports + observed_at: '2026-09-01T00:00:00Z' +extensions: + org.fiam.catalog: + version: 0.2-draft.5 + processed_batches: ['1111111111111111111111111111111111111111111111111111111111111111'] + declared_entity_ids: [node.orders, node.inventory, node.partner, port.inventory.api, contract.inventory, operation.inventory.get, binding.inventory] + last_ingest_at: '2026-09-01T00:00:00Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: none + sample_size: 0 + org.fiam.runtime_aggregates: [] + org.fiam.runtime_topology_observations: + - id: topology.orders-inventory + domain: rpc + kind: direct-call + from: node.orders + to: node.inventory + binding: binding.inventory + operation: operation.inventory.get + count: 100 + first_seen: '2026-08-25T00:00:00Z' + last_seen: '2026-09-01T00:00:00Z' + correlation: fixture + org.fiam.runtime_unresolved: [] + org.fiam.reconciliation_candidates: [] diff --git a/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/snapshot-2026-09-08.yaml b/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/snapshot-2026-09-08.yaml new file mode 100644 index 0000000..385a489 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/snapshot-2026-09-08.yaml @@ -0,0 +1,129 @@ +fiam_version: '0.2' +instance: + id: model.estate-history.prod + kind: model + title: "Estate history \u2014 production" + status: provisional + intent: Temporal architecture-intelligence fixture. +nodes: +- id: node.orders + kind: system-node + name: Orders + node_type: fiam.node-type.service +- id: node.inventory + kind: system-node + name: Inventory + node_type: fiam.node-type.service +- id: node.partner + kind: system-node + name: Partner API + node_type: fiam.node-type.application +ports: +- id: port.inventory.api + kind: port + owner: node.inventory + participations: + - contract: contract.inventory + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.inventory + kind: interface-contract + name: Inventory API + purpose: + - fiam.purpose.query + operations: + - id: operation.inventory.get + kind: operation + name: getInventory + interaction_style: fiam.interaction-style.request-response +bindings: +- id: binding.inventory + kind: binding + contract: contract.inventory + provider_port: port.inventory.api + operations: + - operation.inventory.get +zones: +- id: zone.environment.prod + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.orders + - node.inventory + - node.partner +- id: zone.trust.internal + kind: zone + name: internal trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.orders + - node.inventory +- id: zone.trust.partner + kind: zone + name: partner trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.partner +- id: zone.org.internal + kind: zone + name: internal organization + zone_type: fiam.zone-type.organization + members: + - node.orders + - node.inventory +- id: zone.org.partner + kind: zone + name: partner organization + zone_type: fiam.zone-type.organization + members: + - node.partner +assertions: +- id: assertion.declared.orders-uses-inventory + assertion_kind: relation + subject: node.orders + predicate: fiam.relation.uses + polarity: asserted + object_ref: binding.inventory + evidence: + mode: fiam.evidence.declared + source: + type: architecture-declaration + ref: fixture://estate-history/declared + locator: dependency/orders-inventory + observer: fixture.owner + confidence: 1.0 + stance: supports + observed_at: '2026-09-08T00:00:00Z' +extensions: + org.fiam.catalog: + version: 0.2-draft.5 + processed_batches: + - '2222222222222222222222222222222222222222222222222222222222222222' + declared_entity_ids: + - node.orders + - node.inventory + - node.partner + - port.inventory.api + - contract.inventory + - operation.inventory.get + - binding.inventory + last_ingest_at: '2026-09-08T00:00:00Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: none + sample_size: 0 + org.fiam.runtime_aggregates: [] + org.fiam.runtime_topology_observations: + - id: topology.orders-partner + domain: rpc + kind: direct-call + from: node.orders + to: node.partner + count: 12 + first_seen: '2026-09-08T00:00:00Z' + last_seen: '2026-09-08T00:00:00Z' + correlation: fixture + org.fiam.runtime_unresolved: [] + org.fiam.reconciliation_candidates: [] diff --git a/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/snapshot-2026-09-10.yaml b/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/snapshot-2026-09-10.yaml new file mode 100644 index 0000000..e82dfe0 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/history/draft5-fixtures/estate-history/snapshot-2026-09-10.yaml @@ -0,0 +1,140 @@ +fiam_version: '0.2' +instance: + id: model.estate-history.prod + kind: model + title: "Estate history \u2014 production" + status: provisional + intent: Temporal architecture-intelligence fixture. +nodes: +- id: node.orders + kind: system-node + name: Orders + node_type: fiam.node-type.service +- id: node.inventory + kind: system-node + name: Inventory + node_type: fiam.node-type.service +- id: node.partner + kind: system-node + name: Partner API + node_type: fiam.node-type.application +ports: +- id: port.inventory.api + kind: port + owner: node.inventory + participations: + - contract: contract.inventory + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.inventory + kind: interface-contract + name: Inventory API + purpose: + - fiam.purpose.query + operations: + - id: operation.inventory.get + kind: operation + name: getInventory + interaction_style: fiam.interaction-style.request-response +bindings: +- id: binding.inventory + kind: binding + contract: contract.inventory + provider_port: port.inventory.api + operations: + - operation.inventory.get +zones: +- id: zone.environment.prod + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.orders + - node.inventory + - node.partner +- id: zone.trust.internal + kind: zone + name: internal trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.orders + - node.inventory +- id: zone.trust.partner + kind: zone + name: partner trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.partner +- id: zone.org.internal + kind: zone + name: internal organization + zone_type: fiam.zone-type.organization + members: + - node.orders + - node.inventory +- id: zone.org.partner + kind: zone + name: partner organization + zone_type: fiam.zone-type.organization + members: + - node.partner +assertions: +- id: assertion.declared.orders-uses-inventory + assertion_kind: relation + subject: node.orders + predicate: fiam.relation.uses + polarity: asserted + object_ref: binding.inventory + evidence: + mode: fiam.evidence.declared + source: + type: architecture-declaration + ref: fixture://estate-history/declared + locator: dependency/orders-inventory + observer: fixture.owner + confidence: 1.0 + stance: supports + observed_at: '2026-09-10T00:00:00Z' +extensions: + org.fiam.catalog: + version: 0.2-draft.5 + processed_batches: + - '4444444444444444444444444444444444444444444444444444444444444444' + declared_entity_ids: + - node.orders + - node.inventory + - node.partner + - port.inventory.api + - contract.inventory + - operation.inventory.get + - binding.inventory + last_ingest_at: '2026-09-10T00:00:00Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: none + sample_size: 0 + org.fiam.runtime_aggregates: [] + org.fiam.runtime_topology_observations: + - id: topology.orders-partner + domain: rpc + kind: direct-call + from: node.orders + to: node.partner + count: 20 + first_seen: '2026-09-08T00:00:00Z' + last_seen: '2026-09-10T00:00:00Z' + correlation: fixture + - id: topology.orders-inventory.reappeared + domain: rpc + kind: direct-call + from: node.orders + to: node.inventory + binding: binding.inventory + operation: operation.inventory.get + count: 5 + first_seen: '2026-09-10T00:00:00Z' + last_seen: '2026-09-10T00:00:00Z' + correlation: fixture + org.fiam.runtime_unresolved: [] + org.fiam.reconciliation_candidates: [] diff --git a/history/FIAM_v0.2_Draft6/lenses/README.md b/history/FIAM_v0.2_Draft6/lenses/README.md new file mode 100644 index 0000000..c1add23 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/lenses/README.md @@ -0,0 +1,17 @@ +# FIAM Lenses + +A Lens is an analysis/projection over the evidence-preserving FIAM graph and derived Architecture Intelligence Index. It is not a competing ontology and does not introduce primitive interface types. + +Draft.6 ships these executable/reference lenses: + +- `declared-vs-observed.yaml` — evidence-backed property agreement/refinement/conflict; +- `runtime-topology.yaml` — direct RPC, mediated messaging, and resource-oriented DB topology; +- `architecture-changes.yaml` — appeared/disappeared/newly-undeclared logical dependencies; +- `boundary-drift.yaml` — new Zone/trust/organization crossings; +- `architecture-policy.yaml` — named governance/materiality policy over factual findings; +- `operation-coverage.yaml` — observed/dormant/never-observed declared capabilities; +- `security-coverage.yaml` — effective declared security requirements; +- `security-evidence-coverage.yaml` — declared security alongside runtime evidence coverage/unknown; +- `evidence-health.yaml` — conflict, challenge, staleness, and weak support under a named scoring policy. + +Lens outputs are derived query artifacts. They MUST identify relevant policy ids/hashes when interpretation depends on policy and MUST NOT silently rewrite FIAM assertions or historical intervals. diff --git a/history/FIAM_v0.2_Draft6/lenses/architecture-changes.yaml b/history/FIAM_v0.2_Draft6/lenses/architecture-changes.yaml new file mode 100644 index 0000000..5d70194 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/lenses/architecture-changes.yaml @@ -0,0 +1,11 @@ +id: fiam.lens.architecture-changes +version: 0.2-draft.6 +title: Architecture Changes +intent: Surface newly observed, disappeared, and newly undeclared runtime dependencies over a time window from the + persistent FIAM query index. +source: persistent-index +requires_authoritative_closure_for_disappearance: true +classifications: +- appeared +- disappeared +- newly-undeclared diff --git a/history/FIAM_v0.2_Draft6/lenses/architecture-policy.yaml b/history/FIAM_v0.2_Draft6/lenses/architecture-policy.yaml new file mode 100644 index 0000000..b7da445 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/lenses/architecture-policy.yaml @@ -0,0 +1,6 @@ +id: fiam.lens.architecture-policy +version: 0.2-draft.6 +intent: Project named governance policy over architecture-change and boundary facts without mutating FIAM history. +outputs: +- material-dependencies +- policy-violations diff --git a/history/FIAM_v0.2_Draft6/lenses/boundary-drift.yaml b/history/FIAM_v0.2_Draft6/lenses/boundary-drift.yaml new file mode 100644 index 0000000..2e383d5 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/lenses/boundary-drift.yaml @@ -0,0 +1,11 @@ +id: fiam.lens.boundary-drift +version: 0.2-draft.6 +title: Boundary Drift +intent: Surface newly observed runtime dependencies whose endpoints occupy different monitored FIAM Zones, emphasizing + trust-zone and organizational crossings. +source: persistent-index +monitored_zone_types: +- fiam.zone-type.trust-zone +- fiam.zone-type.organization +- fiam.zone-type.deployment-environment +- fiam.zone-type.cluster diff --git a/history/FIAM_v0.2_Draft6/lenses/declared-vs-observed.yaml b/history/FIAM_v0.2_Draft6/lenses/declared-vs-observed.yaml new file mode 100644 index 0000000..9a48cae --- /dev/null +++ b/history/FIAM_v0.2_Draft6/lenses/declared-vs-observed.yaml @@ -0,0 +1,40 @@ +id: fiam.lens.declared-vs-observed +version: 0.2-draft.6 +title: Declared vs Observed Architecture +description: 'Compares evidence-backed declared properties with runtime-observed properties on architectural records + related by corresponds-to. It preserves both source records and classifies agreement, refinement, gaps, and conflicts + without merging identities. + + ' +pair_relation: fiam.relation.corresponds-to +declared_evidence_modes: +- fiam.evidence.declared +observed_evidence_modes: +- fiam.evidence.runtime-observed +comparisons: +- predicate: fiam.property.communication-protocol + subject_kinds: + - binding + strategy: canon-hierarchy + include_missing: true +- predicate: fiam.property.network-protocol-version + subject_kinds: + - binding + strategy: exact + include_missing: true +- predicate: fiam.property.http-method + subject_kinds: + - operation + strategy: exact + include_missing: true +- predicate: fiam.property.server-address + subject_kinds: + - endpoint + strategy: exact + include_missing: true +- predicate: fiam.property.server-port + subject_kinds: + - endpoint + strategy: exact + include_missing: true +owner_resolution: provider-port-owner diff --git a/history/FIAM_v0.2_Draft6/lenses/evidence-health.yaml b/history/FIAM_v0.2_Draft6/lenses/evidence-health.yaml new file mode 100644 index 0000000..a1f4050 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/lenses/evidence-health.yaml @@ -0,0 +1,12 @@ +id: fiam.lens.evidence-health +version: 0.2-draft.6 +intent: Surface conflicting, challenged, stale, and weak architectural facts using query-time evidence scoring. +inputs: +- indexed-assertions +- indexed-evidence +- evidence-scoring-policy +outputs: +- conflicts +- challenged +- stale-runtime-only +- low-support diff --git a/history/FIAM_v0.2_Draft6/lenses/operation-coverage.yaml b/history/FIAM_v0.2_Draft6/lenses/operation-coverage.yaml new file mode 100644 index 0000000..286f510 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/lenses/operation-coverage.yaml @@ -0,0 +1,7 @@ +id: fiam.lens.operation-coverage +version: 0.2-draft.6 +intent: Compare effective declared operations with runtime aggregate last-seen evidence over a window. +outputs: +- observed-in-window +- dormant +- never-observed diff --git a/history/FIAM_v0.2_Draft6/lenses/runtime-topology.yaml b/history/FIAM_v0.2_Draft6/lenses/runtime-topology.yaml new file mode 100644 index 0000000..4d0e92f --- /dev/null +++ b/history/FIAM_v0.2_Draft6/lenses/runtime-topology.yaml @@ -0,0 +1,22 @@ +id: fiam.lens.runtime-topology +version: 0.2-draft.6 +title: Runtime Interaction Topology +description: 'Projects aggregated runtime-observed FIAM architecture observations into dependency/topology edges + while preserving the different structural semantics of RPC calls, mediated messaging, and database resource access. + It does not flatten Channels or InformationResources into generic service-to-service edges. + + ' +evidence_modes: +- fiam.evidence.runtime-observed +- fiam.evidence.inferred +domains: +- rpc +- messaging +- database +preserve_mediation: true +rpc_correlation: trace-parent-when-available +messaging_correlation: span-link-when-available +database_target_relations: +- fiam.relation.reads-from +- fiam.relation.writes-to +- fiam.relation.targets diff --git a/history/FIAM_v0.2_Draft6/lenses/security-coverage.yaml b/history/FIAM_v0.2_Draft6/lenses/security-coverage.yaml new file mode 100644 index 0000000..2cb71ec --- /dev/null +++ b/history/FIAM_v0.2_Draft6/lenses/security-coverage.yaml @@ -0,0 +1,7 @@ +id: fiam.lens.security-coverage +version: 0.2-draft.6 +title: Declared Security Coverage +description: Projects effective declared security requirements per operation, preserving OpenAPI OR alternatives + and AND-within-requirement semantics. Generic OTLP is not treated as evidence that authentication is absent. +source: declared-security-profiles +runtime_absence_semantics: unknown diff --git a/history/FIAM_v0.2_Draft6/lenses/security-evidence-coverage.yaml b/history/FIAM_v0.2_Draft6/lenses/security-evidence-coverage.yaml new file mode 100644 index 0000000..9da1732 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/lenses/security-evidence-coverage.yaml @@ -0,0 +1,7 @@ +id: fiam.lens.security-evidence-coverage +version: 0.2-draft.6 +intent: Show declared authentication coverage alongside explicit runtime security-evidence coverage while preserving + unknown. +outputs: +- declared-security-runtime-evidence-unknown +- declared-security-operation-not-observed diff --git a/history/FIAM_v0.2_Draft6/policies/ARCHITECTURE-GOVERNANCE-v0.2.yaml b/history/FIAM_v0.2_Draft6/policies/ARCHITECTURE-GOVERNANCE-v0.2.yaml new file mode 100644 index 0000000..54ab961 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/policies/ARCHITECTURE-GOVERNANCE-v0.2.yaml @@ -0,0 +1,32 @@ +id: fiam.policy.architecture-governance.v0.2 +version: '0.2' +status: provisional +materiality: + thresholds: + high: 0.75 + medium: 0.45 + weights: + undeclared: 0.35 + trust_boundary: 0.25 + organization_boundary: 0.15 + high_volume: 0.15 + strong_evidence: 0.10 + high_volume_observation_count: 100 +boundary_rules: + - id: require-declaration-internal-to-partner + zone_type: fiam.zone-type.trust-zone + from_zone: zone.trust.internal + to_zone: zone.trust.partner + condition: require-declared + severity: high + - id: forbid-prod-to-untrusted + zone_type: fiam.zone-type.trust-zone + from_zone: zone.trust.internal + to_zone: zone.trust.untrusted + condition: forbid + severity: critical +dormancy: + default_days: 90 +evidence_health: + stale_runtime_days: 30 + conflict_min_support: 0.45 diff --git a/history/FIAM_v0.2_Draft6/policies/CORE-FREEZE.sha256 b/history/FIAM_v0.2_Draft6/policies/CORE-FREEZE.sha256 new file mode 100644 index 0000000..4a24864 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/policies/CORE-FREEZE.sha256 @@ -0,0 +1 @@ +a6fce1b19ab7009069a1c8552fc6035cabd8707cb63b647350396d36785668d9 schemas/FIAM-Core-v0.2.schema.json diff --git a/history/FIAM_v0.2_Draft6/policies/EVIDENCE-SCORING-v0.2.yaml b/history/FIAM_v0.2_Draft6/policies/EVIDENCE-SCORING-v0.2.yaml new file mode 100644 index 0000000..ef4e6b2 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/policies/EVIDENCE-SCORING-v0.2.yaml @@ -0,0 +1,51 @@ +policy_version: '0.2' +id: fiam.policy.evidence-scoring.default +intent: Rank evidential support for architecture-intelligence queries without turning heuristic scores into truth probabilities + or rewriting source assertions. +combination: independent-noisy-or +independence_key: +- mode +- source.type +- source.ref +- source.locator +mode_weights: + fiam.evidence.declared: 1.0 + fiam.evidence.static-observed: 0.9 + fiam.evidence.runtime-observed: 0.95 + fiam.evidence.inferred: 0.65 +source_type_weights: + openapi-document: 1.0 + architecture-declaration: 1.0 + otlp-trace-stream: 0.95 + otlp-trace-export: 0.95 + otlp-aggregate: 0.98 + schema-structural-fingerprint: 0.7 + reconciliation-rule: 0.65 + database-resource-mapping: 0.8 + database-operation-semantics: 0.8 + architecture-fixture: 0.6 + entity-ref: 0.85 +default_source_type_weight: 0.8 +default_confidence: 0.75 +freshness: + fiam.evidence.runtime-observed: + half_life_days: 14 + floor: 0.25 + fiam.evidence.inferred: + half_life_days: 30 + floor: 0.4 + fiam.evidence.declared: + half_life_days: null + floor: 1.0 + fiam.evidence.static-observed: + half_life_days: null + floor: 1.0 +interpretation: + strong: 0.85 + moderate: 0.6 + weak: 0.3 +notes: +- Scores are query-ranking heuristics, not calibrated probabilities. +- Supporting and challenging evidence are scored separately. +- Independent sources combine; repeated observations from one locator do not count as independent corroboration. +- Runtime freshness decays for ranking purposes without deleting or mutating historical evidence. diff --git a/history/FIAM_v0.2_Draft6/policies/FIAM-ShapeIdentity-v0.2.md b/history/FIAM_v0.2_Draft6/policies/FIAM-ShapeIdentity-v0.2.md new file mode 100644 index 0000000..63ff4a6 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/policies/FIAM-ShapeIdentity-v0.2.md @@ -0,0 +1,56 @@ +# FIAM v0.2 — InformationShape Identity Policy + +## Purpose + +FIAM treats `InformationShape` as an architectural identity node, not as a schema document and not as a wire-format label. This policy governs when separately discovered descriptions should be represented as one shape, multiple related shapes, or unresolved candidates. + +## Identity rule + +Two observations may refer to the **same InformationShape** when they are intended to describe the same admissible semantic/structural form even if they originate in different artifacts, languages, bindings, or representations. + +Examples: one `Customer` shape described by OpenAPI and standalone JSON Schema; the same `Product` shape encoded as JSON and CBOR; a Java declaration and an API schema that an authoritative source explicitly maps to the same contract type. + +## New shape rule + +Create a distinct shape identity when a structural/constraint difference matters to the architecture, when a shape is intentionally versioned, or when a projection/subset/view exposes a different admissible form. Use `version-of` for lineage and `projection-of` for intentional views/projections. + +Do **not** mint a new shape merely because another artifact describes it or another representation carries it. + +## Uncertain reconciliation + +Independent ingest sources should not immediately use `same-entity-as`. Prefer `corresponds-to` or `observationally-equivalent-to` while identity is uncertain. Promote to evidence-backed `same-entity-as` only when there is sufficient authoritative evidence. + +`same-entity-as`, `alias-of`, `version-of`, and `observationally-equivalent-to` require subject and object to have the same FIAM entity kind. Identity assertions never delete source entities or evidence; repository reconciliation is a separate operation. + +## Resource and shape + +A stable InformationResource can change shape over time. Preserve separate shape identities with validity windows rather than overwriting history. A collection-like resource may `conforms-to-shape` a collection shape and separately use `element-shape` for its members. + +## Artifact, representation, and shape + +- Artifact: concrete declaration/implementation (`openapi.yaml`, `.proto`, DDL, Java source). +- Shape: logical admissible form. +- Representation: JSON, protobuf, command tokens, native object, etc. +- Resource: identifiable information-bearing locus/state/collection. + +These identities must not be collapsed. + +## Operational query semantics (draft.1) + +An asserted `same-entity-as` edge places the participating IDs in one **query-time equivalence class**. It does not physically merge records. Traversal or presentation layers may collapse the class for convenience, but must retain and expose the original IDs and their evidence. + +`corresponds-to` and `observationally-equivalent-to` do not create identity equivalence classes. + +## Operational promotion guard (draft.1) + +Automated tools must not promote structural or fingerprint equality directly to `same-entity-as`. + +Default behavior: + +1. create `corresponds-to` for plausible matches; +2. accumulate independent evidence; +3. require a governed/authoritative identity decision for normal promotion; +4. if `same-entity-as` is asserted purely from inferred evidence, require at least two independent signals at confidence `>= 0.98`; +5. even when that inferred threshold is met, default tooling must not auto-promote without reconciliation policy/authority. + +The validator operationalizes the minimum inferred-evidence guard. `tools/identity_view.py` operationalizes non-destructive query equivalence and candidate reporting. diff --git a/history/FIAM_v0.2_Draft6/policies/SNAPSHOT-AUTHORITY-v0.2.yaml b/history/FIAM_v0.2_Draft6/policies/SNAPSHOT-AUTHORITY-v0.2.yaml new file mode 100644 index 0000000..57d396e --- /dev/null +++ b/history/FIAM_v0.2_Draft6/policies/SNAPSHOT-AUTHORITY-v0.2.yaml @@ -0,0 +1,47 @@ +id: fiam.policy.snapshot-authority.v0.2 +version: '0.2' +status: provisional +principles: + - Authority is scoped to an explicitly named observation population and domain set. + - A source may close only observations owned by its observation_scope. + - Sampled or incremental sources never prove absence. + - Overlap between different observation scopes is allowed and unioned at query time; overlap inside one observation_scope requires explicit layering. + - Closure is a policy action distinct from last_seen evidence. +defaults: + grace_hours: 6 + absence_snapshots: 2 +sources: + collector.prod.app-traces: + authoritative: true + observation_scope: prod-cluster-a-app-traces + population_id: prod-cluster-a + population: + environment: prod + cluster: cluster-a + platform: application-traces + domains: [http, rpc, database] + grace_hours: 6 + absence_snapshots: 2 + collector.prod.messaging: + authoritative: true + observation_scope: prod-cluster-a-messaging + population_id: prod-cluster-a + population: + environment: prod + cluster: cluster-a + platform: messaging-telemetry + domains: [messaging] + grace_hours: 6 + absence_snapshots: 2 + collector.prod.mesh: + authoritative: true + observation_scope: prod-cluster-a-mesh + population_id: prod-cluster-a + population: + environment: prod + cluster: cluster-a + platform: service-mesh + domains: [http, rpc] + grace_hours: 6 + absence_snapshots: 2 +layered_scopes: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/bad-authority-scope.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/bad-authority-scope.yaml new file mode 100644 index 0000000..1dfa503 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/bad-authority-scope.yaml @@ -0,0 +1,170 @@ +catalog_exchange_version: '0.2' +created_at: '2026-09-01T00:00:00Z' +exchange_id: exchange.bad.authority-scope +observation: + aggregate_semantics: cumulative + authority_policy_id: fiam.policy.snapshot-authority.v0.2 + domains: + - rpc + mode: complete-snapshot + observation_scope: prod-cluster-a-app-traces + population: + cluster: cluster-a + environment: prod + platform: service-mesh + population_id: prod-cluster-a + snapshot_time: '2026-09-01T00:00:00Z' +profile_id: fiam.catalog-exchange.v0.2 +records: + assertions: [] + declared_entity_ids: [] + entities: + - entity: + id: node.orders + kind: system-node + name: Orders + node_type: fiam.node-type.service + section: nodes + - entity: + id: node.inventory + kind: system-node + name: Inventory + node_type: fiam.node-type.service + section: nodes + - entity: + id: node.partner + kind: system-node + name: Partner API + node_type: fiam.node-type.application + section: nodes + - entity: + id: port.inventory.api + kind: port + owner: node.inventory + participations: + - contract: contract.inventory + mode: offers + roles: + - fiam.role.server + section: ports + - entity: + id: contract.inventory + kind: interface-contract + name: Inventory API + operations: + - id: operation.inventory.get + interaction_style: fiam.interaction-style.request-response + kind: operation + name: getInventory + purpose: + - fiam.purpose.query + section: contracts + - entity: + contract: contract.inventory + id: binding.inventory + kind: binding + operations: + - operation.inventory.get + provider_port: port.inventory.api + section: bindings + - entity: + id: zone.environment.prod + kind: zone + members: + - node.orders + - node.inventory + - node.partner + name: production + zone_type: fiam.zone-type.deployment-environment + section: zones + - entity: + id: zone.trust.internal + kind: zone + members: + - node.orders + - node.inventory + name: internal trust domain + zone_type: fiam.zone-type.trust-zone + section: zones + - entity: + id: zone.trust.partner + kind: zone + members: + - node.partner + name: partner trust domain + zone_type: fiam.zone-type.trust-zone + section: zones + - entity: + id: zone.org.internal + kind: zone + members: + - node.orders + - node.inventory + name: internal organization + zone_type: fiam.zone-type.organization + section: zones + - entity: + id: zone.org.partner + kind: zone + members: + - node.partner + name: partner organization + zone_type: fiam.zone-type.organization + section: zones + reconciliation_candidates: [] + runtime_aggregates: [] + topology_observations: + - binding: binding.inventory + correlation: fixture + count: 100 + domain: rpc + first_seen: '2026-08-25T00:00:00Z' + from: node.orders + id: topology.orders-inventory + kind: direct-call + last_seen: '2026-09-01T00:00:00Z' + operation: operation.inventory.get + to: node.inventory + unresolved: [] + zone_memberships: + - derived: false + member_id: node.inventory + zone_id: zone.environment.prod + zone_type: fiam.zone-type.deployment-environment + - derived: false + member_id: node.orders + zone_id: zone.environment.prod + zone_type: fiam.zone-type.deployment-environment + - derived: false + member_id: node.partner + zone_id: zone.environment.prod + zone_type: fiam.zone-type.deployment-environment + - derived: false + member_id: node.inventory + zone_id: zone.org.internal + zone_type: fiam.zone-type.organization + - derived: false + member_id: node.orders + zone_id: zone.org.internal + zone_type: fiam.zone-type.organization + - derived: false + member_id: node.partner + zone_id: zone.org.partner + zone_type: fiam.zone-type.organization + - derived: false + member_id: node.inventory + zone_id: zone.trust.internal + zone_type: fiam.zone-type.trust-zone + - derived: false + member_id: node.orders + zone_id: zone.trust.internal + zone_type: fiam.zone-type.trust-zone + - derived: false + member_id: node.partner + zone_id: zone.trust.partner + zone_type: fiam.zone-type.trust-zone +source: + content_hash: 5d9aa3c294efa4a8b13b5c291837a19f9cb795e364370ec414f64202fa017c9b + source_id: collector.prod.mesh + source_kind: otel-mesh-adapter + source_ref: estate://collector/prod/mesh diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/declared-2026-09-01.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/declared-2026-09-01.yaml new file mode 100644 index 0000000..f5bfb48 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/declared-2026-09-01.yaml @@ -0,0 +1,177 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.579770301744fd3e9b7d3709 +created_at: '2026-09-01T00:00:00Z' +source: + source_id: architecture.git + source_kind: openapi-and-architecture + source_ref: estate://architecture/prod + content_hash: 5d9aa3c294efa4a8b13b5c291837a19f9cb795e364370ec414f64202fa017c9b +observation: + mode: declared-snapshot + snapshot_time: '2026-09-01T00:00:00Z' + observation_scope: null + population_id: prod-cluster-a + population: {} + domains: [] + aggregate_semantics: cumulative +records: + entities: + - section: nodes + entity: + id: node.orders + kind: system-node + name: Orders + node_type: fiam.node-type.service + - section: nodes + entity: + id: node.inventory + kind: system-node + name: Inventory + node_type: fiam.node-type.service + - section: nodes + entity: + id: node.partner + kind: system-node + name: Partner API + node_type: fiam.node-type.application + - section: ports + entity: + id: port.inventory.api + kind: port + owner: node.inventory + participations: + - contract: contract.inventory + mode: offers + roles: + - fiam.role.server + - section: contracts + entity: + id: contract.inventory + kind: interface-contract + name: Inventory API + purpose: + - fiam.purpose.query + operations: + - id: operation.inventory.get + kind: operation + name: getInventory + interaction_style: fiam.interaction-style.request-response + - section: bindings + entity: + id: binding.inventory + kind: binding + contract: contract.inventory + provider_port: port.inventory.api + operations: + - operation.inventory.get + - section: zones + entity: + id: zone.environment.prod + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.orders + - node.inventory + - node.partner + - section: zones + entity: + id: zone.trust.internal + kind: zone + name: internal trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.orders + - node.inventory + - section: zones + entity: + id: zone.trust.partner + kind: zone + name: partner trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.partner + - section: zones + entity: + id: zone.org.internal + kind: zone + name: internal organization + zone_type: fiam.zone-type.organization + members: + - node.orders + - node.inventory + - section: zones + entity: + id: zone.org.partner + kind: zone + name: partner organization + zone_type: fiam.zone-type.organization + members: + - node.partner + assertions: + - id: assertion.declared.orders-uses-inventory + assertion_kind: relation + subject: node.orders + predicate: fiam.relation.uses + polarity: asserted + object_ref: binding.inventory + evidence: + mode: fiam.evidence.declared + source: + type: architecture-declaration + ref: fixture://estate-history/declared + locator: dependency/orders-inventory + observer: fixture.owner + confidence: 1.0 + stance: supports + observed_at: '2026-09-01T00:00:00Z' + zone_memberships: + - zone_id: zone.environment.prod + member_id: node.inventory + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.environment.prod + member_id: node.orders + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.environment.prod + member_id: node.partner + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.org.internal + member_id: node.inventory + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.org.internal + member_id: node.orders + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.org.partner + member_id: node.partner + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.trust.internal + member_id: node.inventory + zone_type: fiam.zone-type.trust-zone + derived: false + - zone_id: zone.trust.internal + member_id: node.orders + zone_type: fiam.zone-type.trust-zone + derived: false + - zone_id: zone.trust.partner + member_id: node.partner + zone_type: fiam.zone-type.trust-zone + derived: false + runtime_aggregates: [] + topology_observations: [] + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: + - node.orders + - node.inventory + - node.partner + - port.inventory.api + - contract.inventory + - operation.inventory.get + - binding.inventory diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/evidence-health.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/evidence-health.yaml new file mode 100644 index 0000000..ec01900 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/evidence-health.yaml @@ -0,0 +1,106 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.evidence-health +created_at: '2026-09-09T00:00:00Z' +source: + source_id: fixture.evidence + source_kind: architecture-and-runtime + source_ref: fixture://evidence + content_hash: null +observation: + mode: declared-snapshot + observation_scope: null + population_id: evidence-pop + population: {} + domains: [] + snapshot_time: '2026-09-09T00:00:00Z' + aggregate_semantics: cumulative +records: + entities: + - section: nodes + entity: + id: node.evidence.api + kind: system-node + name: Evidence API + node_type: fiam.node-type.service + assertions: + - id: assertion.protocol.http11 + assertion_kind: property + subject: node.evidence.api + predicate: fiam.property.network-protocol-version + polarity: asserted + value: '1.1' + evidence: + - mode: fiam.evidence.declared + source: + type: architecture-declaration + ref: arch://http-policy + locator: fixture + observer: fixture + observed_at: '2026-09-08T00:00:00Z' + confidence: 0.95 + stance: supports + - id: assertion.protocol.http2 + assertion_kind: property + subject: node.evidence.api + predicate: fiam.property.network-protocol-version + polarity: asserted + value: '2' + evidence: + - mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: otel://old-http2 + locator: fixture + observer: fixture + observed_at: '2026-08-25T00:00:00Z' + confidence: 0.95 + stance: supports + - id: assertion.service-name + assertion_kind: property + subject: node.evidence.api + predicate: fiam.property.service-name + polarity: asserted + value: evidence-api + evidence: + - mode: fiam.evidence.declared + source: + type: architecture-declaration + ref: arch://service + locator: fixture + observer: fixture + observed_at: '2026-09-08T00:00:00Z' + confidence: 0.95 + stance: supports + - mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: otel://challenge + locator: fixture + observer: fixture + observed_at: '2026-09-08T01:00:00Z' + confidence: 0.8 + stance: challenges + - id: assertion.stale-peer + assertion_kind: property + subject: node.evidence.api + predicate: fiam.property.service-peer-name + polarity: asserted + value: legacy-peer + evidence: + - mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: otel://legacy-peer + locator: fixture + observer: fixture + observed_at: '2026-06-01T00:00:00Z' + confidence: 0.95 + stance: supports + zone_memberships: [] + runtime_aggregates: [] + topology_observations: [] + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: + - node.evidence.api diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/mesh-runtime-2026-09-01.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/mesh-runtime-2026-09-01.yaml new file mode 100644 index 0000000..e651029 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/mesh-runtime-2026-09-01.yaml @@ -0,0 +1,170 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.32f0ef0c9e863d095b026e5d +created_at: '2026-09-01T00:00:00Z' +source: + source_id: collector.prod.mesh + source_kind: otel-mesh-adapter + source_ref: estate://collector/prod/mesh + content_hash: 5d9aa3c294efa4a8b13b5c291837a19f9cb795e364370ec414f64202fa017c9b +observation: + mode: complete-snapshot + snapshot_time: '2026-09-01T00:00:00Z' + observation_scope: prod-cluster-a-mesh + population_id: prod-cluster-a + population: + environment: prod + cluster: cluster-a + platform: service-mesh + domains: + - rpc + aggregate_semantics: cumulative + authority_policy_id: fiam.policy.snapshot-authority.v0.2 +records: + entities: + - section: nodes + entity: + id: node.orders + kind: system-node + name: Orders + node_type: fiam.node-type.service + - section: nodes + entity: + id: node.inventory + kind: system-node + name: Inventory + node_type: fiam.node-type.service + - section: nodes + entity: + id: node.partner + kind: system-node + name: Partner API + node_type: fiam.node-type.application + - section: ports + entity: + id: port.inventory.api + kind: port + owner: node.inventory + participations: + - contract: contract.inventory + mode: offers + roles: + - fiam.role.server + - section: contracts + entity: + id: contract.inventory + kind: interface-contract + name: Inventory API + purpose: + - fiam.purpose.query + operations: + - id: operation.inventory.get + kind: operation + name: getInventory + interaction_style: fiam.interaction-style.request-response + - section: bindings + entity: + id: binding.inventory + kind: binding + contract: contract.inventory + provider_port: port.inventory.api + operations: + - operation.inventory.get + - section: zones + entity: + id: zone.environment.prod + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.orders + - node.inventory + - node.partner + - section: zones + entity: + id: zone.trust.internal + kind: zone + name: internal trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.orders + - node.inventory + - section: zones + entity: + id: zone.trust.partner + kind: zone + name: partner trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.partner + - section: zones + entity: + id: zone.org.internal + kind: zone + name: internal organization + zone_type: fiam.zone-type.organization + members: + - node.orders + - node.inventory + - section: zones + entity: + id: zone.org.partner + kind: zone + name: partner organization + zone_type: fiam.zone-type.organization + members: + - node.partner + assertions: [] + zone_memberships: + - zone_id: zone.environment.prod + member_id: node.inventory + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.environment.prod + member_id: node.orders + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.environment.prod + member_id: node.partner + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.org.internal + member_id: node.inventory + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.org.internal + member_id: node.orders + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.org.partner + member_id: node.partner + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.trust.internal + member_id: node.inventory + zone_type: fiam.zone-type.trust-zone + derived: false + - zone_id: zone.trust.internal + member_id: node.orders + zone_type: fiam.zone-type.trust-zone + derived: false + - zone_id: zone.trust.partner + member_id: node.partner + zone_type: fiam.zone-type.trust-zone + derived: false + runtime_aggregates: [] + topology_observations: + - id: topology.orders-inventory + domain: rpc + kind: direct-call + from: node.orders + to: node.inventory + binding: binding.inventory + operation: operation.inventory.get + count: 100 + first_seen: '2026-08-25T00:00:00Z' + last_seen: '2026-09-01T00:00:00Z' + correlation: fixture + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/runtime-2026-09-01.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/runtime-2026-09-01.yaml new file mode 100644 index 0000000..bd1abde --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/runtime-2026-09-01.yaml @@ -0,0 +1,170 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.d41216a2d3882ac1dff2b4e6 +created_at: '2026-09-01T00:00:00Z' +source: + source_id: collector.prod.app-traces + source_kind: otlp-adapter + source_ref: estate://collector/prod/app-traces + content_hash: 5d9aa3c294efa4a8b13b5c291837a19f9cb795e364370ec414f64202fa017c9b +observation: + mode: complete-snapshot + snapshot_time: '2026-09-01T00:00:00Z' + observation_scope: prod-cluster-a-app-traces + population_id: prod-cluster-a + population: + environment: prod + cluster: cluster-a + platform: application-traces + domains: + - rpc + aggregate_semantics: cumulative + authority_policy_id: fiam.policy.snapshot-authority.v0.2 +records: + entities: + - section: nodes + entity: + id: node.orders + kind: system-node + name: Orders + node_type: fiam.node-type.service + - section: nodes + entity: + id: node.inventory + kind: system-node + name: Inventory + node_type: fiam.node-type.service + - section: nodes + entity: + id: node.partner + kind: system-node + name: Partner API + node_type: fiam.node-type.application + - section: ports + entity: + id: port.inventory.api + kind: port + owner: node.inventory + participations: + - contract: contract.inventory + mode: offers + roles: + - fiam.role.server + - section: contracts + entity: + id: contract.inventory + kind: interface-contract + name: Inventory API + purpose: + - fiam.purpose.query + operations: + - id: operation.inventory.get + kind: operation + name: getInventory + interaction_style: fiam.interaction-style.request-response + - section: bindings + entity: + id: binding.inventory + kind: binding + contract: contract.inventory + provider_port: port.inventory.api + operations: + - operation.inventory.get + - section: zones + entity: + id: zone.environment.prod + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.orders + - node.inventory + - node.partner + - section: zones + entity: + id: zone.trust.internal + kind: zone + name: internal trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.orders + - node.inventory + - section: zones + entity: + id: zone.trust.partner + kind: zone + name: partner trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.partner + - section: zones + entity: + id: zone.org.internal + kind: zone + name: internal organization + zone_type: fiam.zone-type.organization + members: + - node.orders + - node.inventory + - section: zones + entity: + id: zone.org.partner + kind: zone + name: partner organization + zone_type: fiam.zone-type.organization + members: + - node.partner + assertions: [] + zone_memberships: + - zone_id: zone.environment.prod + member_id: node.inventory + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.environment.prod + member_id: node.orders + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.environment.prod + member_id: node.partner + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.org.internal + member_id: node.inventory + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.org.internal + member_id: node.orders + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.org.partner + member_id: node.partner + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.trust.internal + member_id: node.inventory + zone_type: fiam.zone-type.trust-zone + derived: false + - zone_id: zone.trust.internal + member_id: node.orders + zone_type: fiam.zone-type.trust-zone + derived: false + - zone_id: zone.trust.partner + member_id: node.partner + zone_type: fiam.zone-type.trust-zone + derived: false + runtime_aggregates: [] + topology_observations: + - id: topology.orders-inventory + domain: rpc + kind: direct-call + from: node.orders + to: node.inventory + binding: binding.inventory + operation: operation.inventory.get + count: 100 + first_seen: '2026-08-25T00:00:00Z' + last_seen: '2026-09-01T00:00:00Z' + correlation: fixture + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/runtime-2026-09-08.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/runtime-2026-09-08.yaml new file mode 100644 index 0000000..46696f0 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/runtime-2026-09-08.yaml @@ -0,0 +1,168 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.8f690b6aa87b67f18cb9b593 +created_at: '2026-09-08T00:00:00Z' +source: + source_id: collector.prod.app-traces + source_kind: otlp-adapter + source_ref: estate://collector/prod/app-traces + content_hash: 7384989f29f9a26eec85ed4eae54235a09856c705e96cc3e2d4e9dca8afcdb50 +observation: + mode: complete-snapshot + snapshot_time: '2026-09-08T00:00:00Z' + observation_scope: prod-cluster-a-app-traces + population_id: prod-cluster-a + population: + environment: prod + cluster: cluster-a + platform: application-traces + domains: + - rpc + aggregate_semantics: cumulative + authority_policy_id: fiam.policy.snapshot-authority.v0.2 +records: + entities: + - section: nodes + entity: + id: node.orders + kind: system-node + name: Orders + node_type: fiam.node-type.service + - section: nodes + entity: + id: node.inventory + kind: system-node + name: Inventory + node_type: fiam.node-type.service + - section: nodes + entity: + id: node.partner + kind: system-node + name: Partner API + node_type: fiam.node-type.application + - section: ports + entity: + id: port.inventory.api + kind: port + owner: node.inventory + participations: + - contract: contract.inventory + mode: offers + roles: + - fiam.role.server + - section: contracts + entity: + id: contract.inventory + kind: interface-contract + name: Inventory API + purpose: + - fiam.purpose.query + operations: + - id: operation.inventory.get + kind: operation + name: getInventory + interaction_style: fiam.interaction-style.request-response + - section: bindings + entity: + id: binding.inventory + kind: binding + contract: contract.inventory + provider_port: port.inventory.api + operations: + - operation.inventory.get + - section: zones + entity: + id: zone.environment.prod + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.orders + - node.inventory + - node.partner + - section: zones + entity: + id: zone.trust.internal + kind: zone + name: internal trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.orders + - node.inventory + - section: zones + entity: + id: zone.trust.partner + kind: zone + name: partner trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.partner + - section: zones + entity: + id: zone.org.internal + kind: zone + name: internal organization + zone_type: fiam.zone-type.organization + members: + - node.orders + - node.inventory + - section: zones + entity: + id: zone.org.partner + kind: zone + name: partner organization + zone_type: fiam.zone-type.organization + members: + - node.partner + assertions: [] + zone_memberships: + - zone_id: zone.environment.prod + member_id: node.inventory + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.environment.prod + member_id: node.orders + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.environment.prod + member_id: node.partner + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.org.internal + member_id: node.inventory + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.org.internal + member_id: node.orders + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.org.partner + member_id: node.partner + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.trust.internal + member_id: node.inventory + zone_type: fiam.zone-type.trust-zone + derived: false + - zone_id: zone.trust.internal + member_id: node.orders + zone_type: fiam.zone-type.trust-zone + derived: false + - zone_id: zone.trust.partner + member_id: node.partner + zone_type: fiam.zone-type.trust-zone + derived: false + runtime_aggregates: [] + topology_observations: + - id: topology.orders-partner + domain: rpc + kind: direct-call + from: node.orders + to: node.partner + count: 12 + first_seen: '2026-09-08T00:00:00Z' + last_seen: '2026-09-08T00:00:00Z' + correlation: fixture + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/runtime-2026-09-09.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/runtime-2026-09-09.yaml new file mode 100644 index 0000000..56c7db9 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/runtime-2026-09-09.yaml @@ -0,0 +1,168 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.5028fed51f1365aedeb7ca55 +created_at: '2026-09-09T00:00:00Z' +source: + source_id: collector.prod.app-traces + source_kind: otlp-adapter + source_ref: estate://collector/prod/app-traces + content_hash: 7384989f29f9a26eec85ed4eae54235a09856c705e96cc3e2d4e9dca8afcdb50 +observation: + mode: complete-snapshot + snapshot_time: '2026-09-09T00:00:00Z' + observation_scope: prod-cluster-a-app-traces + population_id: prod-cluster-a + population: + environment: prod + cluster: cluster-a + platform: application-traces + domains: + - rpc + aggregate_semantics: cumulative + authority_policy_id: fiam.policy.snapshot-authority.v0.2 +records: + entities: + - section: nodes + entity: + id: node.orders + kind: system-node + name: Orders + node_type: fiam.node-type.service + - section: nodes + entity: + id: node.inventory + kind: system-node + name: Inventory + node_type: fiam.node-type.service + - section: nodes + entity: + id: node.partner + kind: system-node + name: Partner API + node_type: fiam.node-type.application + - section: ports + entity: + id: port.inventory.api + kind: port + owner: node.inventory + participations: + - contract: contract.inventory + mode: offers + roles: + - fiam.role.server + - section: contracts + entity: + id: contract.inventory + kind: interface-contract + name: Inventory API + purpose: + - fiam.purpose.query + operations: + - id: operation.inventory.get + kind: operation + name: getInventory + interaction_style: fiam.interaction-style.request-response + - section: bindings + entity: + id: binding.inventory + kind: binding + contract: contract.inventory + provider_port: port.inventory.api + operations: + - operation.inventory.get + - section: zones + entity: + id: zone.environment.prod + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.orders + - node.inventory + - node.partner + - section: zones + entity: + id: zone.trust.internal + kind: zone + name: internal trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.orders + - node.inventory + - section: zones + entity: + id: zone.trust.partner + kind: zone + name: partner trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.partner + - section: zones + entity: + id: zone.org.internal + kind: zone + name: internal organization + zone_type: fiam.zone-type.organization + members: + - node.orders + - node.inventory + - section: zones + entity: + id: zone.org.partner + kind: zone + name: partner organization + zone_type: fiam.zone-type.organization + members: + - node.partner + assertions: [] + zone_memberships: + - zone_id: zone.environment.prod + member_id: node.inventory + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.environment.prod + member_id: node.orders + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.environment.prod + member_id: node.partner + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.org.internal + member_id: node.inventory + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.org.internal + member_id: node.orders + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.org.partner + member_id: node.partner + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.trust.internal + member_id: node.inventory + zone_type: fiam.zone-type.trust-zone + derived: false + - zone_id: zone.trust.internal + member_id: node.orders + zone_type: fiam.zone-type.trust-zone + derived: false + - zone_id: zone.trust.partner + member_id: node.partner + zone_type: fiam.zone-type.trust-zone + derived: false + runtime_aggregates: [] + topology_observations: + - id: topology.orders-partner + domain: rpc + kind: direct-call + from: node.orders + to: node.partner + count: 12 + first_seen: '2026-09-08T00:00:00Z' + last_seen: '2026-09-08T00:00:00Z' + correlation: fixture + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/runtime-2026-09-10.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/runtime-2026-09-10.yaml new file mode 100644 index 0000000..c9b2faa --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/runtime-2026-09-10.yaml @@ -0,0 +1,179 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.14331448fd1f498bb4d812cf +created_at: '2026-09-10T00:00:00Z' +source: + source_id: collector.prod.app-traces + source_kind: otlp-adapter + source_ref: estate://collector/prod/app-traces + content_hash: b1a6db4f17c375349d216a4e43aae340bbd3c9a1521902fc162f2e4ee79408cb +observation: + mode: complete-snapshot + snapshot_time: '2026-09-10T00:00:00Z' + observation_scope: prod-cluster-a-app-traces + population_id: prod-cluster-a + population: + environment: prod + cluster: cluster-a + platform: application-traces + domains: + - rpc + aggregate_semantics: cumulative + authority_policy_id: fiam.policy.snapshot-authority.v0.2 +records: + entities: + - section: nodes + entity: + id: node.orders + kind: system-node + name: Orders + node_type: fiam.node-type.service + - section: nodes + entity: + id: node.inventory + kind: system-node + name: Inventory + node_type: fiam.node-type.service + - section: nodes + entity: + id: node.partner + kind: system-node + name: Partner API + node_type: fiam.node-type.application + - section: ports + entity: + id: port.inventory.api + kind: port + owner: node.inventory + participations: + - contract: contract.inventory + mode: offers + roles: + - fiam.role.server + - section: contracts + entity: + id: contract.inventory + kind: interface-contract + name: Inventory API + purpose: + - fiam.purpose.query + operations: + - id: operation.inventory.get + kind: operation + name: getInventory + interaction_style: fiam.interaction-style.request-response + - section: bindings + entity: + id: binding.inventory + kind: binding + contract: contract.inventory + provider_port: port.inventory.api + operations: + - operation.inventory.get + - section: zones + entity: + id: zone.environment.prod + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.orders + - node.inventory + - node.partner + - section: zones + entity: + id: zone.trust.internal + kind: zone + name: internal trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.orders + - node.inventory + - section: zones + entity: + id: zone.trust.partner + kind: zone + name: partner trust domain + zone_type: fiam.zone-type.trust-zone + members: + - node.partner + - section: zones + entity: + id: zone.org.internal + kind: zone + name: internal organization + zone_type: fiam.zone-type.organization + members: + - node.orders + - node.inventory + - section: zones + entity: + id: zone.org.partner + kind: zone + name: partner organization + zone_type: fiam.zone-type.organization + members: + - node.partner + assertions: [] + zone_memberships: + - zone_id: zone.environment.prod + member_id: node.inventory + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.environment.prod + member_id: node.orders + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.environment.prod + member_id: node.partner + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.org.internal + member_id: node.inventory + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.org.internal + member_id: node.orders + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.org.partner + member_id: node.partner + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.trust.internal + member_id: node.inventory + zone_type: fiam.zone-type.trust-zone + derived: false + - zone_id: zone.trust.internal + member_id: node.orders + zone_type: fiam.zone-type.trust-zone + derived: false + - zone_id: zone.trust.partner + member_id: node.partner + zone_type: fiam.zone-type.trust-zone + derived: false + runtime_aggregates: [] + topology_observations: + - id: topology.orders-partner + domain: rpc + kind: direct-call + from: node.orders + to: node.partner + count: 20 + first_seen: '2026-09-08T00:00:00Z' + last_seen: '2026-09-10T00:00:00Z' + correlation: fixture + - id: topology.orders-inventory.reappeared + domain: rpc + kind: direct-call + from: node.orders + to: node.inventory + binding: binding.inventory + operation: operation.inventory.get + count: 5 + first_seen: '2026-09-10T00:00:00Z' + last_seen: '2026-09-10T00:00:00Z' + correlation: fixture + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/security-declared.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/security-declared.yaml new file mode 100644 index 0000000..ed6f4f2 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/security-declared.yaml @@ -0,0 +1,696 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.2d2eb13476c62be2b7514239 +created_at: '2026-09-01T00:00:00Z' +source: + source_id: architecture.openapi + source_kind: openapi-adapter + source_ref: estate://openapi/security-api + content_hash: bf2b36b164e0549fcaabf775ce3e6ed08ce4dea89ec6086030717421c07e69c4 +observation: + mode: declared-snapshot + snapshot_time: '2026-09-01T00:00:00Z' + observation_scope: null + population_id: security-prod + population: {} + domains: [] + aggregate_semantics: cumulative +records: + entities: + - section: nodes + entity: + id: node.openapi.estate-security-api + kind: system-node + name: Estate Security API + node_type: fiam.node-type.service + - section: ports + entity: + id: port.openapi.estate-security-api + owner: node.openapi.estate-security-api + participations: + - contract: contract.openapi.estate-security-api + mode: offers + - section: contracts + entity: + id: contract.openapi.estate-security-api + kind: interface-contract + name: Estate Security API + contract_forms: + - fiam.contract-form.openapi + operations: + - id: operation.openapi.estate-security-api.listItems + kind: operation + name: listItems + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /items + x-openapi-operation-id: listItems + - id: operation.openapi.estate-security-api.createItem + kind: operation + name: createItem + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.write + purpose: + - fiam.purpose.mutation + x-http-method: POST + x-openapi-path: /items + x-openapi-operation-id: createItem + - id: operation.openapi.estate-security-api.optionalInfo + kind: operation + name: optionalInfo + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /optional + x-openapi-operation-id: optionalInfo + - id: operation.openapi.estate-security-api.publicInfo + kind: operation + name: publicInfo + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /public + x-openapi-operation-id: publicInfo + - section: endpoints + entity: + id: endpoint.openapi.estate-security-api.1 + kind: endpoint + name: OpenAPI server 1 + address: https://security.example.test + address_scheme: fiam.address-scheme.https-url + - section: bindings + entity: + id: binding.openapi.estate-security-api.1 + kind: binding + contract: contract.openapi.estate-security-api + provider_port: port.openapi.estate-security-api + endpoints: + - endpoint.openapi.estate-security-api.1 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.openapi.estate-security-api.listItems + - operation.openapi.estate-security-api.createItem + - operation.openapi.estate-security-api.optionalInfo + - operation.openapi.estate-security-api.publicInfo + - section: information_resources + entity: + id: resource.openapi.estate-security-api.items + kind: information-resource + owner: node.openapi.estate-security-api + name: /items + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /items + - section: information_resources + entity: + id: resource.openapi.estate-security-api.optional + kind: information-resource + owner: node.openapi.estate-security-api + name: /optional + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /optional + - section: information_resources + entity: + id: resource.openapi.estate-security-api.public + kind: information-resource + owner: node.openapi.estate-security-api + name: /public + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /public + - section: information_shapes + entity: + id: shape.openapi.estate-security-api.Item + kind: information-shape + name: Item + shape_kind: fiam.information-shape.object + facets: + openapi_component: Item + - section: information_shapes + entity: + id: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + kind: information-shape + name: listItems response + shape_kind: fiam.information-shape.collection + facets: + openapi_pointer: '#/paths/~1items/get/responses/200/content/application~1json/schema' + - section: artifacts + entity: + id: artifact.openapi.estate-security-api + kind: artifact + name: security-api.yaml + artifact_type: fiam.artifact.api-description + describes: + - contract.openapi.estate-security-api + - shape.openapi.estate-security-api.Item + - shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + - security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + - security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + - security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + locator: real-world/openapi/estate-hardening/security-api.yaml + facets: + openapi_version: 3.2.0 + document_version: 1.0.0 + source_file: security-api.yaml + - section: security + entity: + id: security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + applies_to: contract.openapi.estate-security-api + authentication: fiam.security.authentication.openid-connect + facets: + openapi_security_scheme: oidc + openapi_security_type: openIdConnect + requirement_alternative: 1 + requirement_operator: and-within-alternative + required_scopes: + - items.read + openapi_openIdConnectUrl: https://id.example.test/.well-known/openid-configuration + credential_artifacts: + - fiam.credential.id-token + - fiam.credential.access-token + - section: security + entity: + id: security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + applies_to: operation.openapi.estate-security-api.createItem + authentication: fiam.security.authentication.api-key + facets: + openapi_security_scheme: apiKey + openapi_security_type: apiKey + requirement_alternative: 1 + requirement_operator: and-within-alternative + required_scopes: [] + openapi_name: X-API-Key + openapi_in: header + credential_artifacts: + - fiam.credential.api-key + - section: security + entity: + id: security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + applies_to: operation.openapi.estate-security-api.optionalInfo + authentication: fiam.security.authentication.openid-connect + facets: + openapi_security_scheme: oidc + openapi_security_type: openIdConnect + requirement_alternative: 2 + requirement_operator: and-within-alternative + required_scopes: [] + openapi_openIdConnectUrl: https://id.example.test/.well-known/openid-configuration + credential_artifacts: + - fiam.credential.id-token + - fiam.credential.access-token + assertions: + - id: assertion.openapi.0001 + assertion_kind: property + subject: contract.openapi.estate-security-api + predicate: fiam.property.security-override + polarity: asserted + value: declared + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0002 + assertion_kind: property + subject: security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + predicate: fiam.property.security-override + polarity: asserted + value: required + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/security/0/oidc' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + applies_to: contract.openapi.estate-security-api + - id: assertion.openapi.0003 + assertion_kind: property + subject: binding.openapi.estate-security-api.1 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/servers/0' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0004 + assertion_kind: property + subject: endpoint.openapi.estate-security-api.1 + predicate: fiam.property.server-address + polarity: asserted + value: security.example.test + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/servers/0/url' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0005 + assertion_kind: property + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0006 + assertion_kind: property + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.property.http-route + polarity: asserted + value: /items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0007 + assertion_kind: relation + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0008 + assertion_kind: relation + subject: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.Item + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get/responses/200/content/application~1json/schema/items' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + slot: items + role: fiam.shape-role.element + - id: assertion.openapi.0009 + assertion_kind: relation + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get/responses/200/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + role: fiam.shape-role.response + - id: assertion.openapi.0010 + assertion_kind: relation + subject: binding.openapi.estate-security-api.1 + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get/responses/200/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + operation_ref: operation.openapi.estate-security-api.listItems + role: fiam.shape-role.response + representation: fiam.representation.json + - id: assertion.openapi.0011 + assertion_kind: property + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.property.security-override + polarity: asserted + value: operation + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0012 + assertion_kind: property + subject: security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + predicate: fiam.property.security-override + polarity: asserted + value: required + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/security/0/apiKey' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + applies_to: operation.openapi.estate-security-api.createItem + - id: assertion.openapi.0013 + assertion_kind: property + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.property.http-method + polarity: asserted + value: POST + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0014 + assertion_kind: property + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.property.http-route + polarity: asserted + value: /items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0015 + assertion_kind: relation + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0016 + assertion_kind: relation + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.Item + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/requestBody/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + role: fiam.shape-role.request + - id: assertion.openapi.0017 + assertion_kind: relation + subject: binding.openapi.estate-security-api.1 + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.Item + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/requestBody/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + operation_ref: operation.openapi.estate-security-api.createItem + role: fiam.shape-role.request + representation: fiam.representation.json + - id: assertion.openapi.0018 + assertion_kind: property + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.property.security-override + polarity: asserted + value: anonymous-alternative + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0019 + assertion_kind: property + subject: security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + predicate: fiam.property.security-override + polarity: asserted + value: required + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get/security/1/oidc' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + applies_to: operation.openapi.estate-security-api.optionalInfo + - id: assertion.openapi.0020 + assertion_kind: property + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0021 + assertion_kind: property + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.property.http-route + polarity: asserted + value: /optional + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0022 + assertion_kind: relation + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.optional + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0023 + assertion_kind: property + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.property.security-override + polarity: asserted + value: none + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0024 + assertion_kind: property + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0025 + assertion_kind: property + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.property.http-route + polarity: asserted + value: /public + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0026 + assertion_kind: relation + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.public + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + zone_memberships: [] + runtime_aggregates: [] + topology_observations: [] + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: + - operation.openapi.estate-security-api.createItem + - operation.openapi.estate-security-api.listItems + - operation.openapi.estate-security-api.optionalInfo + - operation.openapi.estate-security-api.publicInfo diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/security-old-coverage.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/security-old-coverage.yaml new file mode 100644 index 0000000..6a93e61 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/security-old-coverage.yaml @@ -0,0 +1,42 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.security.old-coverage +created_at: '2026-09-09T00:00:00Z' +source: + source_id: collector.security.history + source_kind: runtime-aggregate + source_ref: fixture://security-history + content_hash: null +observation: + mode: incremental + observation_scope: security-prod-history + population_id: security-prod + population: + environment: prod + domains: + - http + snapshot_time: '2026-09-09T00:00:00Z' + aggregate_semantics: cumulative +records: + entities: [] + assertions: [] + zone_memberships: [] + runtime_aggregates: + - id: aggregate.createItem.old + domain: http + role: server + operation: operation.openapi.estate-security-api.createItem + binding: null + local_node: node.openapi.estate-security-api + remote_node: null + channel: null + resource: null + count: 100 + error_count: 0 + first_seen: '2026-01-01T00:00:00Z' + last_seen: '2026-05-01T00:00:00Z' + sample_spans: [] + topology_observations: [] + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/security-runtime.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/security-runtime.yaml new file mode 100644 index 0000000..6f83efa --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/security-runtime.yaml @@ -0,0 +1,1414 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.52b66e85d053921358b19db3 +created_at: '2026-09-09T00:00:00Z' +source: + source_id: collector.security.app + source_kind: otlp-adapter + source_ref: estate://collector/security + content_hash: 6c44f07538fa8cd3640e263f76369cf1b0f82423ab0c5ad155aa4411d50a1bc0 +observation: + mode: incremental + snapshot_time: '2026-09-09T00:00:00Z' + observation_scope: security-prod-app + population_id: security-prod + population: + environment: prod + domains: + - http + aggregate_semantics: cumulative +records: + entities: + - section: nodes + entity: + id: node.openapi.estate-security-api + kind: system-node + name: Estate Security API + node_type: fiam.node-type.service + - section: nodes + entity: + id: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + kind: system-node + name: Estate Security API + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: petstore3.swagger.io + service_name: Estate Security API + - section: ports + entity: + id: port.openapi.estate-security-api + owner: node.openapi.estate-security-api + participations: + - contract: contract.openapi.estate-security-api + mode: offers + - section: ports + entity: + id: port.otel.http.Estate-Security-API.530db556431d + kind: port + owner: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + participations: + - contract: contract.otel.http.Estate-Security-API.1dd49a95178d + mode: offers + roles: + - fiam.role.server + - section: contracts + entity: + id: contract.openapi.estate-security-api + kind: interface-contract + name: Estate Security API + contract_forms: + - fiam.contract-form.openapi + operations: + - id: operation.openapi.estate-security-api.createItem + kind: operation + name: createItem + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.write + purpose: + - fiam.purpose.mutation + x-http-method: POST + x-openapi-path: /items + x-openapi-operation-id: createItem + - id: operation.openapi.estate-security-api.listItems + kind: operation + name: listItems + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /items + x-openapi-operation-id: listItems + - id: operation.openapi.estate-security-api.optionalInfo + kind: operation + name: optionalInfo + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /optional + x-openapi-operation-id: optionalInfo + - id: operation.openapi.estate-security-api.publicInfo + kind: operation + name: publicInfo + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /public + x-openapi-operation-id: publicInfo + - section: contracts + entity: + id: contract.otel.http.Estate-Security-API.1dd49a95178d + kind: interface-contract + name: "Observed HTTP surface \u2014 Estate Security API" + operations: + - id: operation.otel.http.GET--items.d210cde96bfe + kind: operation + name: GET /items + interaction_style: fiam.interaction-style.request-response + x-http-method: GET + x-http-route: /items + - section: endpoints + entity: + id: endpoint.openapi.estate-security-api.1 + kind: endpoint + name: OpenAPI server 1 + address: https://security.example.test + address_scheme: fiam.address-scheme.https-url + - section: endpoints + entity: + id: endpoint.otel.http.security.example.test.b578c891ea81 + kind: endpoint + name: security.example.test + address_scheme: fiam.address-scheme.https-url + facets: + identity_tuple: + address: https://security.example.test + address_scheme: fiam.address-scheme.https-url + zone: + - '' + - '' + - '' + - '' + - '' + logical_server_address: security.example.test + address: https://security.example.test + - section: bindings + entity: + id: binding.openapi.estate-security-api.1 + kind: binding + contract: contract.openapi.estate-security-api + provider_port: port.openapi.estate-security-api + endpoints: + - endpoint.openapi.estate-security-api.1 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.openapi.estate-security-api.listItems + - operation.openapi.estate-security-api.createItem + - operation.openapi.estate-security-api.optionalInfo + - operation.openapi.estate-security-api.publicInfo + - section: bindings + entity: + id: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + kind: binding + contract: contract.otel.http.Estate-Security-API.1dd49a95178d + provider_port: port.otel.http.Estate-Security-API.530db556431d + endpoints: + - endpoint.otel.http.security.example.test.b578c891ea81 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http2 + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.otel.http.GET--items.d210cde96bfe + facets: + identity_tuple: + kind: http-binding + service_node: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + server_address: security.example.test + server_port: 443 + zone: + - '' + - '' + - '' + - '' + - '' + - section: information_resources + entity: + id: resource.openapi.estate-security-api.items + kind: information-resource + owner: node.openapi.estate-security-api + name: /items + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /items + - section: information_resources + entity: + id: resource.openapi.estate-security-api.optional + kind: information-resource + owner: node.openapi.estate-security-api + name: /optional + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /optional + - section: information_resources + entity: + id: resource.openapi.estate-security-api.public + kind: information-resource + owner: node.openapi.estate-security-api + name: /public + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /public + - section: information_shapes + entity: + id: shape.openapi.estate-security-api.Item + kind: information-shape + name: Item + shape_kind: fiam.information-shape.object + facets: + openapi_component: Item + - section: information_shapes + entity: + id: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + kind: information-shape + name: listItems response + shape_kind: fiam.information-shape.collection + facets: + openapi_pointer: '#/paths/~1items/get/responses/200/content/application~1json/schema' + - section: interactions + entity: + id: interaction.sample.58316c4b6aac715d6c057fb5.1122334455667788 + kind: interaction + operation: operation.otel.http.GET--items.d210cde96bfe + contract: contract.otel.http.Estate-Security-API.1dd49a95178d + binding: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + interaction_style: fiam.interaction-style.request-response + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + responder: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + facets: + otel_trace_id: aabbccddeeff00112233445566778899 + otel_span_id: '1122334455667788' + otel_span_kind: server + instrumentation_scope: example.http.instrumentation + observed_service: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + - section: artifacts + entity: + id: artifact.openapi.estate-security-api + kind: artifact + name: security-api.yaml + artifact_type: fiam.artifact.api-description + describes: + - contract.openapi.estate-security-api + - shape.openapi.estate-security-api.Item + - shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + - security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + - security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + - security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + locator: real-world/openapi/estate-hardening/security-api.yaml + facets: + openapi_version: 3.2.0 + document_version: 1.0.0 + source_file: security-api.yaml + - section: artifacts + entity: + id: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + kind: artifact + name: OTLP runtime stream + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/estate-hardening/security-api-list-items.otlp.json + facets: + format: OTLP/JSON + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + latest_batch_hash: 43fefde097aeb470bb1b3865b5bc067640484182dacd2f99157cd2126c9295ef + describes: + - interaction.sample.58316c4b6aac715d6c057fb5.1122334455667788 + - section: zones + entity: + id: zone.otel.unscoped + kind: zone + name: Unscoped runtime observations + zone_type: fiam.zone-type.unscoped + members: + - node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + - section: security + entity: + id: security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + applies_to: contract.openapi.estate-security-api + authentication: fiam.security.authentication.openid-connect + facets: + openapi_security_scheme: oidc + openapi_security_type: openIdConnect + requirement_alternative: 1 + requirement_operator: and-within-alternative + required_scopes: + - items.read + openapi_openIdConnectUrl: https://id.example.test/.well-known/openid-configuration + credential_artifacts: + - fiam.credential.id-token + - fiam.credential.access-token + - section: security + entity: + id: security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + applies_to: operation.openapi.estate-security-api.createItem + authentication: fiam.security.authentication.api-key + facets: + openapi_security_scheme: apiKey + openapi_security_type: apiKey + requirement_alternative: 1 + requirement_operator: and-within-alternative + required_scopes: [] + openapi_name: X-API-Key + openapi_in: header + credential_artifacts: + - fiam.credential.api-key + - section: security + entity: + id: security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + applies_to: operation.openapi.estate-security-api.optionalInfo + authentication: fiam.security.authentication.openid-connect + facets: + openapi_security_scheme: oidc + openapi_security_type: openIdConnect + requirement_alternative: 2 + requirement_operator: and-within-alternative + required_scopes: [] + openapi_openIdConnectUrl: https://id.example.test/.well-known/openid-configuration + credential_artifacts: + - fiam.credential.id-token + - fiam.credential.access-token + assertions: + - id: assertion.openapi.0001 + assertion_kind: property + subject: contract.openapi.estate-security-api + predicate: fiam.property.security-override + polarity: asserted + value: declared + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0002 + assertion_kind: property + subject: security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + predicate: fiam.property.security-override + polarity: asserted + value: required + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/security/0/oidc' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + applies_to: contract.openapi.estate-security-api + - id: assertion.openapi.0003 + assertion_kind: property + subject: binding.openapi.estate-security-api.1 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/servers/0' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0004 + assertion_kind: property + subject: endpoint.openapi.estate-security-api.1 + predicate: fiam.property.server-address + polarity: asserted + value: security.example.test + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/servers/0/url' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0005 + assertion_kind: property + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0006 + assertion_kind: property + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.property.http-route + polarity: asserted + value: /items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0007 + assertion_kind: relation + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0008 + assertion_kind: relation + subject: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.Item + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get/responses/200/content/application~1json/schema/items' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + slot: items + role: fiam.shape-role.element + - id: assertion.openapi.0009 + assertion_kind: relation + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get/responses/200/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + role: fiam.shape-role.response + - id: assertion.openapi.0010 + assertion_kind: relation + subject: binding.openapi.estate-security-api.1 + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get/responses/200/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + operation_ref: operation.openapi.estate-security-api.listItems + role: fiam.shape-role.response + representation: fiam.representation.json + - id: assertion.openapi.0011 + assertion_kind: property + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.property.security-override + polarity: asserted + value: operation + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0012 + assertion_kind: property + subject: security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + predicate: fiam.property.security-override + polarity: asserted + value: required + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/security/0/apiKey' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + applies_to: operation.openapi.estate-security-api.createItem + - id: assertion.openapi.0013 + assertion_kind: property + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.property.http-method + polarity: asserted + value: POST + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0014 + assertion_kind: property + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.property.http-route + polarity: asserted + value: /items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0015 + assertion_kind: relation + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0016 + assertion_kind: relation + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.Item + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/requestBody/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + role: fiam.shape-role.request + - id: assertion.openapi.0017 + assertion_kind: relation + subject: binding.openapi.estate-security-api.1 + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.Item + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/requestBody/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + operation_ref: operation.openapi.estate-security-api.createItem + role: fiam.shape-role.request + representation: fiam.representation.json + - id: assertion.openapi.0018 + assertion_kind: property + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.property.security-override + polarity: asserted + value: anonymous-alternative + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0019 + assertion_kind: property + subject: security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + predicate: fiam.property.security-override + polarity: asserted + value: required + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get/security/1/oidc' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + applies_to: operation.openapi.estate-security-api.optionalInfo + - id: assertion.openapi.0020 + assertion_kind: property + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0021 + assertion_kind: property + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.property.http-route + polarity: asserted + value: /optional + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0022 + assertion_kind: relation + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.optional + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0023 + assertion_kind: property + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.property.security-override + polarity: asserted + value: none + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0024 + assertion_kind: property + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0025 + assertion_kind: property + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.property.http-route + polarity: asserted + value: /public + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.openapi.0026 + assertion_kind: relation + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.public + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + - id: assertion.otel.0c013b9bfca2e06ee4d9 + assertion_kind: property + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T01:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: aggregate:58316c4b6aac715d6c057fb5 + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:58316c4b6aac715d6c057fb5 + aggregation_key: 58316c4b6aac715d6c057fb5 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: &id001 + aggregation_key: 58316c4b6aac715d6c057fb5 + domain: http + role: server + operation_ref: operation.otel.http.GET--items.d210cde96bfe + local_node_ref: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.1e0a4e5e28d5cf3becdb + assertion_kind: relation + subject: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: node.openapi.estate-security-api + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:http + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:http + signals: &id002 + - http-method + - http-route-exact + - server-address + score: 1.0 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.94 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.25864fd816ddf62afacd + assertion_kind: property + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: aggregate:58316c4b6aac715d6c057fb5 + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:58316c4b6aac715d6c057fb5 + aggregation_key: 58316c4b6aac715d6c057fb5 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.303cc12daf188231639d + assertion_kind: property + subject: endpoint.otel.http.security.example.test.b578c891ea81 + predicate: fiam.property.server-address + polarity: asserted + value: security.example.test + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:server.address + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:server.address + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.35589efcc9bddeb5cbce + assertion_kind: property + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http2 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:network.protocol.version + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:network.protocol.version + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.40191da00a8093cd6a8d + assertion_kind: property + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: aggregate:58316c4b6aac715d6c057fb5 + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:58316c4b6aac715d6c057fb5 + aggregation_key: 58316c4b6aac715d6c057fb5 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.477a30d93b905248cbd6 + assertion_kind: property + subject: interaction.sample.58316c4b6aac715d6c057fb5.1122334455667788 + predicate: fiam.property.http-response-status-code + polarity: asserted + value: 200 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:http.response.status_code + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.response.status_code + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.499e3268cadc16df61b8 + assertion_kind: relation + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: binding.openapi.estate-security-api.1 + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:http + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:http + signals: *id002 + score: 1.0 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.96 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.4e624f09924fd090d149 + assertion_kind: property + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T01:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: aggregate:58316c4b6aac715d6c057fb5 + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:58316c4b6aac715d6c057fb5 + aggregation_key: 58316c4b6aac715d6c057fb5 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.6b9158ee7e12db7c08bb + assertion_kind: property + subject: operation.otel.http.GET--items.d210cde96bfe + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:http.request.method + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.request.method + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.7eae4a2ccaf380107bac + assertion_kind: property + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: aggregate:58316c4b6aac715d6c057fb5 + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:58316c4b6aac715d6c057fb5 + aggregation_key: 58316c4b6aac715d6c057fb5 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.8b8036aa238aa607dc96 + assertion_kind: relation + subject: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: node.openapi.estate-security-api + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:service-identity + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:service-identity + signals: &id003 + - service-name + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.92 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.c9329ce50d77ad4498b2 + assertion_kind: relation + subject: operation.otel.http.GET--items.d210cde96bfe + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: operation.openapi.estate-security-api.listItems + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:http + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:http + signals: *id002 + score: 1.0 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.97 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.d54cc10e94399ee53344 + assertion_kind: property + subject: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + predicate: fiam.property.service-namespace + polarity: asserted + value: petstore3.swagger.io + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:service.namespace + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.namespace + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.de7c69afccbdf234bccd + assertion_kind: relation + subject: endpoint.otel.http.security.example.test.b578c891ea81 + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: endpoint.openapi.estate-security-api.1 + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:http + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:http + signals: *id002 + score: 1.0 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.95 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.e8528004dca55453b943 + assertion_kind: property + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.property.network-protocol-version + polarity: asserted + value: '2' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:network.protocol.version + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:network.protocol.version + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.eb376a12ea09822f6d92 + assertion_kind: property + subject: endpoint.otel.http.security.example.test.b578c891ea81 + predicate: fiam.property.server-port + polarity: asserted + value: 443 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:server.port + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:server.port + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.f2f7c94c1a8a662b226e + assertion_kind: property + subject: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + predicate: fiam.property.service-name + polarity: asserted + value: Estate Security API + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:service.name + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + - id: assertion.otel.f5a4d4e2dcf69ced2545 + assertion_kind: property + subject: operation.otel.http.GET--items.d210cde96bfe + predicate: fiam.property.http-route + polarity: asserted + value: /items + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:http.route + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.route + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' + zone_memberships: + - zone_id: zone.otel.unscoped + member_id: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + zone_type: fiam.zone-type.unscoped + derived: false + runtime_aggregates: + - id: aggregate.otel.58316c4b6aac715d6c057fb5 + domain: http + role: server + operation: operation.otel.http.GET--items.d210cde96bfe + binding: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + local_node: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + remote_node: null + channel: null + resource: null + method: GET + route: /items + count: 1 + error_count: 0 + first_seen: '2026-09-09T01:00:00Z' + last_seen: '2026-09-09T01:00:00Z' + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + topology_observations: [] + unresolved: [] + reconciliation_candidates: + - observed_ref: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + entity_kind: system-node + status: matched + candidates: + - declared_ref: node.openapi.estate-security-api + score: 0.7 + signals: *id003 + - observed_ref: operation.otel.http.GET--items.d210cde96bfe + entity_kind: operation + status: matched + candidates: + - declared_ref: operation.openapi.estate-security-api.listItems + binding_ref: binding.openapi.estate-security-api.1 + endpoint_ref: endpoint.openapi.estate-security-api.1 + node_ref: node.openapi.estate-security-api + score: 1.0 + signals: *id002 + - declared_ref: operation.openapi.estate-security-api.createItem + binding_ref: binding.openapi.estate-security-api.1 + endpoint_ref: endpoint.openapi.estate-security-api.1 + node_ref: node.openapi.estate-security-api + score: 0.7 + signals: + - http-route-exact + - server-address + - declared_ref: operation.openapi.estate-security-api.optionalInfo + binding_ref: binding.openapi.estate-security-api.1 + endpoint_ref: endpoint.openapi.estate-security-api.1 + node_ref: node.openapi.estate-security-api + score: 0.5 + signals: + - http-method + - server-address + - declared_ref: operation.openapi.estate-security-api.publicInfo + binding_ref: binding.openapi.estate-security-api.1 + endpoint_ref: endpoint.openapi.estate-security-api.1 + node_ref: node.openapi.estate-security-api + score: 0.5 + signals: + - http-method + - server-address + declared_entity_ids: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/zone-derivation-input.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/zone-derivation-input.yaml new file mode 100644 index 0000000..e114bc9 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/zone-derivation-input.yaml @@ -0,0 +1,16 @@ +fiam_version: '0.2' +instance: + id: fixture.zone-derivation + kind: runtime-model +nodes: + - id: node.zone-derived + kind: system-node + name: zone-derived + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_name: zone-derived + environment: prod + cluster_name: cluster-a + k8s_namespace: payments diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/zone-derivation.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/zone-derivation.yaml new file mode 100644 index 0000000..adff2f6 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-exchange/zone-derivation.yaml @@ -0,0 +1,52 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.2ad173cc7bb31561462f1fc6 +created_at: '2026-09-09T00:00:00Z' +source: + source_id: fixture.zone + source_kind: fiam-model + source_ref: real-world/catalog-exchange/zone-derivation-input.yaml + content_hash: 77eca2bbd97770a25cc51258270fffc6c60bda2ddd4a255b497a20a061aebaca +observation: + mode: incremental + snapshot_time: '2026-09-09T00:00:00Z' + observation_scope: zone-fixture + population_id: zone-pop + population: {} + domains: + - http + aggregate_semantics: cumulative +records: + entities: + - section: nodes + entity: + id: node.zone-derived + kind: system-node + name: zone-derived + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_name: zone-derived + environment: prod + cluster_name: cluster-a + k8s_namespace: payments + assertions: [] + zone_memberships: + - zone_id: zone.derived.cluster.e2b03c9fd730 + member_id: node.zone-derived + zone_type: fiam.zone-type.cluster + derived: true + - zone_id: zone.derived.environment.efc534777568 + member_id: node.zone-derived + zone_type: fiam.zone-type.deployment-environment + derived: true + - zone_id: zone.derived.k8s-namespace.3ee07e089e28 + member_id: node.zone-derived + zone_type: fiam.zone-type.kubernetes-namespace + derived: true + runtime_aggregates: [] + topology_observations: [] + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-operations/RESULT-SUMMARY.json b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/RESULT-SUMMARY.json new file mode 100644 index 0000000..848bee5 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/RESULT-SUMMARY.json @@ -0,0 +1,32 @@ +{ + "architecture-changes.yaml": { + "appeared": 1, + "disappeared": 1, + "newly_undeclared": 1 + }, + "architecture-policy.yaml": { + "material_dependencies": 1, + "new_dependencies": 1, + "policy_violations": 1 + }, + "boundary-drift.yaml": { + "new_cross_zone": 1, + "new_organization_boundary": 1, + "new_trust_boundary": 1 + }, + "evidence-health.yaml": { + "challenged": 1, + "conflicts": 1, + "low_support": 1, + "stale_runtime_only": 1 + }, + "operation-coverage.yaml": { + "dormant": 1, + "never-observed": 2, + "observed-in-window": 1 + }, + "security-evidence-coverage.yaml": { + "declared_profile_operation_pairs": 6, + "observed_operations_with_security_unknown": 1 + } +} diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-operations/architecture-changes.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/architecture-changes.yaml new file mode 100644 index 0000000..8ebe4fa --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/architecture-changes.yaml @@ -0,0 +1,65 @@ +lens_id: fiam.lens.architecture-changes +window: + since: '2026-09-07T00:00:00Z' + until: '2026-09-09T23:59:59Z' + population_id: prod-cluster-a +summary: + appeared: 1 + disappeared: 1 + newly_undeclared: 1 +appeared: +- edge_key: edge.210c03e257e70068c68df0c0 + domain: rpc + kind: direct-call + from: node.orders + target: node.partner + target_kind: node + channel: null + first_seen: '2026-09-08T00:00:00Z' + last_seen: '2026-09-08T00:00:00Z' + valid_from: '2026-09-08T00:00:00Z' + closed_at: null + observation_count: 12 + declared: false + declaration_matches: &id001 [] + declaration_reason: no-matching-declaration + close_reason: null +disappeared: +- edge_key: edge.be323ef1b2f1274e52be419c + domain: rpc + kind: direct-call + from: node.orders + target: node.inventory + target_kind: node + channel: null + first_seen: '2026-08-25T00:00:00Z' + last_seen: '2026-09-01T00:00:00Z' + valid_from: '2026-08-25T00:00:00Z' + closed_at: '2026-09-09T00:00:00Z' + observation_count: 100 + declared: true + declaration_matches: + - declaration_id: assertion.declared.orders-uses-inventory + predicate: fiam.relation.uses + matched_via: target + matched_ref: node.inventory + source_id: architecture.git + declaration_reason: matched + close_reason: all-observation-scopes-closed +newly_undeclared: +- edge_key: edge.210c03e257e70068c68df0c0 + domain: rpc + kind: direct-call + from: node.orders + target: node.partner + target_kind: node + channel: null + first_seen: '2026-09-08T00:00:00Z' + last_seen: '2026-09-08T00:00:00Z' + valid_from: '2026-09-08T00:00:00Z' + closed_at: null + observation_count: 12 + declared: false + declaration_matches: *id001 + declaration_reason: no-matching-declaration + close_reason: null diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-operations/architecture-policy.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/architecture-policy.yaml new file mode 100644 index 0000000..02f61a7 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/architecture-policy.yaml @@ -0,0 +1,56 @@ +lens_id: fiam.lens.architecture-policy +policy: + id: fiam.policy.architecture-governance.v0.2 + sha256: f9fac195fba210643a84f15771632b146ead9f877b45b7e96d39e18a31e4fbdd +window: + since: '2026-09-07T00:00:00Z' + until: '2026-09-09T23:59:59Z' + population_id: prod-cluster-a +summary: + new_dependencies: 1 + material_dependencies: 1 + policy_violations: 1 +dependencies: +- &id001 + edge_key: edge.210c03e257e70068c68df0c0 + from: node.orders + target: node.partner + domain: rpc + first_seen: '2026-09-08T00:00:00Z' + declared: false + observation_count: 12 + corroborating_scopes: + - prod-cluster-a-app-traces + materiality_score: 0.75 + materiality: high + components: + undeclared: true + trust_boundary: true + organization_boundary: true + high_volume: false + strong_evidence: false + zone_context: + from: + fiam.zone-type.deployment-environment: + - zone.environment.prod + fiam.zone-type.organization: + - zone.org.internal + fiam.zone-type.trust-zone: + - zone.trust.internal + target: + fiam.zone-type.deployment-environment: + - zone.environment.prod + fiam.zone-type.organization: + - zone.org.partner + fiam.zone-type.trust-zone: + - zone.trust.partner +material_dependencies: +- *id001 +policy_violations: +- edge_key: edge.210c03e257e70068c68df0c0 + rule_id: require-declaration-internal-to-partner + severity: high + condition: require-declared + from_zone: zone.trust.internal + to_zone: zone.trust.partner + declared: false diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-operations/boundary-drift.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/boundary-drift.yaml new file mode 100644 index 0000000..3f8708a --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/boundary-drift.yaml @@ -0,0 +1,28 @@ +lens_id: fiam.lens.boundary-drift +window: + since: '2026-09-07T00:00:00Z' + until: '2026-09-09T23:59:59Z' + population_id: prod-cluster-a +summary: + new_cross_zone: 1 + new_trust_boundary: 1 + new_organization_boundary: 1 +crossings: +- edge_key: edge.210c03e257e70068c68df0c0 + kind: direct-call + from: node.orders + target: node.partner + first_seen: '2026-09-08T00:00:00Z' + zone_crossings: + - zone_type: fiam.zone-type.trust-zone + from_zones: + - zone.trust.internal + target_zones: + - zone.trust.partner + - zone_type: fiam.zone-type.organization + from_zones: + - zone.org.internal + target_zones: + - zone.org.partner + trust_boundary: true + organization_boundary: true diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-operations/catalog-export-app-traces.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/catalog-export-app-traces.yaml new file mode 100644 index 0000000..87fd988 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/catalog-export-app-traces.yaml @@ -0,0 +1,186 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.index-export.be86ca76e8a06411b98de3b5 +created_at: '2026-09-09T00:00:00Z' +source: + source_id: fiam.index-export + source_kind: index-checkpoint + source_ref: /tmp/tmp.uHHDdXSsJj/estate.sqlite + content_hash: null +observation: + mode: incremental + observation_scope: prod-cluster-a-app-traces + population_id: prod-cluster-a + population: {} + domains: + - rpc + snapshot_time: '2026-09-09T00:00:00Z' + aggregate_semantics: cumulative +records: + entities: + - section: indexed + entity: + contract: contract.inventory + id: binding.inventory + kind: binding + operations: + - operation.inventory.get + provider_port: port.inventory.api + - section: indexed + entity: + id: contract.inventory + kind: interface-contract + name: Inventory API + operations: + - id: operation.inventory.get + interaction_style: fiam.interaction-style.request-response + kind: operation + name: getInventory + purpose: + - fiam.purpose.query + - section: indexed + entity: + id: node.inventory + kind: system-node + name: Inventory + node_type: fiam.node-type.service + - section: indexed + entity: + id: node.orders + kind: system-node + name: Orders + node_type: fiam.node-type.service + - section: indexed + entity: + id: node.partner + kind: system-node + name: Partner API + node_type: fiam.node-type.application + - section: indexed + entity: + id: operation.inventory.get + interaction_style: fiam.interaction-style.request-response + kind: operation + name: getInventory + - section: indexed + entity: + id: port.inventory.api + kind: port + owner: node.inventory + participations: + - contract: contract.inventory + mode: offers + roles: + - fiam.role.server + - section: indexed + entity: + id: zone.environment.prod + kind: zone + members: + - node.orders + - node.inventory + - node.partner + name: production + zone_type: fiam.zone-type.deployment-environment + - section: indexed + entity: + id: zone.org.internal + kind: zone + members: + - node.orders + - node.inventory + name: internal organization + zone_type: fiam.zone-type.organization + - section: indexed + entity: + id: zone.org.partner + kind: zone + members: + - node.partner + name: partner organization + zone_type: fiam.zone-type.organization + - section: indexed + entity: + id: zone.trust.internal + kind: zone + members: + - node.orders + - node.inventory + name: internal trust domain + zone_type: fiam.zone-type.trust-zone + - section: indexed + entity: + id: zone.trust.partner + kind: zone + members: + - node.partner + name: partner trust domain + zone_type: fiam.zone-type.trust-zone + assertions: + - assertion_kind: relation + evidence: + confidence: 1.0 + mode: fiam.evidence.declared + observed_at: '2026-09-01T00:00:00Z' + observer: fixture.owner + source: + locator: dependency/orders-inventory + ref: fixture://estate-history/declared + type: architecture-declaration + stance: supports + id: assertion.declared.orders-uses-inventory + object_ref: binding.inventory + polarity: asserted + predicate: fiam.relation.uses + subject: node.orders + zone_memberships: + - zone_id: zone.environment.prod + member_id: node.inventory + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.environment.prod + member_id: node.orders + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.environment.prod + member_id: node.partner + zone_type: fiam.zone-type.deployment-environment + derived: false + - zone_id: zone.org.internal + member_id: node.inventory + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.org.internal + member_id: node.orders + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.org.partner + member_id: node.partner + zone_type: fiam.zone-type.organization + derived: false + - zone_id: zone.trust.internal + member_id: node.inventory + zone_type: fiam.zone-type.trust-zone + derived: false + - zone_id: zone.trust.internal + member_id: node.orders + zone_type: fiam.zone-type.trust-zone + derived: false + - zone_id: zone.trust.partner + member_id: node.partner + zone_type: fiam.zone-type.trust-zone + derived: false + runtime_aggregates: [] + topology_observations: + - correlation: fixture + count: 12 + domain: rpc + first_seen: '2026-09-08T00:00:00Z' + from: node.orders + id: topology.orders-partner + kind: direct-call + last_seen: '2026-09-08T00:00:00Z' + to: node.partner + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-operations/evidence-health.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/evidence-health.yaml new file mode 100644 index 0000000..ee3b4bf --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/evidence-health.yaml @@ -0,0 +1,38 @@ +lens_id: fiam.lens.evidence-health +evaluated_at: '2026-09-09T00:00:00Z' +policy: + id: fiam.policy.evidence-scoring.default + sha256: 595a0afe8aabe3a65358a672031ff60a58c575322662a4c0b8608e1717e454cc +summary: + conflicts: 1 + challenged: 1 + stale_runtime_only: 1 + low_support: 1 +conflicts: +- subject: node.evidence.api + predicate: fiam.property.network-protocol-version + alternatives: + - value: '"1.1"' + assertion_id: assertion.protocol.http11 + support_score: 0.95 + - value: '"2"' + assertion_id: assertion.protocol.http2 + support_score: 0.40798 +challenged: +- assertion_id: assertion.service-name + subject: node.evidence.api + predicate: fiam.property.service-name + support_score: 0.95 + challenge_score: 0.688543 + net_support: 0.261457 +stale_runtime_only: +- assertion_id: assertion.stale-peer + subject: node.evidence.api + predicate: fiam.property.service-peer-name + latest_runtime_evidence: '2026-06-01T00:00:00Z' + support_score: 0.214344 +low_support: +- assertion_id: assertion.stale-peer + subject: node.evidence.api + predicate: fiam.property.service-peer-name + support_score: 0.214344 diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-operations/operation-coverage.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/operation-coverage.yaml new file mode 100644 index 0000000..6008bfd --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/operation-coverage.yaml @@ -0,0 +1,29 @@ +lens_id: fiam.lens.operation-coverage +population_id: security-prod +window: + since: '2026-06-11T23:59:59Z' + until: '2026-09-09T23:59:59Z' + days: 90 +summary: + dormant: 1 + never-observed: 2 + observed-in-window: 1 +operations: +- operation_ref: operation.openapi.estate-security-api.createItem + name: createItem + classification: dormant + last_seen: '2026-05-01T00:00:00Z' + count: 100 + error_count: 0 +- operation_ref: operation.openapi.estate-security-api.listItems + name: listItems + classification: observed-in-window + last_seen: '2026-09-09T01:00:00Z' + count: 1 + error_count: 0 +- operation_ref: operation.openapi.estate-security-api.optionalInfo + name: optionalInfo + classification: never-observed +- operation_ref: operation.openapi.estate-security-api.publicInfo + name: publicInfo + classification: never-observed diff --git a/history/FIAM_v0.2_Draft6/real-world/catalog-operations/security-evidence-coverage.yaml b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/security-evidence-coverage.yaml new file mode 100644 index 0000000..637dc98 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/catalog-operations/security-evidence-coverage.yaml @@ -0,0 +1,52 @@ +lens_id: fiam.lens.security-evidence-coverage +population_id: security-prod +window: + since: '2026-06-11T00:00:00Z' + until: '2026-09-09T23:59:59Z' +summary: + declared_profile_operation_pairs: 6 + observed_operations_with_security_unknown: 1 +profiles: +- profile_ref: security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + declared_at: contract.openapi.estate-security-api + operation_ref: operation.openapi.estate-security-api.createItem + authentication: fiam.security.authentication.openid-connect + operation_observed_in_window: false + runtime_security_evidence: unknown + interpretation: declared-security-operation-not-observed +- profile_ref: security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + declared_at: contract.openapi.estate-security-api + operation_ref: operation.openapi.estate-security-api.listItems + authentication: fiam.security.authentication.openid-connect + operation_observed_in_window: true + runtime_security_evidence: unknown + interpretation: declared-security-runtime-evidence-unknown +- profile_ref: security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + declared_at: contract.openapi.estate-security-api + operation_ref: operation.openapi.estate-security-api.optionalInfo + authentication: fiam.security.authentication.openid-connect + operation_observed_in_window: false + runtime_security_evidence: unknown + interpretation: declared-security-operation-not-observed +- profile_ref: security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + declared_at: contract.openapi.estate-security-api + operation_ref: operation.openapi.estate-security-api.publicInfo + authentication: fiam.security.authentication.openid-connect + operation_observed_in_window: false + runtime_security_evidence: unknown + interpretation: declared-security-operation-not-observed +- profile_ref: security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + declared_at: operation.openapi.estate-security-api.createItem + operation_ref: operation.openapi.estate-security-api.createItem + authentication: fiam.security.authentication.api-key + operation_observed_in_window: false + runtime_security_evidence: unknown + interpretation: declared-security-operation-not-observed +- profile_ref: security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + declared_at: operation.openapi.estate-security-api.optionalInfo + operation_ref: operation.openapi.estate-security-api.optionalInfo + authentication: fiam.security.authentication.openid-connect + operation_observed_in_window: false + runtime_security_evidence: unknown + interpretation: declared-security-operation-not-observed +note: Generic OTLP does not prove authentication presence or absence. Unknown is preserved. diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/ambiguous-http.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/composite/ambiguous-http.fiam.yaml new file mode 100644 index 0000000..4692519 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/ambiguous-http.fiam.yaml @@ -0,0 +1,597 @@ +fiam_version: '0.2' +instance: + id: model.declared.ambiguous-http.catalog + kind: model + title: Ambiguous HTTP declaration fixture — runtime catalog + status: provisional + intent: Incremental FIAM catalog combining declared architecture with aggregated runtime observations. +nodes: +- id: node.otel.service.gateway-observed.4ea22f0238ef + kind: system-node + name: gateway-observed + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: gateway-observed + environment: production +- id: node.service.alpha + kind: system-node + name: alpha + node_type: fiam.node-type.service +- id: node.service.beta + kind: system-node + name: beta + node_type: fiam.node-type.service +ports: +- id: port.alpha.http + kind: port + owner: node.service.alpha + participations: + - contract: contract.alpha.http + mode: offers +- id: port.beta.http + kind: port + owner: node.service.beta + participations: + - contract: contract.beta.http + mode: offers +- id: port.otel.http.gateway-observed.d93c4771fe17 + kind: port + owner: node.otel.service.gateway-observed.4ea22f0238ef + participations: + - contract: contract.otel.http.gateway-observed.5205bb5e84c0 + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.alpha.http + kind: interface-contract + name: Alpha HTTP + operations: + - id: operation.alpha.get-pet + kind: operation + name: get pet alpha + interaction_style: fiam.interaction-style.request-response +- id: contract.beta.http + kind: interface-contract + name: Beta HTTP + operations: + - id: operation.beta.get-pet + kind: operation + name: get pet beta + interaction_style: fiam.interaction-style.request-response +- id: contract.otel.http.gateway-observed.5205bb5e84c0 + kind: interface-contract + name: Observed HTTP surface — gateway-observed + operations: + - id: operation.otel.http.GET--pets-id.dc9e2765dcf6 + kind: operation + name: GET /pets/{id} + interaction_style: fiam.interaction-style.request-response + x-http-method: GET + x-http-route: /pets/{id} +endpoints: +- id: endpoint.alpha + kind: endpoint + address: https://alpha.example + address_scheme: fiam.address-scheme.https-url +- id: endpoint.beta + kind: endpoint + address: https://beta.example + address_scheme: fiam.address-scheme.https-url +- id: endpoint.otel.http.unlocated.80928725ff75 + kind: endpoint + name: unlocated + address_scheme: fiam.address-scheme.http-url + facets: + identity_tuple: + address: null + address_scheme: fiam.address-scheme.http-url + zone: + - production + - '' + - '' + - '' + - '' + logical_server_address: '' +bindings: +- id: binding.alpha + kind: binding + contract: contract.alpha.http + provider_port: port.alpha.http + operations: + - operation.alpha.get-pet + endpoints: + - endpoint.alpha + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http +- id: binding.beta + kind: binding + contract: contract.beta.http + provider_port: port.beta.http + operations: + - operation.beta.get-pet + endpoints: + - endpoint.beta + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http +- id: binding.otel.http.gateway-observed-unlocated.715c2ecd9a06 + kind: binding + contract: contract.otel.http.gateway-observed.5205bb5e84c0 + provider_port: port.otel.http.gateway-observed.d93c4771fe17 + endpoints: + - endpoint.otel.http.unlocated.80928725ff75 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http2 + operations: + - operation.otel.http.GET--pets-id.dc9e2765dcf6 + facets: + identity_tuple: + kind: http-binding + service_node: node.otel.service.gateway-observed.4ea22f0238ef + server_address: '' + server_port: null + zone: + - production + - '' + - '' + - '' + - '' +artifacts: +- id: artifact.ambiguous-declaration + kind: artifact + name: ambiguous fixture + artifact_type: fiam.artifact.architecture-declaration +- id: artifact.otel.stream.ambiguous-http.otlp.4f7c9d655f57 + kind: artifact + name: OTLP runtime stream + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/estate-hardening/ambiguous-http.otlp.json + facets: + format: OTLP/JSON + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + latest_batch_hash: b3421c406d9a5e66b75c94da6067d48540f2fa2abb39b0daf45ba77c1466bd77 + describes: + - interaction.sample.1b5b9581923bee4418356756.3333333333333333 +assertions: +- id: assertion.alpha.method + assertion_kind: property + subject: operation.alpha.get-pet + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: &id001 + mode: fiam.evidence.declared + source: + type: architecture-fixture + ref: artifact.ambiguous-declaration + locator: alpha + observer: fixture + confidence: 1.0 + stance: supports +- id: assertion.alpha.route + assertion_kind: property + subject: operation.alpha.get-pet + predicate: fiam.property.http-route + polarity: asserted + value: /pets/{id} + evidence: *id001 +- id: assertion.beta.method + assertion_kind: property + subject: operation.beta.get-pet + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: *id001 +- id: assertion.beta.route + assertion_kind: property + subject: operation.beta.get-pet + predicate: fiam.property.http-route + polarity: asserted + value: /pets/{id} + evidence: *id001 +- id: assertion.otel.369ab89aa421dec3deb4 + assertion_kind: property + subject: binding.otel.http.gateway-observed-unlocated.715c2ecd9a06 + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.ambiguous-http.otlp.4f7c9d655f57 + locator: aggregate:1b5b9581923bee4418356756 + metadata: + source: real-world/otel/estate-hardening/ambiguous-http.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:1b5b9581923bee4418356756 + aggregation_key: 1b5b9581923bee4418356756 + sample_spans: + - trace:88888888888888888888888888888888/span:3333333333333333 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: &id002 + aggregation_key: 1b5b9581923bee4418356756 + domain: http + role: server + operation_ref: operation.otel.http.GET--pets-id.dc9e2765dcf6 + local_node_ref: node.otel.service.gateway-observed.4ea22f0238ef + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.5375802da687e3923825 + assertion_kind: property + subject: binding.otel.http.gateway-observed-unlocated.715c2ecd9a06 + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.ambiguous-http.otlp.4f7c9d655f57 + locator: aggregate:1b5b9581923bee4418356756 + metadata: + source: real-world/otel/estate-hardening/ambiguous-http.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:1b5b9581923bee4418356756 + aggregation_key: 1b5b9581923bee4418356756 + sample_spans: + - trace:88888888888888888888888888888888/span:3333333333333333 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.5fc3e5ac747bd9982dff + assertion_kind: property + subject: operation.otel.http.GET--pets-id.dc9e2765dcf6 + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.ambiguous-http.otlp.4f7c9d655f57 + locator: attribute:http.request.method + metadata: + source: real-world/otel/estate-hardening/ambiguous-http.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.request.method + sample_spans: + - trace:88888888888888888888888888888888/span:3333333333333333 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.a159330db85e21da23d0 + assertion_kind: property + subject: binding.otel.http.gateway-observed-unlocated.715c2ecd9a06 + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.ambiguous-http.otlp.4f7c9d655f57 + locator: aggregate:1b5b9581923bee4418356756 + metadata: + source: real-world/otel/estate-hardening/ambiguous-http.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:1b5b9581923bee4418356756 + aggregation_key: 1b5b9581923bee4418356756 + sample_spans: + - trace:88888888888888888888888888888888/span:3333333333333333 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.d4a9733ad29768dec5e9 + assertion_kind: property + subject: binding.otel.http.gateway-observed-unlocated.715c2ecd9a06 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http2 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.ambiguous-http.otlp.4f7c9d655f57 + locator: attribute:network.protocol.version + metadata: + source: real-world/otel/estate-hardening/ambiguous-http.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:network.protocol.version + sample_spans: + - trace:88888888888888888888888888888888/span:3333333333333333 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.d9a82b1deece9db2b946 + assertion_kind: property + subject: binding.otel.http.gateway-observed-unlocated.715c2ecd9a06 + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.ambiguous-http.otlp.4f7c9d655f57 + locator: aggregate:1b5b9581923bee4418356756 + metadata: + source: real-world/otel/estate-hardening/ambiguous-http.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:1b5b9581923bee4418356756 + aggregation_key: 1b5b9581923bee4418356756 + sample_spans: + - trace:88888888888888888888888888888888/span:3333333333333333 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.e0e1ce2d5936ca1b563e + assertion_kind: property + subject: binding.otel.http.gateway-observed-unlocated.715c2ecd9a06 + predicate: fiam.property.network-protocol-version + polarity: asserted + value: '2' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.ambiguous-http.otlp.4f7c9d655f57 + locator: attribute:network.protocol.version + metadata: + source: real-world/otel/estate-hardening/ambiguous-http.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:network.protocol.version + sample_spans: + - trace:88888888888888888888888888888888/span:3333333333333333 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.e257946735f3a36cb8fa + assertion_kind: property + subject: node.otel.service.gateway-observed.4ea22f0238ef + predicate: fiam.property.service-name + polarity: asserted + value: gateway-observed + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.ambiguous-http.otlp.4f7c9d655f57 + locator: attribute:service.name + metadata: + source: real-world/otel/estate-hardening/ambiguous-http.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:88888888888888888888888888888888/span:3333333333333333 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.e8bdc688c39fcbc6ac07 + assertion_kind: property + subject: binding.otel.http.gateway-observed-unlocated.715c2ecd9a06 + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.ambiguous-http.otlp.4f7c9d655f57 + locator: aggregate:1b5b9581923bee4418356756 + metadata: + source: real-world/otel/estate-hardening/ambiguous-http.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:1b5b9581923bee4418356756 + aggregation_key: 1b5b9581923bee4418356756 + sample_spans: + - trace:88888888888888888888888888888888/span:3333333333333333 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.f0b832f0f0a324a5f7bb + assertion_kind: property + subject: interaction.sample.1b5b9581923bee4418356756.3333333333333333 + predicate: fiam.property.http-response-status-code + polarity: asserted + value: 200 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.ambiguous-http.otlp.4f7c9d655f57 + locator: attribute:http.response.status_code + metadata: + source: real-world/otel/estate-hardening/ambiguous-http.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.response.status_code + sample_spans: + - trace:88888888888888888888888888888888/span:3333333333333333 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.ff265ca66687a1339456 + assertion_kind: property + subject: operation.otel.http.GET--pets-id.dc9e2765dcf6 + predicate: fiam.property.http-route + polarity: asserted + value: /pets/{id} + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.ambiguous-http.otlp.4f7c9d655f57 + locator: attribute:http.route + metadata: + source: real-world/otel/estate-hardening/ambiguous-http.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.route + sample_spans: + - trace:88888888888888888888888888888888/span:3333333333333333 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +extensions: + org.fiam.catalog: + version: 0.2-draft.4 + processed_batches: + - b3421c406d9a5e66b75c94da6067d48540f2fa2abb39b0daf45ba77c1466bd77 + declared_entity_ids: + - artifact.ambiguous-declaration + - binding.alpha + - binding.beta + - contract.alpha.http + - contract.beta.http + - endpoint.alpha + - endpoint.beta + - node.service.alpha + - node.service.beta + - operation.alpha.get-pet + - operation.beta.get-pet + - port.alpha.http + - port.beta.http + last_ingest_at: '2026-09-09T07:00:00Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: sample + sample_size: 3 + org.fiam.runtime_aggregates: + - id: aggregate.otel.1b5b9581923bee4418356756 + domain: http + role: server + operation: operation.otel.http.GET--pets-id.dc9e2765dcf6 + binding: binding.otel.http.gateway-observed-unlocated.715c2ecd9a06 + local_node: node.otel.service.gateway-observed.4ea22f0238ef + remote_node: null + channel: null + resource: null + method: GET + route: /pets/{id} + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:00Z' + last_seen: '2026-09-09T07:00:00Z' + sample_spans: + - trace:88888888888888888888888888888888/span:3333333333333333 + org.fiam.runtime_topology_observations: [] + org.fiam.runtime_unresolved: [] + org.fiam.reconciliation_candidates: + - observed_ref: operation.otel.http.GET--pets-id.dc9e2765dcf6 + entity_kind: operation + status: ambiguous + candidates: + - declared_ref: operation.alpha.get-pet + binding_ref: binding.alpha + endpoint_ref: endpoint.alpha + node_ref: node.service.alpha + score: 0.8 + signals: + - http-method + - http-route-exact + - declared_ref: operation.beta.get-pet + binding_ref: binding.beta + endpoint_ref: endpoint.beta + node_ref: node.service.beta + score: 0.8 + signals: + - http-method + - http-route-exact +zones: +- id: zone.otel.environment.production.1521d207f3b6 + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.otel.service.gateway-observed.4ea22f0238ef +interactions: +- id: interaction.sample.1b5b9581923bee4418356756.3333333333333333 + kind: interaction + operation: operation.otel.http.GET--pets-id.dc9e2765dcf6 + contract: contract.otel.http.gateway-observed.5205bb5e84c0 + binding: binding.otel.http.gateway-observed-unlocated.715c2ecd9a06 + interaction_style: fiam.interaction-style.request-response + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + responder: node.otel.service.gateway-observed.4ea22f0238ef + facets: + otel_trace_id: '88888888888888888888888888888888' + otel_span_id: '3333333333333333' + otel_span_kind: server + instrumentation_scope: fixture + observed_service: node.otel.service.gateway-observed.4ea22f0238ef diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/ambiguous-http.lens.md b/history/FIAM_v0.2_Draft6/real-world/composite/ambiguous-http.lens.md new file mode 100644 index 0000000..9f07ea3 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/ambiguous-http.lens.md @@ -0,0 +1,19 @@ +# fiam.lens.declared-vs-observed result + +Model: `model.declared.ambiguous-http.catalog` + +## Property comparison + + +## Coverage + +- **ambiguous:** 1 +- **declared-only:** 2 + +## Property findings + +## Coverage findings + +- **declared-only** operation: `operation.alpha.get-pet` +- **declared-only** operation: `operation.beta.get-pet` +- **ambiguous** operation: `operation.otel.http.GET--pets-id.dc9e2765dcf6` (ambiguous) diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/ambiguous-http.lens.yaml b/history/FIAM_v0.2_Draft6/real-world/composite/ambiguous-http.lens.yaml new file mode 100644 index 0000000..b5bbcc1 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/ambiguous-http.lens.yaml @@ -0,0 +1,50 @@ +lens: fiam.lens.declared-vs-observed +lens_version: 0.2-draft.4 +model: model.declared.ambiguous-http.catalog +summary: + pairs: 0 + property_findings: 0 + classifications: {} + coverage: + ambiguous: 1 + declared-only: 2 +findings: [] +coverage_findings: +- entity_kind: operation + classification: declared-only + declared_ref: operation.alpha.get-pet + owner: + node_ref: node.service.alpha + name: alpha +- entity_kind: operation + classification: declared-only + declared_ref: operation.beta.get-pet + owner: + node_ref: node.service.beta + name: beta +- entity_kind: operation + classification: ambiguous + observed_ref: operation.otel.http.GET--pets-id.dc9e2765dcf6 + candidate_status: ambiguous + candidates: &id001 + - declared_ref: operation.alpha.get-pet + binding_ref: binding.alpha + endpoint_ref: endpoint.alpha + node_ref: node.service.alpha + score: 0.8 + signals: + - http-method + - http-route-exact + - declared_ref: operation.beta.get-pet + binding_ref: binding.beta + endpoint_ref: endpoint.beta + node_ref: node.service.beta + score: 0.8 + signals: + - http-method + - http-route-exact +reconciliation_candidates: +- observed_ref: operation.otel.http.GET--pets-id.dc9e2765dcf6 + entity_kind: operation + status: ambiguous + candidates: *id001 diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/gateway-rpc.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/composite/gateway-rpc.fiam.yaml new file mode 100644 index 0000000..4ca3f4d --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/gateway-rpc.fiam.yaml @@ -0,0 +1,1001 @@ +fiam_version: '0.2' +instance: + id: specimen.grpc.bidirectional-stream.catalog + kind: model + title: gRPC bidirectional streaming operation — runtime catalog + status: provisional + intent: Incremental FIAM catalog combining declared architecture with aggregated runtime observations. +nodes: +- id: node.grpc-client + kind: system-node + name: Telemetry Client + node_type: fiam.node-type.service +- id: node.grpc-server + kind: system-node + name: Telemetry Aggregator + node_type: fiam.node-type.service +- id: node.otel.service.Telemetry-Client.d615c56a664a + kind: system-node + name: Telemetry Client + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: Telemetry Client + environment: production +- id: node.otel.service.grpc.Telemetry-Aggregator.871798602556 + kind: system-node + name: Telemetry Aggregator + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service + system: grpc + logical_address: Telemetry Aggregator + zone: + - production + - '' + - '' + - '' + - '' +- id: node.otel.service.istio-proxy.4eb044a5d1b4 + kind: system-node + name: istio-proxy + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: istio-proxy + environment: production +ports: +- id: port.grpc-client + owner: node.grpc-client + participations: + - contract: contract.telemetry.grpc + mode: requires + roles: + - fiam.role.client +- id: port.grpc-server + owner: node.grpc-server + participations: + - contract: contract.telemetry.grpc + mode: offers + roles: + - fiam.role.server +- id: port.otel.rpc.Telemetry-Client-grpc-client.341f327a7fe2 + kind: port + owner: node.otel.service.Telemetry-Client.d615c56a664a + participations: + - contract: contract.otel.rpc.Telemetry-Client-grpc.9d43c8624f4e + mode: requires + roles: + - fiam.role.client +- id: port.otel.rpc.istio-proxy-grpc-server.df746a52ac68 + kind: port + owner: node.otel.service.istio-proxy.4eb044a5d1b4 + participations: + - contract: contract.otel.rpc.istio-proxy-grpc.b8260aa6f39a + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.otel.rpc.Telemetry-Client-grpc.9d43c8624f4e + kind: interface-contract + name: Observed grpc surface — Telemetry Client + operations: + - id: operation.otel.rpc.StreamTelemetry.056a20857982 + kind: operation + name: TelemetryService/StreamTelemetry + interaction_style: fiam.interaction-style.rpc + x-rpc-method: TelemetryService/StreamTelemetry +- id: contract.otel.rpc.istio-proxy-grpc.b8260aa6f39a + kind: interface-contract + name: Observed grpc surface — istio-proxy + operations: + - id: operation.otel.rpc.StreamTelemetry.27712660581b + kind: operation + name: TelemetryService/StreamTelemetry + interaction_style: fiam.interaction-style.rpc + x-rpc-method: TelemetryService/StreamTelemetry +- id: contract.telemetry.grpc + kind: interface-contract + purpose: + - fiam.purpose.telemetry-exchange + contract_forms: + - fiam.contract-form.protobuf-service + operations: + - id: operation.telemetry.stream + name: StreamTelemetry + interaction_style: fiam.interaction-style.rpc + temporal_semantics: fiam.temporal.bidirectional-stream +bindings: +- id: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f + kind: binding + contract: contract.otel.rpc.Telemetry-Client-grpc.9d43c8624f4e + operations: + - operation.otel.rpc.StreamTelemetry.056a20857982 + communication_stack: + - role: fiam.stack-role.rpc-protocol + term: fiam.protocol.grpc + facets: + identity_tuple: + kind: rpc-binding + service_node: node.otel.service.Telemetry-Client.d615c56a664a + system: grpc + logical_address: telemetry.internal:4317 + role: client + zone: + - production + - '' + - '' + - '' + - '' + consumer_ports: + - port.otel.rpc.Telemetry-Client-grpc-client.341f327a7fe2 + endpoints: + - endpoint.otel.rpc.telemetry.internal:4317.1f232b851824 +- id: binding.otel.rpc.istio-proxy-grpc-telemetry.internal:4317-server.c3948e71603f + kind: binding + contract: contract.otel.rpc.istio-proxy-grpc.b8260aa6f39a + operations: + - operation.otel.rpc.StreamTelemetry.27712660581b + communication_stack: + - role: fiam.stack-role.rpc-protocol + term: fiam.protocol.grpc + facets: + identity_tuple: + kind: rpc-binding + service_node: node.otel.service.istio-proxy.4eb044a5d1b4 + system: grpc + logical_address: telemetry.internal:4317 + role: server + zone: + - production + - '' + - '' + - '' + - '' + provider_port: port.otel.rpc.istio-proxy-grpc-server.df746a52ac68 + endpoints: + - endpoint.otel.rpc.telemetry.internal:4317.1f232b851824 +- id: binding.telemetry.grpc + contract: contract.telemetry.grpc + provider_port: port.grpc-server + consumer_ports: + - port.grpc-client + binding_profile: fiam.binding-profile.grpc-http2 + communication_stack: + - role: fiam.stack-role.rpc-protocol + term: fiam.protocol.grpc + - role: fiam.stack-role.serialization + term: fiam.representation.protobuf + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http2 + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + - role: fiam.stack-role.transport + term: fiam.transport.tcp +channels: +- id: channel.grpc-stream + kind: channel + channel_type: fiam.channel.bidirectional-message-stream + mediation: fiam.mediation.direct +interactions: +- id: interaction.sample.44b5356df9271fc1575ce6a5.2222222222222222 + kind: interaction + operation: operation.otel.rpc.StreamTelemetry.27712660581b + contract: contract.otel.rpc.istio-proxy-grpc.b8260aa6f39a + binding: binding.otel.rpc.istio-proxy-grpc-telemetry.internal:4317-server.c3948e71603f + interaction_style: fiam.interaction-style.rpc + temporal_semantics: fiam.temporal.synchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + responder: node.otel.service.istio-proxy.4eb044a5d1b4 + facets: + otel_trace_id: '77777777777777777777777777777777' + otel_span_id: '2222222222222222' + otel_span_kind: server + instrumentation_scope: fixture + observed_service: node.otel.service.istio-proxy.4eb044a5d1b4 + otel_parent_span_id: '1111111111111111' +- id: interaction.sample.ca5878f69ff85186d7feebe1.1111111111111111 + kind: interaction + operation: operation.otel.rpc.StreamTelemetry.056a20857982 + contract: contract.otel.rpc.Telemetry-Client-grpc.9d43c8624f4e + binding: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f + interaction_style: fiam.interaction-style.rpc + temporal_semantics: fiam.temporal.synchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + initiator: node.otel.service.Telemetry-Client.d615c56a664a + responder: node.otel.service.grpc.Telemetry-Aggregator.871798602556 + facets: + otel_trace_id: '77777777777777777777777777777777' + otel_span_id: '1111111111111111' + otel_span_kind: client + instrumentation_scope: fixture + observed_service: node.otel.service.Telemetry-Client.d615c56a664a +- id: interaction.telemetry-stream + operation: operation.telemetry.stream + binding: binding.telemetry.grpc + channel: channel.grpc-stream + participants: + initiator: node.grpc-client + responder: node.grpc-server +extensions: + org.fiam.catalog: + version: 0.2-draft.4 + processed_batches: + - 325f327d6cda592602aacc31097763b058f90b1e16ee499a4ea8c061da5d7d92 + declared_entity_ids: + - binding.telemetry.grpc + - channel.grpc-stream + - contract.telemetry.grpc + - interaction.telemetry-stream + - node.grpc-client + - node.grpc-server + - operation.telemetry.stream + - port.grpc-client + - port.grpc-server + last_ingest_at: '2026-09-09T07:00:00Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: sample + sample_size: 3 + org.fiam.runtime_aggregates: + - id: aggregate.otel.44b5356df9271fc1575ce6a5 + domain: rpc + role: server + operation: operation.otel.rpc.StreamTelemetry.27712660581b + binding: binding.otel.rpc.istio-proxy-grpc-telemetry.internal:4317-server.c3948e71603f + local_node: node.otel.service.istio-proxy.4eb044a5d1b4 + remote_node: null + channel: null + resource: null + rpc_system: grpc + rpc_method: TelemetryService/StreamTelemetry + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:00.001000Z' + last_seen: '2026-09-09T07:00:00.001000Z' + sample_spans: + - trace:77777777777777777777777777777777/span:2222222222222222 + - id: aggregate.otel.ca5878f69ff85186d7feebe1 + domain: rpc + role: client + operation: operation.otel.rpc.StreamTelemetry.056a20857982 + binding: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f + local_node: node.otel.service.Telemetry-Client.d615c56a664a + remote_node: node.otel.service.grpc.Telemetry-Aggregator.871798602556 + channel: null + resource: null + rpc_system: grpc + rpc_method: TelemetryService/StreamTelemetry + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:00Z' + last_seen: '2026-09-09T07:00:00Z' + sample_spans: + - trace:77777777777777777777777777777777/span:1111111111111111 + org.fiam.runtime_topology_observations: + - id: topology.otel.rpc.c2d925e81d3630f250e9 + domain: rpc + count: 1 + first_seen: '2026-09-09T07:00:00Z' + last_seen: '2026-09-09T07:00:00.001000Z' + sample_correlations: + - 77777777777777777777777777777777:interaction.sample.ca5878f69ff85186d7feebe1.1111111111111111->interaction.sample.44b5356df9271fc1575ce6a5.2222222222222222 + kind: direct-call + from: node.otel.service.Telemetry-Client.d615c56a664a + to: node.otel.service.istio-proxy.4eb044a5d1b4 + binding: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f + operation: operation.otel.rpc.StreamTelemetry.056a20857982 + correlation: trace-parent + via_gateway: true + gateway: node.otel.service.istio-proxy.4eb044a5d1b4 + intended_target: node.grpc-server + org.fiam.runtime_unresolved: [] + org.fiam.reconciliation_candidates: + - observed_ref: node.otel.service.Telemetry-Client.d615c56a664a + entity_kind: system-node + status: matched + candidates: + - declared_ref: node.grpc-client + score: 0.7 + signals: &id004 + - service-name + - observed_ref: operation.otel.rpc.StreamTelemetry.056a20857982 + entity_kind: operation + status: matched + candidates: + - declared_ref: operation.telemetry.stream + binding_ref: binding.telemetry.grpc + node_ref: node.grpc-server + score: 0.82 + signals: &id003 + - rpc-protocol + - rpc-method-terminal + - service-peer-name + - observed_ref: operation.otel.rpc.StreamTelemetry.27712660581b + entity_kind: operation + status: near-match + candidates: + - declared_ref: operation.telemetry.stream + binding_ref: binding.telemetry.grpc + node_ref: node.grpc-server + score: 0.62 + signals: + - rpc-protocol + - rpc-method-terminal +artifacts: +- id: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + kind: artifact + name: OTLP runtime stream + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/estate-hardening/gateway-rpc.otlp.json + facets: + format: OTLP/JSON + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + latest_batch_hash: 325f327d6cda592602aacc31097763b058f90b1e16ee499a4ea8c061da5d7d92 + describes: + - interaction.sample.44b5356df9271fc1575ce6a5.2222222222222222 + - interaction.sample.ca5878f69ff85186d7feebe1.1111111111111111 +zones: +- id: zone.otel.environment.production.1521d207f3b6 + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.otel.service.Telemetry-Client.d615c56a664a + - node.otel.service.istio-proxy.4eb044a5d1b4 +endpoints: +- id: endpoint.otel.rpc.telemetry.internal:4317.1f232b851824 + kind: endpoint + name: telemetry.internal:4317 + address_scheme: fiam.address-scheme.host-port + facets: + identity_tuple: + address: telemetry.internal:4317 + address_scheme: fiam.address-scheme.host-port + zone: + - production + - '' + - '' + - '' + - '' + logical_server_address: telemetry.internal + address: telemetry.internal:4317 +assertions: +- id: assertion.otel.06bd721b6a7000f7b0a9 + assertion_kind: property + subject: binding.otel.rpc.istio-proxy-grpc-telemetry.internal:4317-server.c3948e71603f + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: aggregate:44b5356df9271fc1575ce6a5 + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:44b5356df9271fc1575ce6a5 + aggregation_key: 44b5356df9271fc1575ce6a5 + sample_spans: + - trace:77777777777777777777777777777777/span:2222222222222222 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.001000Z' + facets: &id001 + aggregation_key: 44b5356df9271fc1575ce6a5 + domain: rpc + role: server + operation_ref: operation.otel.rpc.StreamTelemetry.27712660581b + local_node_ref: node.otel.service.istio-proxy.4eb044a5d1b4 + valid_time: + valid_from: '2026-09-09T07:00:00.001000Z' + valid_until: '2026-09-09T07:00:00.001000Z' + observed_at: '2026-09-09T07:00:00.001000Z' +- id: assertion.otel.113c77eaa3e4d21bc4ba + assertion_kind: property + subject: binding.otel.rpc.istio-proxy-grpc-telemetry.internal:4317-server.c3948e71603f + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: aggregate:44b5356df9271fc1575ce6a5 + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:44b5356df9271fc1575ce6a5 + aggregation_key: 44b5356df9271fc1575ce6a5 + sample_spans: + - trace:77777777777777777777777777777777/span:2222222222222222 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.001000Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00.001000Z' + valid_until: '2026-09-09T07:00:00.001000Z' + observed_at: '2026-09-09T07:00:00.001000Z' +- id: assertion.otel.18b2d06f30bd6082b9e1 + assertion_kind: property + subject: binding.otel.rpc.istio-proxy-grpc-telemetry.internal:4317-server.c3948e71603f + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:00.001000Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: aggregate:44b5356df9271fc1575ce6a5 + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:44b5356df9271fc1575ce6a5 + aggregation_key: 44b5356df9271fc1575ce6a5 + sample_spans: + - trace:77777777777777777777777777777777/span:2222222222222222 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.001000Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00.001000Z' + valid_until: '2026-09-09T07:00:00.001000Z' + observed_at: '2026-09-09T07:00:00.001000Z' +- id: assertion.otel.1f6e0cfae79cd2aab572 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: aggregate:ca5878f69ff85186d7feebe1 + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:ca5878f69ff85186d7feebe1 + aggregation_key: ca5878f69ff85186d7feebe1 + sample_spans: + - trace:77777777777777777777777777777777/span:1111111111111111 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: &id002 + aggregation_key: ca5878f69ff85186d7feebe1 + domain: rpc + role: client + operation_ref: operation.otel.rpc.StreamTelemetry.056a20857982 + local_node_ref: node.otel.service.Telemetry-Client.d615c56a664a + remote_node_ref: node.otel.service.grpc.Telemetry-Aggregator.871798602556 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.21b2e525e34143ecfce5 + assertion_kind: property + subject: binding.otel.rpc.istio-proxy-grpc-telemetry.internal:4317-server.c3948e71603f + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:00.001000Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: aggregate:44b5356df9271fc1575ce6a5 + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:44b5356df9271fc1575ce6a5 + aggregation_key: 44b5356df9271fc1575ce6a5 + sample_spans: + - trace:77777777777777777777777777777777/span:2222222222222222 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.001000Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00.001000Z' + valid_until: '2026-09-09T07:00:00.001000Z' + observed_at: '2026-09-09T07:00:00.001000Z' +- id: assertion.otel.2342fa93689ee6fc3667 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: aggregate:ca5878f69ff85186d7feebe1 + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:ca5878f69ff85186d7feebe1 + aggregation_key: ca5878f69ff85186d7feebe1 + sample_spans: + - trace:77777777777777777777777777777777/span:1111111111111111 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.241cc9bf654e2e63d6c2 + assertion_kind: relation + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: binding.telemetry.grpc + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: reconcile:rpc + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:rpc + signals: *id003 + score: 0.82 + sample_spans: + - trace:77777777777777777777777777777777/span:1111111111111111 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.95 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.2f1526622380a7060814 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f + predicate: fiam.property.service-peer-name + polarity: asserted + value: Telemetry Aggregator + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: attribute:service.peer.name + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.peer.name + sample_spans: + - trace:77777777777777777777777777777777/span:1111111111111111 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.38f4eb6d433d85857559 + assertion_kind: property + subject: operation.otel.rpc.StreamTelemetry.27712660581b + predicate: fiam.property.rpc-system-name + polarity: asserted + value: grpc + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: attribute:rpc.system.name + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.system.name + sample_spans: + - trace:77777777777777777777777777777777/span:2222222222222222 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.001000Z' + valid_time: + valid_from: '2026-09-09T07:00:00.001000Z' + valid_until: '2026-09-09T07:00:00.001000Z' + observed_at: '2026-09-09T07:00:00.001000Z' +- id: assertion.otel.3d07bb0dac7d97b7b91a + assertion_kind: property + subject: operation.otel.rpc.StreamTelemetry.056a20857982 + predicate: fiam.property.rpc-method + polarity: asserted + value: TelemetryService/StreamTelemetry + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: attribute:rpc.method + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.method + sample_spans: + - trace:77777777777777777777777777777777/span:1111111111111111 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.47f6b0f53725460ab21d + assertion_kind: property + subject: operation.otel.rpc.StreamTelemetry.27712660581b + predicate: fiam.property.rpc-method + polarity: asserted + value: TelemetryService/StreamTelemetry + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: attribute:rpc.method + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.method + sample_spans: + - trace:77777777777777777777777777777777/span:2222222222222222 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.001000Z' + valid_time: + valid_from: '2026-09-09T07:00:00.001000Z' + valid_until: '2026-09-09T07:00:00.001000Z' + observed_at: '2026-09-09T07:00:00.001000Z' +- id: assertion.otel.4cc0f428a66175a8be0a + assertion_kind: property + subject: binding.otel.rpc.istio-proxy-grpc-telemetry.internal:4317-server.c3948e71603f + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.grpc + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: attribute:rpc.system.name + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.system.name + sample_spans: + - trace:77777777777777777777777777777777/span:2222222222222222 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.001000Z' + valid_time: + valid_from: '2026-09-09T07:00:00.001000Z' + valid_until: '2026-09-09T07:00:00.001000Z' + observed_at: '2026-09-09T07:00:00.001000Z' +- id: assertion.otel.5030995c97a9a75ce41a + assertion_kind: property + subject: binding.otel.rpc.istio-proxy-grpc-telemetry.internal:4317-server.c3948e71603f + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: aggregate:44b5356df9271fc1575ce6a5 + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:44b5356df9271fc1575ce6a5 + aggregation_key: 44b5356df9271fc1575ce6a5 + sample_spans: + - trace:77777777777777777777777777777777/span:2222222222222222 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.001000Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00.001000Z' + valid_until: '2026-09-09T07:00:00.001000Z' + observed_at: '2026-09-09T07:00:00.001000Z' +- id: assertion.otel.54e8e8da051987980852 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: aggregate:ca5878f69ff85186d7feebe1 + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:ca5878f69ff85186d7feebe1 + aggregation_key: ca5878f69ff85186d7feebe1 + sample_spans: + - trace:77777777777777777777777777777777/span:1111111111111111 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.5938d081c927081ef5c4 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: aggregate:ca5878f69ff85186d7feebe1 + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:ca5878f69ff85186d7feebe1 + aggregation_key: ca5878f69ff85186d7feebe1 + sample_spans: + - trace:77777777777777777777777777777777/span:1111111111111111 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.677763ce55146863af17 + assertion_kind: property + subject: node.otel.service.Telemetry-Client.d615c56a664a + predicate: fiam.property.service-name + polarity: asserted + value: Telemetry Client + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: attribute:service.name + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:77777777777777777777777777777777/span:1111111111111111 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.6db9aa8821bc2452ec3d + assertion_kind: relation + subject: node.otel.service.Telemetry-Client.d615c56a664a + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: node.grpc-client + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: reconcile:service-identity + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:service-identity + signals: *id004 + sample_spans: + - trace:77777777777777777777777777777777/span:1111111111111111 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.92 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.cf5a72389a79ee318f69 + assertion_kind: relation + subject: operation.otel.rpc.StreamTelemetry.056a20857982 + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: operation.telemetry.stream + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: reconcile:rpc + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:rpc + signals: *id003 + score: 0.82 + sample_spans: + - trace:77777777777777777777777777777777/span:1111111111111111 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.96 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.d353d38a4fee45b1d6ed + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.grpc + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: attribute:rpc.system.name + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.system.name + sample_spans: + - trace:77777777777777777777777777777777/span:1111111111111111 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.dcb46ed987e3552bc3c0 + assertion_kind: property + subject: operation.otel.rpc.StreamTelemetry.056a20857982 + predicate: fiam.property.rpc-system-name + polarity: asserted + value: grpc + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: attribute:rpc.system.name + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.system.name + sample_spans: + - trace:77777777777777777777777777777777/span:1111111111111111 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.e8663b5466dd2296aa8f + assertion_kind: property + subject: node.otel.service.istio-proxy.4eb044a5d1b4 + predicate: fiam.property.service-name + polarity: asserted + value: istio-proxy + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: attribute:service.name + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:77777777777777777777777777777777/span:2222222222222222 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.001000Z' + valid_time: + valid_from: '2026-09-09T07:00:00.001000Z' + valid_until: '2026-09-09T07:00:00.001000Z' + observed_at: '2026-09-09T07:00:00.001000Z' +- id: assertion.otel.f1a461ff45fe3e0522af + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.gateway-rpc.otlp.291e6a573588 + locator: aggregate:ca5878f69ff85186d7feebe1 + metadata: + source: real-world/otel/estate-hardening/gateway-rpc.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:ca5878f69ff85186d7feebe1 + aggregation_key: ca5878f69ff85186d7feebe1 + sample_spans: + - trace:77777777777777777777777777777777/span:1111111111111111 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/gateway-rpc.topology.md b/history/FIAM_v0.2_Draft6/real-world/composite/gateway-rpc.topology.md new file mode 100644 index 0000000..7c9c86d --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/gateway-rpc.topology.md @@ -0,0 +1,13 @@ +# Runtime Interaction Topology + +Model: `specimen.grpc.bidirectional-stream.catalog` + +## Summary + +- **rpc:** 1 +- **unresolved:** 0 +- **working-set attachments:** 3 + +## Edges + +- RPC: **Telemetry Client** → **istio-proxy** via gateway **istio-proxy** toward **Telemetry Aggregator** diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/gateway-rpc.topology.yaml b/history/FIAM_v0.2_Draft6/real-world/composite/gateway-rpc.topology.yaml new file mode 100644 index 0000000..8ed7db0 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/gateway-rpc.topology.yaml @@ -0,0 +1,34 @@ +lens: fiam.lens.runtime-topology +lens_version: 0.2-draft.4 +model: specimen.grpc.bidirectional-stream.catalog +summary: + edges: 1 + domains: + rpc: 1 + architectural_nodes: 2 + unresolved: 0 + working_set_attachments: 3 +edges: +- id: edge.topology.otel.rpc.c2d925e81d3630f250e9 + domain: rpc + kind: direct-call + count: 1 + first_seen: '2026-09-09T07:00:00Z' + last_seen: '2026-09-09T07:00:00.001000Z' + correlation: trace-parent + from: node.grpc-client + observed_from: node.otel.service.Telemetry-Client.d615c56a664a + to: node.otel.service.istio-proxy.4eb044a5d1b4 + observed_to: node.otel.service.istio-proxy.4eb044a5d1b4 + binding: binding.telemetry.grpc + observed_binding: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f + operation: operation.telemetry.stream + observed_operation: operation.otel.rpc.StreamTelemetry.056a20857982 + via_gateway: true + gateway: node.otel.service.istio-proxy.4eb044a5d1b4 + observed_gateway: node.otel.service.istio-proxy.4eb044a5d1b4 + intended_target: node.grpc-server +unresolved: [] +working_set: + enabled: true + ambiguous: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/gateway-rpc.working-set.yaml b/history/FIAM_v0.2_Draft6/real-world/composite/gateway-rpc.working-set.yaml new file mode 100644 index 0000000..e7d5338 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/gateway-rpc.working-set.yaml @@ -0,0 +1,26 @@ +model: specimen.grpc.bidirectional-stream.catalog +policy: + preference: declared-preferred-through-high-confidence-correspondence + threshold: 0.9 + destructive_merge: false +preferred_ref_by_observed: + binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f: binding.telemetry.grpc + node.otel.service.Telemetry-Client.d615c56a664a: node.grpc-client + operation.otel.rpc.StreamTelemetry.056a20857982: operation.telemetry.stream +attachments: +- observed_ref: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.e3f31cb7ac6f + preferred_ref: binding.telemetry.grpc + confidence: 0.95 + assertion_id: assertion.otel.241cc9bf654e2e63d6c2 + merged: false +- observed_ref: node.otel.service.Telemetry-Client.d615c56a664a + preferred_ref: node.grpc-client + confidence: 0.92 + assertion_id: assertion.otel.6db9aa8821bc2452ec3d + merged: false +- observed_ref: operation.otel.rpc.StreamTelemetry.056a20857982 + preferred_ref: operation.telemetry.stream + confidence: 0.96 + assertion_id: assertion.otel.cf5a72389a79ee318f69 + merged: false +ambiguous: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/grpc-declared-plus-runtime.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/composite/grpc-declared-plus-runtime.fiam.yaml new file mode 100644 index 0000000..5be73a9 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/grpc-declared-plus-runtime.fiam.yaml @@ -0,0 +1,930 @@ +fiam_version: '0.2' +instance: + id: specimen.grpc.bidirectional-stream.catalog + kind: model + title: gRPC bidirectional streaming operation — runtime catalog + status: provisional + intent: Incremental FIAM catalog combining declared architecture with aggregated runtime observations. +nodes: +- id: node.grpc-client + kind: system-node + name: Telemetry Client + node_type: fiam.node-type.service +- id: node.grpc-server + kind: system-node + name: Telemetry Aggregator + node_type: fiam.node-type.service +- id: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + kind: system-node + name: Telemetry Aggregator + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: Telemetry Aggregator +- id: node.otel.service.Telemetry-Client.78936dd205bd + kind: system-node + name: Telemetry Client + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: Telemetry Client +ports: +- id: port.grpc-client + owner: node.grpc-client + participations: + - contract: contract.telemetry.grpc + mode: requires + roles: + - fiam.role.client +- id: port.grpc-server + owner: node.grpc-server + participations: + - contract: contract.telemetry.grpc + mode: offers + roles: + - fiam.role.server +- id: port.otel.rpc.Telemetry-Aggregator-grpc-server.97d1d4ec3f07 + kind: port + owner: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + participations: + - contract: contract.otel.rpc.Telemetry-Aggregator-grpc.514ae3c41ea1 + mode: offers + roles: + - fiam.role.server +- id: port.otel.rpc.Telemetry-Client-grpc-client.fd704ccd5456 + kind: port + owner: node.otel.service.Telemetry-Client.78936dd205bd + participations: + - contract: contract.otel.rpc.Telemetry-Client-grpc.7c8fe2572a80 + mode: requires + roles: + - fiam.role.client +contracts: +- id: contract.otel.rpc.Telemetry-Aggregator-grpc.514ae3c41ea1 + kind: interface-contract + name: Observed grpc surface — Telemetry Aggregator + operations: + - id: operation.otel.rpc.StreamTelemetry.7785627aa978 + kind: operation + name: TelemetryService/StreamTelemetry + interaction_style: fiam.interaction-style.rpc + x-rpc-method: TelemetryService/StreamTelemetry +- id: contract.otel.rpc.Telemetry-Client-grpc.7c8fe2572a80 + kind: interface-contract + name: Observed grpc surface — Telemetry Client + operations: + - id: operation.otel.rpc.StreamTelemetry.552f69398b3d + kind: operation + name: TelemetryService/StreamTelemetry + interaction_style: fiam.interaction-style.rpc + x-rpc-method: TelemetryService/StreamTelemetry +- id: contract.telemetry.grpc + kind: interface-contract + purpose: + - fiam.purpose.telemetry-exchange + contract_forms: + - fiam.contract-form.protobuf-service + operations: + - id: operation.telemetry.stream + name: StreamTelemetry + interaction_style: fiam.interaction-style.rpc + temporal_semantics: fiam.temporal.bidirectional-stream +bindings: +- id: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + kind: binding + contract: contract.otel.rpc.Telemetry-Aggregator-grpc.514ae3c41ea1 + operations: + - operation.otel.rpc.StreamTelemetry.7785627aa978 + communication_stack: + - role: fiam.stack-role.rpc-protocol + term: fiam.protocol.grpc + facets: + identity_tuple: + kind: rpc-binding + service_node: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + system: grpc + logical_address: telemetry.internal:4317 + role: server + zone: + - '' + - '' + - '' + - '' + - '' + provider_port: port.otel.rpc.Telemetry-Aggregator-grpc-server.97d1d4ec3f07 + endpoints: + - endpoint.otel.rpc.telemetry.internal:4317.ea4b6583a12d +- id: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + kind: binding + contract: contract.otel.rpc.Telemetry-Client-grpc.7c8fe2572a80 + operations: + - operation.otel.rpc.StreamTelemetry.552f69398b3d + communication_stack: + - role: fiam.stack-role.rpc-protocol + term: fiam.protocol.grpc + facets: + identity_tuple: + kind: rpc-binding + service_node: node.otel.service.Telemetry-Client.78936dd205bd + system: grpc + logical_address: telemetry.internal:4317 + role: client + zone: + - '' + - '' + - '' + - '' + - '' + consumer_ports: + - port.otel.rpc.Telemetry-Client-grpc-client.fd704ccd5456 + endpoints: + - endpoint.otel.rpc.telemetry.internal:4317.ea4b6583a12d +- id: binding.telemetry.grpc + contract: contract.telemetry.grpc + provider_port: port.grpc-server + consumer_ports: + - port.grpc-client + binding_profile: fiam.binding-profile.grpc-http2 + communication_stack: + - role: fiam.stack-role.rpc-protocol + term: fiam.protocol.grpc + - role: fiam.stack-role.serialization + term: fiam.representation.protobuf + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http2 + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + - role: fiam.stack-role.transport + term: fiam.transport.tcp +channels: +- id: channel.grpc-stream + kind: channel + channel_type: fiam.channel.bidirectional-message-stream + mediation: fiam.mediation.direct +interactions: +- id: interaction.sample.2ccec9f9ed32803fa562b76c.aaaaaaaaaaaaaaaa + kind: interaction + operation: operation.otel.rpc.StreamTelemetry.552f69398b3d + contract: contract.otel.rpc.Telemetry-Client-grpc.7c8fe2572a80 + binding: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + interaction_style: fiam.interaction-style.rpc + temporal_semantics: fiam.temporal.synchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + initiator: node.otel.service.Telemetry-Client.78936dd205bd + facets: + otel_trace_id: '11111111111111111111111111111111' + otel_span_id: aaaaaaaaaaaaaaaa + otel_span_kind: client + instrumentation_scope: runtime-fixture + observed_service: node.otel.service.Telemetry-Client.78936dd205bd +- id: interaction.sample.43bc423016df8daaec891605.bbbbbbbbbbbbbbbb + kind: interaction + operation: operation.otel.rpc.StreamTelemetry.7785627aa978 + contract: contract.otel.rpc.Telemetry-Aggregator-grpc.514ae3c41ea1 + binding: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + interaction_style: fiam.interaction-style.rpc + temporal_semantics: fiam.temporal.synchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + responder: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + facets: + otel_trace_id: '11111111111111111111111111111111' + otel_span_id: bbbbbbbbbbbbbbbb + otel_span_kind: server + instrumentation_scope: runtime-fixture + observed_service: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + otel_parent_span_id: aaaaaaaaaaaaaaaa +- id: interaction.telemetry-stream + operation: operation.telemetry.stream + binding: binding.telemetry.grpc + channel: channel.grpc-stream + participants: + initiator: node.grpc-client + responder: node.grpc-server +extensions: + org.fiam.catalog: + version: 0.2-draft.4 + processed_batches: + - e2385373e31774a04e91dba733e6773c2c02f83c0ec0d29c24fbb46f8612be53 + declared_entity_ids: + - binding.telemetry.grpc + - channel.grpc-stream + - contract.telemetry.grpc + - interaction.telemetry-stream + - node.grpc-client + - node.grpc-server + - operation.telemetry.stream + - port.grpc-client + - port.grpc-server + last_ingest_at: '2026-09-09T07:00:00Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: sample + sample_size: 3 + org.fiam.runtime_aggregates: + - id: aggregate.otel.2ccec9f9ed32803fa562b76c + domain: rpc + role: client + operation: operation.otel.rpc.StreamTelemetry.552f69398b3d + binding: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + local_node: node.otel.service.Telemetry-Client.78936dd205bd + remote_node: null + channel: null + resource: null + rpc_system: grpc + rpc_method: TelemetryService/StreamTelemetry + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:00Z' + last_seen: '2026-09-09T07:00:00Z' + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + - id: aggregate.otel.43bc423016df8daaec891605 + domain: rpc + role: server + operation: operation.otel.rpc.StreamTelemetry.7785627aa978 + binding: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + local_node: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + remote_node: null + channel: null + resource: null + rpc_system: grpc + rpc_method: TelemetryService/StreamTelemetry + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:00.010000Z' + last_seen: '2026-09-09T07:00:00.010000Z' + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + org.fiam.runtime_topology_observations: + - id: topology.otel.rpc.68b29be9b90d97664917 + domain: rpc + count: 1 + first_seen: '2026-09-09T07:00:00Z' + last_seen: '2026-09-09T07:00:00.010000Z' + sample_correlations: + - 11111111111111111111111111111111:interaction.sample.2ccec9f9ed32803fa562b76c.aaaaaaaaaaaaaaaa->interaction.sample.43bc423016df8daaec891605.bbbbbbbbbbbbbbbb + kind: direct-call + from: node.otel.service.Telemetry-Client.78936dd205bd + to: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + binding: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + operation: operation.otel.rpc.StreamTelemetry.552f69398b3d + correlation: trace-parent + via_gateway: false + org.fiam.runtime_unresolved: [] + org.fiam.reconciliation_candidates: + - observed_ref: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + entity_kind: system-node + status: matched + candidates: + - declared_ref: node.grpc-server + score: 0.7 + signals: &id003 + - service-name + - observed_ref: node.otel.service.Telemetry-Client.78936dd205bd + entity_kind: system-node + status: matched + candidates: + - declared_ref: node.grpc-client + score: 0.7 + signals: &id004 + - service-name + - observed_ref: operation.otel.rpc.StreamTelemetry.552f69398b3d + entity_kind: operation + status: near-match + candidates: + - declared_ref: operation.telemetry.stream + binding_ref: binding.telemetry.grpc + node_ref: node.grpc-server + score: 0.62 + signals: + - rpc-protocol + - rpc-method-terminal + - observed_ref: operation.otel.rpc.StreamTelemetry.7785627aa978 + entity_kind: operation + status: near-match + candidates: + - declared_ref: operation.telemetry.stream + binding_ref: binding.telemetry.grpc + node_ref: node.grpc-server + score: 0.62 + signals: + - rpc-protocol + - rpc-method-terminal +artifacts: +- id: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + kind: artifact + name: OTLP runtime stream + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/grpc-runtime.otlp.json + facets: + format: OTLP/JSON + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + latest_batch_hash: e2385373e31774a04e91dba733e6773c2c02f83c0ec0d29c24fbb46f8612be53 + describes: + - interaction.sample.2ccec9f9ed32803fa562b76c.aaaaaaaaaaaaaaaa + - interaction.sample.43bc423016df8daaec891605.bbbbbbbbbbbbbbbb +zones: +- id: zone.otel.unscoped + kind: zone + name: Unscoped runtime observations + zone_type: fiam.zone-type.unscoped + members: + - node.otel.service.Telemetry-Client.78936dd205bd + - node.otel.service.Telemetry-Aggregator.ff6cc4a76891 +endpoints: +- id: endpoint.otel.rpc.telemetry.internal:4317.ea4b6583a12d + kind: endpoint + name: telemetry.internal:4317 + address_scheme: fiam.address-scheme.host-port + facets: + identity_tuple: + address: telemetry.internal:4317 + address_scheme: fiam.address-scheme.host-port + zone: + - '' + - '' + - '' + - '' + - '' + logical_server_address: telemetry.internal + address: telemetry.internal:4317 +assertions: +- id: assertion.otel.16564bbbbc499dd2dd77 + assertion_kind: property + subject: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + predicate: fiam.property.service-name + polarity: asserted + value: Telemetry Aggregator + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: attribute:service.name + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.434be08ba01f8d6aab9d + assertion_kind: property + subject: operation.otel.rpc.StreamTelemetry.552f69398b3d + predicate: fiam.property.rpc-system-name + polarity: asserted + value: grpc + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: attribute:rpc.system.name + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.system.name + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.48143cfd29eb7b6bafc3 + assertion_kind: property + subject: operation.otel.rpc.StreamTelemetry.7785627aa978 + predicate: fiam.property.rpc-system-name + polarity: asserted + value: grpc + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: attribute:rpc.system.name + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.system.name + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.5b34af908631ef11888c + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: aggregate:43bc423016df8daaec891605 + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:43bc423016df8daaec891605 + aggregation_key: 43bc423016df8daaec891605 + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + facets: &id001 + aggregation_key: 43bc423016df8daaec891605 + domain: rpc + role: server + operation_ref: operation.otel.rpc.StreamTelemetry.7785627aa978 + local_node_ref: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.646f35d7c4ab43786354 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: aggregate:43bc423016df8daaec891605 + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:43bc423016df8daaec891605 + aggregation_key: 43bc423016df8daaec891605 + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.67f5cb7d53c3bc0b042c + assertion_kind: property + subject: operation.otel.rpc.StreamTelemetry.552f69398b3d + predicate: fiam.property.rpc-method + polarity: asserted + value: TelemetryService/StreamTelemetry + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: attribute:rpc.method + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.method + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.6bbcaa4be952e1b93214 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:00.010000Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: aggregate:43bc423016df8daaec891605 + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:43bc423016df8daaec891605 + aggregation_key: 43bc423016df8daaec891605 + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.7406fe78cf99d3a341cb + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: aggregate:2ccec9f9ed32803fa562b76c + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2ccec9f9ed32803fa562b76c + aggregation_key: 2ccec9f9ed32803fa562b76c + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: &id002 + aggregation_key: 2ccec9f9ed32803fa562b76c + domain: rpc + role: client + operation_ref: operation.otel.rpc.StreamTelemetry.552f69398b3d + local_node_ref: node.otel.service.Telemetry-Client.78936dd205bd + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.7db8e7fc7b81c9797c64 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.grpc + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: attribute:rpc.system.name + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.system.name + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.81b1e9e2534ae1b4b43e + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: aggregate:2ccec9f9ed32803fa562b76c + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2ccec9f9ed32803fa562b76c + aggregation_key: 2ccec9f9ed32803fa562b76c + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.85bb706ed46a335b40d1 + assertion_kind: property + subject: operation.otel.rpc.StreamTelemetry.7785627aa978 + predicate: fiam.property.rpc-method + polarity: asserted + value: TelemetryService/StreamTelemetry + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: attribute:rpc.method + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.method + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.8911b188c96835519d73 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.grpc + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: attribute:rpc.system.name + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.system.name + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.acb56a6457756f7993ca + assertion_kind: property + subject: node.otel.service.Telemetry-Client.78936dd205bd + predicate: fiam.property.service-name + polarity: asserted + value: Telemetry Client + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: attribute:service.name + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.ca392eabd5d7fdd02a90 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: aggregate:2ccec9f9ed32803fa562b76c + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2ccec9f9ed32803fa562b76c + aggregation_key: 2ccec9f9ed32803fa562b76c + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.cb7d95335b6f057b8c29 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: aggregate:2ccec9f9ed32803fa562b76c + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2ccec9f9ed32803fa562b76c + aggregation_key: 2ccec9f9ed32803fa562b76c + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.dfe25a2b70c1dec57d69 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: aggregate:2ccec9f9ed32803fa562b76c + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2ccec9f9ed32803fa562b76c + aggregation_key: 2ccec9f9ed32803fa562b76c + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.e539d30cb8ecb8b13e74 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: aggregate:43bc423016df8daaec891605 + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:43bc423016df8daaec891605 + aggregation_key: 43bc423016df8daaec891605 + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.ea64c8043a1fe5a13b85 + assertion_kind: relation + subject: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: node.grpc-server + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: reconcile:service-identity + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:service-identity + signals: *id003 + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 0.92 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.ed144c61299b5f17b6c1 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:00.010000Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: aggregate:43bc423016df8daaec891605 + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:43bc423016df8daaec891605 + aggregation_key: 43bc423016df8daaec891605 + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.fb3f62325ab4c2fa8773 + assertion_kind: relation + subject: node.otel.service.Telemetry-Client.78936dd205bd + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: node.grpc-client + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.grpc-runtime.otlp.91614cfe5cee + locator: reconcile:service-identity + metadata: + source: real-world/otel/grpc-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:service-identity + signals: *id004 + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 0.92 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/kafka-declared-plus-runtime.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/composite/kafka-declared-plus-runtime.fiam.yaml new file mode 100644 index 0000000..f2429cb --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/kafka-declared-plus-runtime.fiam.yaml @@ -0,0 +1,1182 @@ +fiam_version: '0.2' +instance: + id: specimen.kafka.topic.catalog + kind: model + title: Kafka producer/consumer interaction through a durable topic — runtime catalog + status: provisional + intent: Incremental FIAM catalog combining declared architecture with aggregated runtime observations. +nodes: +- id: node.billing-service + kind: system-node + name: Billing Service + node_type: fiam.node-type.service +- id: node.kafka-cluster + kind: system-node + name: Kafka Cluster + node_type: fiam.node-type.broker +- id: node.order-service + kind: system-node + name: Order Service + node_type: fiam.node-type.service +- id: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + kind: system-node + name: kafka at kafka.internal:9092 + node_type: fiam.node-type.broker + facets: + identity_tuple: + kind: broker + system: kafka + logical_address: kafka.internal:9092 + zone: + - '' + - '' + - '' + - '' + - '' +- id: node.otel.service.Billing-Service.d6ddce900d32 + kind: system-node + name: Billing Service + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: Billing Service +- id: node.otel.service.Order-Service.a75279f84c2c + kind: system-node + name: Order Service + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: Order Service +ports: +- id: port.billing.events + owner: node.billing-service + participations: + - contract: contract.order-events + mode: requires + roles: + - fiam.role.consumer +- id: port.order.events + owner: node.order-service + participations: + - contract: contract.order-events + mode: offers + roles: + - fiam.role.producer +- id: port.otel.messaging.Billing-Service-kafka-consumer.2375156d00c8 + kind: port + owner: node.otel.service.Billing-Service.d6ddce900d32 + participations: + - contract: contract.otel.messaging.Billing-Service-kafka.18363aba2a59 + mode: requires + roles: + - fiam.role.consumer +- id: port.otel.messaging.Order-Service-kafka-producer.998bdba5e0d9 + kind: port + owner: node.otel.service.Order-Service.a75279f84c2c + participations: + - contract: contract.otel.messaging.Order-Service-kafka.eb23fcd426e8 + mode: requires + roles: + - fiam.role.producer +contracts: +- id: contract.order-events + kind: interface-contract + purpose: + - fiam.purpose.domain-event-publication + contract_forms: + - fiam.contract-form.event-schema + operations: + - id: operation.order-created.consume + name: OrderCreated + interaction_style: fiam.interaction-style.subscribe + - id: operation.order-created.publish + name: OrderCreated + interaction_style: fiam.interaction-style.publish +- id: contract.otel.messaging.Billing-Service-kafka.18363aba2a59 + kind: interface-contract + name: Observed kafka surface — Billing Service + operations: + - id: operation.otel.messaging.process-orders.v1.2e3dfcfb341c + kind: operation + name: consume + interaction_style: fiam.interaction-style.subscribe +- id: contract.otel.messaging.Order-Service-kafka.eb23fcd426e8 + kind: interface-contract + name: Observed kafka surface — Order Service + operations: + - id: operation.otel.messaging.send-orders.v1.e27097565779 + kind: operation + name: publish + interaction_style: fiam.interaction-style.publish +channels: +- id: channel.orders + kind: channel + owner: node.kafka-cluster + channel_type: fiam.channel.durable-topic + name: orders.v1 + mediation: fiam.mediation.brokered + delivery_semantics: fiam.delivery.at-least-once + ordering_scope: fiam.ordering.partition + replay: true + retention: 7d +- id: channel.otel.messaging.orders.v1.891b2277822e + kind: channel + name: orders.v1 + channel_type: fiam.channel.durable-topic + mediation: fiam.mediation.brokered + facets: + identity_tuple: + kind: messaging-channel + system: kafka + logical_broker: kafka.internal:9092 + destination: orders.v1 + zone: + - '' + - '' + - '' + - '' + - '' + owner: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad +bindings: +- id: binding.kafka.orders + contract: contract.order-events + provider_port: port.order.events + consumer_ports: + - port.billing.events + binding_profile: fiam.binding-profile.kafka + channel: channel.orders + communication_stack: + - role: fiam.stack-role.broker-protocol + term: fiam.protocol.kafka + - role: fiam.stack-role.transport + term: fiam.transport.tcp +- id: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + kind: binding + contract: contract.otel.messaging.Billing-Service-kafka.18363aba2a59 + consumer_ports: + - port.otel.messaging.Billing-Service-kafka-consumer.2375156d00c8 + operations: + - operation.otel.messaging.process-orders.v1.2e3dfcfb341c + communication_stack: + - role: fiam.stack-role.broker-protocol + term: fiam.protocol.kafka + channel: channel.otel.messaging.orders.v1.891b2277822e + facets: + identity_tuple: + kind: messaging-binding + service_node: node.otel.service.Billing-Service.d6ddce900d32 + system: kafka + destination: orders.v1 + role: consumer + zone: + - '' + - '' + - '' + - '' + - '' +- id: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + kind: binding + contract: contract.otel.messaging.Order-Service-kafka.eb23fcd426e8 + consumer_ports: + - port.otel.messaging.Order-Service-kafka-producer.998bdba5e0d9 + operations: + - operation.otel.messaging.send-orders.v1.e27097565779 + communication_stack: + - role: fiam.stack-role.broker-protocol + term: fiam.protocol.kafka + channel: channel.otel.messaging.orders.v1.891b2277822e + facets: + identity_tuple: + kind: messaging-binding + service_node: node.otel.service.Order-Service.a75279f84c2c + system: kafka + destination: orders.v1 + role: producer + zone: + - '' + - '' + - '' + - '' + - '' +interactions: +- id: interaction.consume-order-created + operation: operation.order-created.consume + binding: binding.kafka.orders + channel: channel.orders + temporal_semantics: fiam.temporal.asynchronous +- id: interaction.publish-order-created + operation: operation.order-created.publish + binding: binding.kafka.orders + channel: channel.orders + temporal_semantics: fiam.temporal.asynchronous +- id: interaction.sample.581d83f560b25eaf272c5bc3.cccccccccccccccc + kind: interaction + operation: operation.otel.messaging.send-orders.v1.e27097565779 + contract: contract.otel.messaging.Order-Service-kafka.eb23fcd426e8 + binding: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + channel: channel.otel.messaging.orders.v1.891b2277822e + interaction_style: fiam.interaction-style.publish + temporal_semantics: fiam.temporal.asynchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + producer: node.otel.service.Order-Service.a75279f84c2c + broker: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + facets: + otel_trace_id: '22222222222222222222222222222222' + otel_span_id: cccccccccccccccc + otel_span_kind: producer + instrumentation_scope: runtime-fixture + observed_service: node.otel.service.Order-Service.a75279f84c2c +- id: interaction.sample.8aaf289773e141a92dbc0b22.dddddddddddddddd + kind: interaction + operation: operation.otel.messaging.process-orders.v1.2e3dfcfb341c + contract: contract.otel.messaging.Billing-Service-kafka.18363aba2a59 + binding: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + channel: channel.otel.messaging.orders.v1.891b2277822e + interaction_style: fiam.interaction-style.subscribe + temporal_semantics: fiam.temporal.asynchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + consumer: node.otel.service.Billing-Service.d6ddce900d32 + broker: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + facets: + otel_trace_id: '33333333333333333333333333333333' + otel_span_id: dddddddddddddddd + otel_span_kind: consumer + instrumentation_scope: runtime-fixture + observed_service: node.otel.service.Billing-Service.d6ddce900d32 + otel_links: + - 22222222222222222222222222222222:cccccccccccccccc +assertions: +- id: assertion.channel-first-class + subject: channel.orders + predicate: fiam.property.mediation + value: fiam.mediation.brokered + evidence: + mode: fiam.evidence.declared + source: Kafka topology configuration + confidence: 0.98 + assertion_kind: property + polarity: asserted +- id: assertion.kafka.backed-by + assertion_kind: relation + subject: channel.orders + predicate: fiam.relation.backed-by + polarity: asserted + object_ref: resource.kafka.orders-log + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.kafka.consume-json + assertion_kind: relation + subject: interaction.consume-order-created + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.order-created + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.payload + representation: fiam.representation.json +- id: assertion.kafka.consume-reads + assertion_kind: relation + subject: interaction.consume-order-created + predicate: fiam.relation.reads-from + polarity: asserted + object_ref: resource.kafka.orders-log + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.kafka.consume-shape + assertion_kind: relation + subject: operation.order-created.consume + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.order-created + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.payload +- id: assertion.kafka.publish-appends + assertion_kind: relation + subject: interaction.publish-order-created + predicate: fiam.relation.appends-to + polarity: asserted + object_ref: resource.kafka.orders-log + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.kafka.publish-json + assertion_kind: relation + subject: interaction.publish-order-created + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.order-created + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.payload + representation: fiam.representation.json +- id: assertion.kafka.publish-shape + assertion_kind: relation + subject: operation.order-created.publish + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.order-created + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.payload +- id: assertion.otel.058fac2f700d20110ddd + assertion_kind: property + subject: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.kafka + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: attribute:messaging.system + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.system + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.0942568c089c4b5a4c27 + assertion_kind: property + subject: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:01Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: aggregate:581d83f560b25eaf272c5bc3 + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:581d83f560b25eaf272c5bc3 + aggregation_key: 581d83f560b25eaf272c5bc3 + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: &id002 + aggregation_key: 581d83f560b25eaf272c5bc3 + domain: messaging + role: producer + operation_ref: operation.otel.messaging.send-orders.v1.e27097565779 + local_node_ref: node.otel.service.Order-Service.a75279f84c2c + remote_node_ref: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + channel_ref: channel.otel.messaging.orders.v1.891b2277822e + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.0b48772bc6b526328693 + assertion_kind: property + subject: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: aggregate:8aaf289773e141a92dbc0b22 + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:8aaf289773e141a92dbc0b22 + aggregation_key: 8aaf289773e141a92dbc0b22 + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + facets: &id001 + aggregation_key: 8aaf289773e141a92dbc0b22 + domain: messaging + role: consumer + operation_ref: operation.otel.messaging.process-orders.v1.2e3dfcfb341c + local_node_ref: node.otel.service.Billing-Service.d6ddce900d32 + remote_node_ref: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + channel_ref: channel.otel.messaging.orders.v1.891b2277822e + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.105f7cafb630fba3a795 + assertion_kind: relation + subject: node.otel.service.Billing-Service.d6ddce900d32 + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: node.billing-service + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: reconcile:service-identity + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:service-identity + signals: &id003 + - service-name + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 0.92 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.1d118a7e7df17974a296 + assertion_kind: property + subject: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:02Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: aggregate:8aaf289773e141a92dbc0b22 + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:8aaf289773e141a92dbc0b22 + aggregation_key: 8aaf289773e141a92dbc0b22 + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.20383a15dfff006d4259 + assertion_kind: property + subject: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: aggregate:8aaf289773e141a92dbc0b22 + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:8aaf289773e141a92dbc0b22 + aggregation_key: 8aaf289773e141a92dbc0b22 + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.2471a4303f4bde9cf4c5 + assertion_kind: property + subject: node.otel.service.Order-Service.a75279f84c2c + predicate: fiam.property.service-name + polarity: asserted + value: Order Service + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: attribute:service.name + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.2665e1f43365babd7372 + assertion_kind: property + subject: node.otel.service.Billing-Service.d6ddce900d32 + predicate: fiam.property.service-name + polarity: asserted + value: Billing Service + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: attribute:service.name + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.2904126e3395802c8ef9 + assertion_kind: property + subject: channel.otel.messaging.orders.v1.891b2277822e + predicate: fiam.property.messaging-destination-name + polarity: asserted + value: orders.v1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: attribute:messaging.destination.name + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.destination.name + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + - trace:33333333333333333333333333333333/span:dddddddddddddddd + sample_batch_hashes: + - 5dde665d8105ea4fa4f5fc288051b63f4d995e3a0cfa0cf36b15adf87921e8d5 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.29c5a478c622c3d3247b + assertion_kind: property + subject: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:02Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: aggregate:8aaf289773e141a92dbc0b22 + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:8aaf289773e141a92dbc0b22 + aggregation_key: 8aaf289773e141a92dbc0b22 + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.3c821a82847190ec5b64 + assertion_kind: relation + subject: node.otel.service.Order-Service.a75279f84c2c + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: node.order-service + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: reconcile:service-identity + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:service-identity + signals: &id004 + - service-name + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 0.92 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.488ba561f69eb2a73cd4 + assertion_kind: property + subject: operation.otel.messaging.process-orders.v1.2e3dfcfb341c + predicate: fiam.property.messaging-system + polarity: asserted + value: kafka + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: attribute:messaging.system + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.system + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.5acbc8778a106fd34b70 + assertion_kind: property + subject: operation.otel.messaging.process-orders.v1.2e3dfcfb341c + predicate: fiam.property.messaging-operation-name + polarity: asserted + value: consume + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: attribute:messaging.operation.name + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.operation.name + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.6b173bf6db8a03ed4c7c + assertion_kind: property + subject: operation.otel.messaging.process-orders.v1.2e3dfcfb341c + predicate: fiam.property.messaging-operation-type + polarity: asserted + value: process + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: attribute:messaging.operation.type + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.operation.type + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.9a601a9d9911501f88e0 + assertion_kind: property + subject: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:01Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: aggregate:581d83f560b25eaf272c5bc3 + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:581d83f560b25eaf272c5bc3 + aggregation_key: 581d83f560b25eaf272c5bc3 + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.a51dca2be00d77d91fae + assertion_kind: property + subject: operation.otel.messaging.send-orders.v1.e27097565779 + predicate: fiam.property.messaging-operation-type + polarity: asserted + value: send + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: attribute:messaging.operation.type + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.operation.type + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.aae8ecf06a1784dda5c6 + assertion_kind: relation + subject: channel.otel.messaging.orders.v1.891b2277822e + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: channel.orders + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: reconcile:messaging + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:messaging + signals: + - destination-name + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + - trace:33333333333333333333333333333333/span:dddddddddddddddd + sample_batch_hashes: + - 5dde665d8105ea4fa4f5fc288051b63f4d995e3a0cfa0cf36b15adf87921e8d5 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.96 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.b2b5c8e23fbea5ee11be + assertion_kind: property + subject: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: aggregate:581d83f560b25eaf272c5bc3 + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:581d83f560b25eaf272c5bc3 + aggregation_key: 581d83f560b25eaf272c5bc3 + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.b406caa6cb3267597397 + assertion_kind: property + subject: operation.otel.messaging.send-orders.v1.e27097565779 + predicate: fiam.property.messaging-operation-name + polarity: asserted + value: publish + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: attribute:messaging.operation.name + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.operation.name + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.bf3fad20e85ef16edb3c + assertion_kind: property + subject: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: aggregate:8aaf289773e141a92dbc0b22 + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:8aaf289773e141a92dbc0b22 + aggregation_key: 8aaf289773e141a92dbc0b22 + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.c162387a3ed6aa897438 + assertion_kind: property + subject: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: aggregate:581d83f560b25eaf272c5bc3 + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:581d83f560b25eaf272c5bc3 + aggregation_key: 581d83f560b25eaf272c5bc3 + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.cce9983d494446f8b61f + assertion_kind: property + subject: operation.otel.messaging.send-orders.v1.e27097565779 + predicate: fiam.property.messaging-system + polarity: asserted + value: kafka + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: attribute:messaging.system + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.system + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.d7cfb566dcd3f7010951 + assertion_kind: property + subject: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.kafka + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: attribute:messaging.system + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.system + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.f7ebe90dd903ccf1ee9e + assertion_kind: property + subject: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + locator: aggregate:581d83f560b25eaf272c5bc3 + metadata: + source: real-world/otel/kafka-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:581d83f560b25eaf272c5bc3 + aggregation_key: 581d83f560b25eaf272c5bc3 + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +information_resources: +- id: resource.kafka.orders-log + kind: information-resource + owner: node.kafka-cluster + name: orders.v1 retained log + resource_kind: fiam.information-resource.append-log + resource_scope: fiam.resource-scope.concrete-collection + selectors: + - kind: fiam.resource-selector.kafka-topic-name + value: orders.v1 + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.append-only +information_shapes: +- id: shape.order-created + kind: information-shape + name: OrderCreated event payload + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.order-created-schema + kind: artifact + name: OrderCreated schema + artifact_type: fiam.artifact.schema-document + describes: shape.order-created + locator: registry://orders/OrderCreated +- id: artifact.otel.stream.kafka-runtime.otlp.4236c2e60128 + kind: artifact + name: OTLP runtime stream + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/kafka-runtime.otlp.json + facets: + format: OTLP/JSON + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + latest_batch_hash: 5dde665d8105ea4fa4f5fc288051b63f4d995e3a0cfa0cf36b15adf87921e8d5 + describes: + - interaction.sample.581d83f560b25eaf272c5bc3.cccccccccccccccc + - interaction.sample.8aaf289773e141a92dbc0b22.dddddddddddddddd +extensions: + org.fiam.catalog: + version: 0.2-draft.4 + processed_batches: + - 5dde665d8105ea4fa4f5fc288051b63f4d995e3a0cfa0cf36b15adf87921e8d5 + declared_entity_ids: + - artifact.order-created-schema + - binding.kafka.orders + - channel.orders + - contract.order-events + - interaction.consume-order-created + - interaction.publish-order-created + - node.billing-service + - node.kafka-cluster + - node.order-service + - operation.order-created.consume + - operation.order-created.publish + - port.billing.events + - port.order.events + - resource.kafka.orders-log + - shape.order-created + last_ingest_at: '2026-09-09T07:00:02Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: sample + sample_size: 3 + org.fiam.runtime_aggregates: + - id: aggregate.otel.581d83f560b25eaf272c5bc3 + domain: messaging + role: producer + operation: operation.otel.messaging.send-orders.v1.e27097565779 + binding: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + local_node: node.otel.service.Order-Service.a75279f84c2c + remote_node: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + channel: channel.otel.messaging.orders.v1.891b2277822e + resource: null + messaging_system: kafka + operation_type: send + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:01Z' + last_seen: '2026-09-09T07:00:01Z' + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + - id: aggregate.otel.8aaf289773e141a92dbc0b22 + domain: messaging + role: consumer + operation: operation.otel.messaging.process-orders.v1.2e3dfcfb341c + binding: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + local_node: node.otel.service.Billing-Service.d6ddce900d32 + remote_node: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + channel: channel.otel.messaging.orders.v1.891b2277822e + resource: null + messaging_system: kafka + operation_type: process + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:02Z' + last_seen: '2026-09-09T07:00:02Z' + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + org.fiam.runtime_topology_observations: + - id: topology.otel.messaging.abbffa57dddbdb8182df + domain: messaging + count: 1 + first_seen: '2026-09-09T07:00:01Z' + last_seen: '2026-09-09T07:00:02Z' + sample_correlations: + - 22222222222222222222222222222222:cccccccccccccccc + kind: mediated-message-flow + from: node.otel.service.Order-Service.a75279f84c2c + to: node.otel.service.Billing-Service.d6ddce900d32 + via_channel: channel.otel.messaging.orders.v1.891b2277822e + correlation: span-link + org.fiam.runtime_unresolved: [] + org.fiam.reconciliation_candidates: + - observed_ref: channel.otel.messaging.orders.v1.891b2277822e + entity_kind: channel + status: matched + candidates: + - declared_ref: channel.orders + score: 0.7 + signals: + - destination-name + - observed_ref: node.otel.service.Billing-Service.d6ddce900d32 + entity_kind: system-node + status: matched + candidates: + - declared_ref: node.billing-service + score: 0.7 + signals: *id003 + - observed_ref: node.otel.service.Order-Service.a75279f84c2c + entity_kind: system-node + status: matched + candidates: + - declared_ref: node.order-service + score: 0.7 + signals: *id004 +zones: +- id: zone.otel.unscoped + kind: zone + name: Unscoped runtime observations + zone_type: fiam.zone-type.unscoped + members: + - node.otel.service.Order-Service.a75279f84c2c + - node.otel.service.Billing-Service.d6ddce900d32 diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/petstore-http11-vs-http2.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/composite/petstore-http11-vs-http2.fiam.yaml new file mode 100644 index 0000000..ec96c4d --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/petstore-http11-vs-http2.fiam.yaml @@ -0,0 +1,753 @@ +fiam_version: '0.2' +instance: + id: model.openapi.swagger-petstore---identity-ingest-excerpt.expectation.runtime-observed + kind: model + title: OpenAPI ingest — Swagger Petstore - identity ingest excerpt + declared expectation + runtime observations + status: provisional + intent: Composite declared + runtime-observed FIAM model. Source records remain separate and are related by evidenced correspondence + assertions. +nodes: +- id: node.openapi.swagger-petstore---identity-ingest-excerpt + kind: system-node + name: Swagger Petstore - identity ingest excerpt + node_type: fiam.node-type.service +- id: node.otel.petstore3.swagger.io.swagger-petstore + kind: system-node + name: swagger-petstore + node_type: fiam.node-type.service + facets: + otel_service_namespace: petstore3.swagger.io +ports: +- id: port.openapi.swagger-petstore---identity-ingest-excerpt + owner: node.openapi.swagger-petstore---identity-ingest-excerpt + participations: + - contract: contract.openapi.swagger-petstore---identity-ingest-excerpt + mode: offers +- id: port.otel.petstore3.swagger.io.swagger-petstore.http + kind: port + owner: node.otel.petstore3.swagger.io.swagger-petstore + participations: + - contract: contract.otel.petstore3.swagger.io.swagger-petstore.http + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.openapi.swagger-petstore---identity-ingest-excerpt + kind: interface-contract + name: Swagger Petstore - identity ingest excerpt + contract_forms: + - fiam.contract-form.openapi + operations: + - id: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + kind: operation + name: Find pet by ID + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /pet/{petId} + x-openapi-operation-id: getPetById +- id: contract.otel.petstore3.swagger.io.swagger-petstore.http + kind: interface-contract + name: Observed HTTP surface — swagger-petstore + operations: + - id: operation.otel.petstore3.swagger.io.swagger-petstore.GET--api-v3-pet-petId + kind: operation + name: GET /api/v3/pet/{petId} + interaction_style: fiam.interaction-style.request-response + x-http-method: GET + x-http-route: /api/v3/pet/{petId} +endpoints: +- id: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + kind: endpoint + name: OpenAPI server 1 + address: https://petstore3.swagger.io/api/v3 + address_scheme: fiam.address-scheme.https-url +- id: endpoint.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443 + kind: endpoint + name: Observed HTTPS endpoint + address_scheme: fiam.address-scheme.https-url + address: https://petstore3.swagger.io +bindings: +- id: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + kind: binding + contract: contract.openapi.swagger-petstore---identity-ingest-excerpt + provider_port: port.openapi.swagger-petstore---identity-ingest-excerpt + endpoints: + - endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById +- id: binding.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443 + kind: binding + contract: contract.otel.petstore3.swagger.io.swagger-petstore.http + provider_port: port.otel.petstore3.swagger.io.swagger-petstore.http + endpoints: + - endpoint.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http2 + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.otel.petstore3.swagger.io.swagger-petstore.GET--api-v3-pet-petId +information_resources: +- id: resource.openapi.swagger-petstore---identity-ingest-excerpt.pet-petId + kind: information-resource + owner: node.openapi.swagger-petstore---identity-ingest-excerpt + name: /pet/{petId} + resource_kind: fiam.information-resource.api-resource-object + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /pet/{petId} +information_shapes: +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + kind: information-shape + name: Category + shape_kind: fiam.information-shape.object + facets: + openapi_component: Category +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + kind: information-shape + name: Tag + shape_kind: fiam.information-shape.object + facets: + openapi_component: Tag +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + kind: information-shape + name: Pet + shape_kind: fiam.information-shape.object + facets: + openapi_component: Pet +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + kind: information-shape + name: Pet.photoUrls + shape_kind: fiam.information-shape.collection + facets: + openapi_pointer: '#/components/schemas/Pet/properties/photoUrls' +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls-element.4eb61207 + kind: information-shape + name: Pet.photoUrls element + shape_kind: fiam.information-shape.scalar + facets: + openapi_pointer: '#/components/schemas/Pet/properties/photoUrls/items' +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + kind: information-shape + name: Pet.tags + shape_kind: fiam.information-shape.collection + facets: + openapi_pointer: '#/components/schemas/Pet/properties/tags' +artifacts: +- id: artifact.openapi.swagger-petstore---identity-ingest-excerpt + kind: artifact + name: petstore-identity-excerpt.yaml + artifact_type: fiam.artifact.api-description + describes: + - contract.openapi.swagger-petstore---identity-ingest-excerpt + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls-element.4eb61207 + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + locator: https://petstore3.swagger.io/api/v3/openapi.json + facets: + openapi_version: 3.0.4 + document_version: 1.0.27 + source_file: petstore-identity-excerpt.yaml + source_note: Normalized semantic excerpt from live Swagger Petstore 1.0.27; examples, XML metadata and unrelated paths/components + intentionally omitted. +- id: artifact.declaration.petstore-http11-expectation + kind: artifact + name: petstore-http11-expectation.yaml + artifact_type: fiam.artifact.architecture-declaration + locator: real-world/declared/petstore-http11-expectation.yaml + facets: + source_note: Controlled mismatch fixture used to exercise the Declared-vs-Observed Lens; not a claim about the public + Swagger Petstore deployment. +- id: artifact.otel.petstore-get-pet-http2.otlp + kind: artifact + name: petstore-get-pet-http2.otlp.json + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/petstore-get-pet-http2.otlp.json + facets: + format: OTLP/JSON + source_file: petstore-get-pet-http2.otlp.json + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + describes: + - interaction.otel.7E3A2A4E36B64569BBA44A91A03C3120.0F1E2D3C4B5A6978 +assertions: +- id: assertion.openapi.0001 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/category' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports + facets: + slot: category + role: fiam.shape-role.envelope-member +- id: assertion.openapi.0002 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls-element.4eb61207 + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/photoUrls/items' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports + facets: + slot: items + role: fiam.shape-role.element +- id: assertion.openapi.0003 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/photoUrls' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports + facets: + slot: photoUrls + role: fiam.shape-role.envelope-member +- id: assertion.openapi.0004 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/tags/items' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports + facets: + slot: items + role: fiam.shape-role.element +- id: assertion.openapi.0005 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/tags' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports + facets: + slot: tags + role: fiam.shape-role.envelope-member +- id: assertion.openapi.0006 + assertion_kind: property + subject: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/servers/0' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0007 + assertion_kind: property + subject: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + predicate: fiam.property.server-address + polarity: asserted + value: petstore3.swagger.io + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/servers/0/url' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0008 + assertion_kind: property + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0009 + assertion_kind: property + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.property.http-route + polarity: asserted + value: /pet/{petId} + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0010 + assertion_kind: relation + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.swagger-petstore---identity-ingest-excerpt.pet-petId + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0011 + assertion_kind: relation + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get/responses/200/content/application~1json/schema' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports + facets: + role: fiam.shape-role.response +- id: assertion.openapi.0012 + assertion_kind: relation + subject: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get/responses/200/content/application~1json/schema' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports + facets: + operation_ref: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.openapi.0013 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + evidence: + mode: fiam.evidence.inferred + source: + type: schema-structural-fingerprint + ref: schema-structural-fingerprint + locator: fingerprint:sha256:43efaa02d70c55fa422ad1c0aa4bd532aac402499711a1f450bc1fab3efec4b4 + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + left: '#/components/schemas/Category' + right: '#/components/schemas/Tag' + algorithm: normalized-openapi-schema-sha256 + observer: openapi-ingest/v0.2-draft.2 + confidence: 0.75 + stance: supports +- id: assertion.declaration.0001 + assertion_kind: property + subject: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http1.1 + evidence: + mode: fiam.evidence.declared + source: + type: architecture-declaration + ref: artifact.declaration.petstore-http11-expectation + locator: expected_protocol + metadata: + source_file: petstore-http11-expectation.yaml + observer: governed-declaration/v0.2-draft.2 + confidence: 1.0 + stance: supports +- id: assertion.otel.0001 + assertion_kind: property + subject: node.otel.petstore3.swagger.io.swagger-petstore + predicate: fiam.property.service-name + polarity: asserted + value: swagger-petstore + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + observer: otel-ingest/v0.2-draft.3 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.0002 + assertion_kind: property + subject: interaction.otel.7E3A2A4E36B64569BBA44A91A03C3120.0F1E2D3C4B5A6978 + predicate: fiam.property.otel-span-kind + polarity: asserted + value: server + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + observer: otel-ingest/v0.2-draft.3 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.0003 + assertion_kind: property + subject: node.otel.petstore3.swagger.io.swagger-petstore + predicate: fiam.property.service-namespace + polarity: asserted + value: petstore3.swagger.io + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + observer: otel-ingest/v0.2-draft.3 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.0004 + assertion_kind: property + subject: operation.otel.petstore3.swagger.io.swagger-petstore.GET--api-v3-pet-petId + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + observer: otel-ingest/v0.2-draft.3 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.0005 + assertion_kind: property + subject: operation.otel.petstore3.swagger.io.swagger-petstore.GET--api-v3-pet-petId + predicate: fiam.property.http-route + polarity: asserted + value: /api/v3/pet/{petId} + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + observer: otel-ingest/v0.2-draft.3 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.0006 + assertion_kind: property + subject: binding.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http2 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + observer: otel-ingest/v0.2-draft.3 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.0007 + assertion_kind: property + subject: binding.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443 + predicate: fiam.property.network-protocol-version + polarity: asserted + value: '2' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + observer: otel-ingest/v0.2-draft.3 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.0008 + assertion_kind: property + subject: endpoint.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443 + predicate: fiam.property.server-address + polarity: asserted + value: petstore3.swagger.io + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + observer: otel-ingest/v0.2-draft.3 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.0009 + assertion_kind: property + subject: endpoint.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443 + predicate: fiam.property.server-port + polarity: asserted + value: 443 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + observer: otel-ingest/v0.2-draft.3 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.0010 + assertion_kind: property + subject: interaction.otel.7E3A2A4E36B64569BBA44A91A03C3120.0F1E2D3C4B5A6978 + predicate: fiam.property.http-response-status-code + polarity: asserted + value: 200 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + observer: otel-ingest/v0.2-draft.3 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.0011 + assertion_kind: relation + subject: operation.otel.petstore3.swagger.io.swagger-petstore.GET--api-v3-pet-petId + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + signals: &id001 + - http-method + - http-route + - server-address + observer: otel-ingest/v0.2-draft.3 + confidence: 0.97 + stance: supports + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.0012 + assertion_kind: relation + subject: binding.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443 + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + signals: *id001 + observer: otel-ingest/v0.2-draft.3 + confidence: 0.97 + stance: supports + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.0013 + assertion_kind: relation + subject: endpoint.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443 + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + signals: *id001 + observer: otel-ingest/v0.2-draft.3 + confidence: 0.96 + stance: supports + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.0014 + assertion_kind: relation + subject: node.otel.petstore3.swagger.io.swagger-petstore + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + signals: *id001 + observer: otel-ingest/v0.2-draft.3 + confidence: 0.94 + stance: supports + observed_at: '2026-09-09T01:00:00Z' +interactions: +- id: interaction.otel.7E3A2A4E36B64569BBA44A91A03C3120.0F1E2D3C4B5A6978 + kind: interaction + operation: operation.otel.petstore3.swagger.io.swagger-petstore.GET--api-v3-pet-petId + contract: contract.otel.petstore3.swagger.io.swagger-petstore.http + binding: binding.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443 + interaction_style: fiam.interaction-style.request-response + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + responder: node.otel.petstore3.swagger.io.swagger-petstore + facets: + otel_trace_id: 7E3A2A4E36B64569BBA44A91A03C3120 + otel_span_id: 0F1E2D3C4B5A6978 + otel_span_kind: server + otel_span_name: GET /api/v3/pet/{petId} + instrumentation_scope: example.http.instrumentation + observed_service: node.otel.petstore3.swagger.io.swagger-petstore diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/petstore-http11-vs-http2.lens.md b/history/FIAM_v0.2_Draft6/real-world/composite/petstore-http11-vs-http2.lens.md new file mode 100644 index 0000000..339a6af --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/petstore-http11-vs-http2.lens.md @@ -0,0 +1,37 @@ +# fiam.lens.declared-vs-observed result + +Model: `model.openapi.swagger-petstore---identity-ingest-excerpt.expectation.runtime-observed` + +## Summary + +- **conflict:** 1 +- **exact:** 2 +- **observed-only:** 2 + +## Findings + +### exact — fiam.property.http-method +- Declared: `operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById` = `GET` +- Observed: `operation.otel.petstore3.swagger.io.swagger-petstore.GET--api-v3-pet-petId` = `GET` +- Architectural owner node: `node.openapi.swagger-petstore---identity-ingest-excerpt` (Swagger Petstore - identity ingest excerpt) + +### conflict — fiam.property.communication-protocol +- Declared: `binding.openapi.swagger-petstore---identity-ingest-excerpt.1` = `fiam.protocol.http1.1` +- Observed: `binding.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443` = `fiam.protocol.http2` +- Architectural owner node: `node.openapi.swagger-petstore---identity-ingest-excerpt` (Swagger Petstore - identity ingest excerpt) + +### observed-only — fiam.property.network-protocol-version +- Declared: `binding.openapi.swagger-petstore---identity-ingest-excerpt.1` = `None` +- Observed: `binding.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443` = `2` +- Architectural owner node: `node.openapi.swagger-petstore---identity-ingest-excerpt` (Swagger Petstore - identity ingest excerpt) + +### exact — fiam.property.server-address +- Declared: `endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1` = `petstore3.swagger.io` +- Observed: `endpoint.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443` = `petstore3.swagger.io` +- Architectural owner node: `node.openapi.swagger-petstore---identity-ingest-excerpt` (Swagger Petstore - identity ingest excerpt) + +### observed-only — fiam.property.server-port +- Declared: `endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1` = `None` +- Observed: `endpoint.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443` = `443` +- Architectural owner node: `node.openapi.swagger-petstore---identity-ingest-excerpt` (Swagger Petstore - identity ingest excerpt) + diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/petstore-http11-vs-http2.lens.yaml b/history/FIAM_v0.2_Draft6/real-world/composite/petstore-http11-vs-http2.lens.yaml new file mode 100644 index 0000000..89f07e2 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/petstore-http11-vs-http2.lens.yaml @@ -0,0 +1,141 @@ +lens: fiam.lens.declared-vs-observed +lens_version: 0.2-draft.3 +model: model.openapi.swagger-petstore---identity-ingest-excerpt.expectation.runtime-observed +summary: + pairs: 5 + findings: 5 + classifications: + conflict: 1 + exact: 2 + observed-only: 2 +findings: +- declared_ref: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + observed_ref: operation.otel.petstore3.swagger.io.swagger-petstore.GET--api-v3-pet-petId + entity_kind: operation + predicate: fiam.property.http-method + classification: exact + declared_value: GET + observed_value: GET + owner: + node_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + name: Swagger Petstore - identity ingest excerpt + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + confidence: 0.97 + declared_evidence: + - mode: fiam.evidence.declared + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get' + confidence: 1.0 + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + confidence: 1.0 +- declared_ref: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + observed_ref: binding.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443 + entity_kind: binding + predicate: fiam.property.communication-protocol + classification: conflict + declared_value: fiam.protocol.http1.1 + observed_value: fiam.protocol.http2 + owner: + node_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + name: Swagger Petstore - identity ingest excerpt + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + confidence: 0.97 + declared_evidence: + - mode: fiam.evidence.declared + type: architecture-declaration + ref: artifact.declaration.petstore-http11-expectation + locator: expected_protocol + confidence: 1.0 + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + confidence: 1.0 +- declared_ref: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + observed_ref: binding.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443 + entity_kind: binding + predicate: fiam.property.network-protocol-version + classification: observed-only + declared_value: null + observed_value: '2' + owner: + node_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + name: Swagger Petstore - identity ingest excerpt + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + confidence: 0.97 + declared_evidence: [] + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + confidence: 1.0 +- declared_ref: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + observed_ref: endpoint.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443 + entity_kind: endpoint + predicate: fiam.property.server-address + classification: exact + declared_value: petstore3.swagger.io + observed_value: petstore3.swagger.io + owner: + node_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + name: Swagger Petstore - identity ingest excerpt + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + confidence: 0.96 + declared_evidence: + - mode: fiam.evidence.declared + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/servers/0/url' + confidence: 1.0 + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + confidence: 1.0 +- declared_ref: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + observed_ref: endpoint.otel.petstore3.swagger.io.swagger-petstore.https-petstore3.swagger.io-443 + entity_kind: endpoint + predicate: fiam.property.server-port + classification: observed-only + declared_value: null + observed_value: 443 + owner: + node_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + name: Swagger Petstore - identity ingest excerpt + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + confidence: 0.96 + declared_evidence: [] + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-export + ref: artifact.otel.petstore-get-pet-http2.otlp + locator: trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + confidence: 1.0 diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/petstore-openapi-plus-otel.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/composite/petstore-openapi-plus-otel.fiam.yaml new file mode 100644 index 0000000..6b3bed9 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/petstore-openapi-plus-otel.fiam.yaml @@ -0,0 +1,1039 @@ +fiam_version: '0.2' +instance: + id: model.openapi.swagger-petstore---identity-ingest-excerpt.catalog + kind: model + title: OpenAPI ingest — Swagger Petstore - identity ingest excerpt — runtime catalog + status: provisional + intent: Incremental FIAM catalog combining declared architecture with aggregated runtime observations. +nodes: +- id: node.openapi.swagger-petstore---identity-ingest-excerpt + kind: system-node + name: Swagger Petstore - identity ingest excerpt + node_type: fiam.node-type.service +- id: node.otel.service.petstore3.swagger.io.swagger-petstore.25c13a136460 + kind: system-node + name: swagger-petstore + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: petstore3.swagger.io + service_name: swagger-petstore +ports: +- id: port.openapi.swagger-petstore---identity-ingest-excerpt + owner: node.openapi.swagger-petstore---identity-ingest-excerpt + participations: + - contract: contract.openapi.swagger-petstore---identity-ingest-excerpt + mode: offers +- id: port.otel.http.swagger-petstore.2d8c26ffc3ea + kind: port + owner: node.otel.service.petstore3.swagger.io.swagger-petstore.25c13a136460 + participations: + - contract: contract.otel.http.swagger-petstore.54cbe801bfd1 + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.openapi.swagger-petstore---identity-ingest-excerpt + kind: interface-contract + name: Swagger Petstore - identity ingest excerpt + contract_forms: + - fiam.contract-form.openapi + operations: + - id: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + kind: operation + name: Find pet by ID + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /pet/{petId} + x-openapi-operation-id: getPetById +- id: contract.otel.http.swagger-petstore.54cbe801bfd1 + kind: interface-contract + name: Observed HTTP surface — swagger-petstore + operations: + - id: operation.otel.http.GET--api-v3-pet-petId.06cf52fa83f4 + kind: operation + name: GET /api/v3/pet/{petId} + interaction_style: fiam.interaction-style.request-response + x-http-method: GET + x-http-route: /api/v3/pet/{petId} +endpoints: +- id: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + kind: endpoint + name: OpenAPI server 1 + address: https://petstore3.swagger.io/api/v3 + address_scheme: fiam.address-scheme.https-url +- id: endpoint.otel.http.petstore3.swagger.io.943bf4a41bd2 + kind: endpoint + name: petstore3.swagger.io + address_scheme: fiam.address-scheme.https-url + facets: + identity_tuple: + address: https://petstore3.swagger.io + address_scheme: fiam.address-scheme.https-url + zone: + - '' + - '' + - '' + - '' + - '' + logical_server_address: petstore3.swagger.io + address: https://petstore3.swagger.io +bindings: +- id: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + kind: binding + contract: contract.openapi.swagger-petstore---identity-ingest-excerpt + provider_port: port.openapi.swagger-petstore---identity-ingest-excerpt + endpoints: + - endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById +- id: binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97 + kind: binding + contract: contract.otel.http.swagger-petstore.54cbe801bfd1 + provider_port: port.otel.http.swagger-petstore.2d8c26ffc3ea + endpoints: + - endpoint.otel.http.petstore3.swagger.io.943bf4a41bd2 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http2 + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.otel.http.GET--api-v3-pet-petId.06cf52fa83f4 + facets: + identity_tuple: + kind: http-binding + service_node: node.otel.service.petstore3.swagger.io.swagger-petstore.25c13a136460 + server_address: petstore3.swagger.io + server_port: 443 + zone: + - '' + - '' + - '' + - '' + - '' +information_resources: +- id: resource.openapi.swagger-petstore---identity-ingest-excerpt.pet-petId + kind: information-resource + owner: node.openapi.swagger-petstore---identity-ingest-excerpt + name: /pet/{petId} + resource_kind: fiam.information-resource.api-resource-object + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /pet/{petId} +information_shapes: +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + kind: information-shape + name: Category + shape_kind: fiam.information-shape.object + facets: + openapi_component: Category +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + kind: information-shape + name: Pet + shape_kind: fiam.information-shape.object + facets: + openapi_component: Pet +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + kind: information-shape + name: Tag + shape_kind: fiam.information-shape.object + facets: + openapi_component: Tag +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls-element.4eb61207 + kind: information-shape + name: Pet.photoUrls element + shape_kind: fiam.information-shape.scalar + facets: + openapi_pointer: '#/components/schemas/Pet/properties/photoUrls/items' +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + kind: information-shape + name: Pet.photoUrls + shape_kind: fiam.information-shape.collection + facets: + openapi_pointer: '#/components/schemas/Pet/properties/photoUrls' +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + kind: information-shape + name: Pet.tags + shape_kind: fiam.information-shape.collection + facets: + openapi_pointer: '#/components/schemas/Pet/properties/tags' +artifacts: +- id: artifact.openapi.swagger-petstore---identity-ingest-excerpt + kind: artifact + name: petstore-identity-excerpt.yaml + artifact_type: fiam.artifact.api-description + describes: + - contract.openapi.swagger-petstore---identity-ingest-excerpt + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls-element.4eb61207 + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + locator: https://petstore3.swagger.io/api/v3/openapi.json + facets: + openapi_version: 3.0.4 + document_version: 1.0.27 + source_file: petstore-identity-excerpt.yaml + source_note: Normalized semantic excerpt from live Swagger Petstore 1.0.27; examples, XML metadata and unrelated paths/components + intentionally omitted. +- id: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + kind: artifact + name: OTLP runtime stream + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/petstore-get-pet-http2.otlp.json + facets: + format: OTLP/JSON + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + latest_batch_hash: 5b251b2a322be16d31fc2b685f1612bcb7b8f7fbee1c74a279d069b6161732c4 + describes: + - interaction.sample.f6aca4d2ec2da5f5bd24b489.0F1E2D3C4B5A6978 +assertions: +- id: assertion.openapi.0001 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/category' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + slot: category + role: fiam.shape-role.envelope-member +- id: assertion.openapi.0002 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls-element.4eb61207 + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/photoUrls/items' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + slot: items + role: fiam.shape-role.element +- id: assertion.openapi.0003 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/photoUrls' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + slot: photoUrls + role: fiam.shape-role.envelope-member +- id: assertion.openapi.0004 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/tags/items' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + slot: items + role: fiam.shape-role.element +- id: assertion.openapi.0005 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/tags' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + slot: tags + role: fiam.shape-role.envelope-member +- id: assertion.openapi.0006 + assertion_kind: property + subject: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/servers/0' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0007 + assertion_kind: property + subject: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + predicate: fiam.property.server-address + polarity: asserted + value: petstore3.swagger.io + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/servers/0/url' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0008 + assertion_kind: property + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0009 + assertion_kind: property + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.property.http-route + polarity: asserted + value: /pet/{petId} + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0010 + assertion_kind: relation + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.swagger-petstore---identity-ingest-excerpt.pet-petId + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0011 + assertion_kind: relation + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get/responses/200/content/application~1json/schema' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + role: fiam.shape-role.response +- id: assertion.openapi.0012 + assertion_kind: relation + subject: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get/responses/200/content/application~1json/schema' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + operation_ref: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.openapi.0013 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + evidence: + mode: fiam.evidence.inferred + source: + type: schema-structural-fingerprint + ref: schema-structural-fingerprint + locator: fingerprint:sha256:43efaa02d70c55fa422ad1c0aa4bd532aac402499711a1f450bc1fab3efec4b4 + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + left: '#/components/schemas/Category' + right: '#/components/schemas/Tag' + algorithm: normalized-openapi-schema-sha256 + observer: openapi-ingest/v0.2-draft.4 + confidence: 0.75 + stance: supports +- id: assertion.otel.16f147bdd9999831cb01 + assertion_kind: property + subject: endpoint.otel.http.petstore3.swagger.io.943bf4a41bd2 + predicate: fiam.property.server-address + polarity: asserted + value: petstore3.swagger.io + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: attribute:server.address + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:server.address + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.1b96a634e434b4917c7c + assertion_kind: relation + subject: node.otel.service.petstore3.swagger.io.swagger-petstore.25c13a136460 + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: reconcile:http + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:http + signals: &id001 + - http-method + - http-route-exact + - server-address + score: 1.0 + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.94 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.2d67c52ae9f110cd2ee1 + assertion_kind: property + subject: operation.otel.http.GET--api-v3-pet-petId.06cf52fa83f4 + predicate: fiam.property.http-route + polarity: asserted + value: /api/v3/pet/{petId} + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: attribute:http.route + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.route + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.3a4db6ee91268ef5d9f9 + assertion_kind: property + subject: binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97 + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T01:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: aggregate:f6aca4d2ec2da5f5bd24b489 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:f6aca4d2ec2da5f5bd24b489 + aggregation_key: f6aca4d2ec2da5f5bd24b489 + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: &id002 + aggregation_key: f6aca4d2ec2da5f5bd24b489 + domain: http + role: server + operation_ref: operation.otel.http.GET--api-v3-pet-petId.06cf52fa83f4 + local_node_ref: node.otel.service.petstore3.swagger.io.swagger-petstore.25c13a136460 + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.3df6f40fdae3bb2fad5d + assertion_kind: property + subject: operation.otel.http.GET--api-v3-pet-petId.06cf52fa83f4 + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: attribute:http.request.method + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.request.method + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.58c30a6371a6c8d18707 + assertion_kind: property + subject: node.otel.service.petstore3.swagger.io.swagger-petstore.25c13a136460 + predicate: fiam.property.service-namespace + polarity: asserted + value: petstore3.swagger.io + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: attribute:service.namespace + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.namespace + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.61ee643dcd4ae2f35c1f + assertion_kind: relation + subject: endpoint.otel.http.petstore3.swagger.io.943bf4a41bd2 + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: reconcile:http + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:http + signals: *id001 + score: 1.0 + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.95 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.65f037d1b849a5deb24b + assertion_kind: property + subject: binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97 + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: aggregate:f6aca4d2ec2da5f5bd24b489 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:f6aca4d2ec2da5f5bd24b489 + aggregation_key: f6aca4d2ec2da5f5bd24b489 + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.8dab97bea0366143d688 + assertion_kind: property + subject: binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97 + predicate: fiam.property.network-protocol-version + polarity: asserted + value: '2' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: attribute:network.protocol.version + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:network.protocol.version + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.94ebba5afc8db554f52f + assertion_kind: property + subject: binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97 + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: aggregate:f6aca4d2ec2da5f5bd24b489 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:f6aca4d2ec2da5f5bd24b489 + aggregation_key: f6aca4d2ec2da5f5bd24b489 + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.a7000cafd39483a9ae54 + assertion_kind: relation + subject: operation.otel.http.GET--api-v3-pet-petId.06cf52fa83f4 + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: reconcile:http + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:http + signals: *id001 + score: 1.0 + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.97 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.c16f4fe5d33d669cef5b + assertion_kind: property + subject: binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http2 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: attribute:network.protocol.version + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:network.protocol.version + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.c39aee943e445c5b5bb2 + assertion_kind: property + subject: node.otel.service.petstore3.swagger.io.swagger-petstore.25c13a136460 + predicate: fiam.property.service-name + polarity: asserted + value: swagger-petstore + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: attribute:service.name + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.ce45dcb72eb26f2c19a0 + assertion_kind: property + subject: binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97 + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T01:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: aggregate:f6aca4d2ec2da5f5bd24b489 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:f6aca4d2ec2da5f5bd24b489 + aggregation_key: f6aca4d2ec2da5f5bd24b489 + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.dfa6f7f01d962e73b3d0 + assertion_kind: property + subject: interaction.sample.f6aca4d2ec2da5f5bd24b489.0F1E2D3C4B5A6978 + predicate: fiam.property.http-response-status-code + polarity: asserted + value: 200 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: attribute:http.response.status_code + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.response.status_code + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.f3415412240b68ce80e8 + assertion_kind: property + subject: binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97 + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: aggregate:f6aca4d2ec2da5f5bd24b489 + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:f6aca4d2ec2da5f5bd24b489 + aggregation_key: f6aca4d2ec2da5f5bd24b489 + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.fc3df934322d8fddcd9d + assertion_kind: relation + subject: binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97 + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: reconcile:http + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:http + signals: *id001 + score: 1.0 + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.96 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.fc7a428bfb9170e4c495 + assertion_kind: property + subject: endpoint.otel.http.petstore3.swagger.io.943bf4a41bd2 + predicate: fiam.property.server-port + polarity: asserted + value: 443 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: attribute:server.port + metadata: + source: real-world/otel/petstore-get-pet-http2.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:server.port + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +extensions: + org.fiam.catalog: + version: 0.2-draft.4 + processed_batches: + - 5b251b2a322be16d31fc2b685f1612bcb7b8f7fbee1c74a279d069b6161732c4 + declared_entity_ids: + - artifact.openapi.swagger-petstore---identity-ingest-excerpt + - binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + - contract.openapi.swagger-petstore---identity-ingest-excerpt + - endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + - node.openapi.swagger-petstore---identity-ingest-excerpt + - operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + - port.openapi.swagger-petstore---identity-ingest-excerpt + - resource.openapi.swagger-petstore---identity-ingest-excerpt.pet-petId + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls-element.4eb61207 + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + last_ingest_at: '2026-09-09T01:00:00Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: sample + sample_size: 3 + org.fiam.runtime_aggregates: + - id: aggregate.otel.f6aca4d2ec2da5f5bd24b489 + domain: http + role: server + operation: operation.otel.http.GET--api-v3-pet-petId.06cf52fa83f4 + binding: binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97 + local_node: node.otel.service.petstore3.swagger.io.swagger-petstore.25c13a136460 + remote_node: null + channel: null + resource: null + method: GET + route: /api/v3/pet/{petId} + count: 1 + error_count: 0 + first_seen: '2026-09-09T01:00:00Z' + last_seen: '2026-09-09T01:00:00Z' + sample_spans: + - trace:7E3A2A4E36B64569BBA44A91A03C3120/span:0F1E2D3C4B5A6978 + org.fiam.runtime_topology_observations: [] + org.fiam.runtime_unresolved: [] + org.fiam.reconciliation_candidates: + - observed_ref: operation.otel.http.GET--api-v3-pet-petId.06cf52fa83f4 + entity_kind: operation + status: matched + candidates: + - declared_ref: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + binding_ref: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + endpoint_ref: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + node_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + score: 1.0 + signals: *id001 +zones: +- id: zone.otel.unscoped + kind: zone + name: Unscoped runtime observations + zone_type: fiam.zone-type.unscoped + members: + - node.otel.service.petstore3.swagger.io.swagger-petstore.25c13a136460 +interactions: +- id: interaction.sample.f6aca4d2ec2da5f5bd24b489.0F1E2D3C4B5A6978 + kind: interaction + operation: operation.otel.http.GET--api-v3-pet-petId.06cf52fa83f4 + contract: contract.otel.http.swagger-petstore.54cbe801bfd1 + binding: binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97 + interaction_style: fiam.interaction-style.request-response + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + responder: node.otel.service.petstore3.swagger.io.swagger-petstore.25c13a136460 + facets: + otel_trace_id: 7E3A2A4E36B64569BBA44A91A03C3120 + otel_span_id: 0F1E2D3C4B5A6978 + otel_span_kind: server + instrumentation_scope: example.http.instrumentation + observed_service: node.otel.service.petstore3.swagger.io.swagger-petstore.25c13a136460 diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/petstore-openapi-plus-otel.lens.md b/history/FIAM_v0.2_Draft6/real-world/composite/petstore-openapi-plus-otel.lens.md new file mode 100644 index 0000000..97b9097 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/petstore-openapi-plus-otel.lens.md @@ -0,0 +1,44 @@ +# fiam.lens.declared-vs-observed result + +Model: `model.openapi.swagger-petstore---identity-ingest-excerpt.catalog` + +## Property comparison + +- **compatible-refinement:** 1 +- **exact:** 2 +- **observed-only:** 2 + +## Coverage + +- **observed:** 1 + +## Property findings + +### exact — fiam.property.server-address +- Declared: `endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1` = `petstore3.swagger.io` +- Observed: `endpoint.otel.http.petstore3.swagger.io.943bf4a41bd2` = `petstore3.swagger.io` +- Architectural owner: `node.openapi.swagger-petstore---identity-ingest-excerpt` (Swagger Petstore - identity ingest excerpt) + +### observed-only — fiam.property.server-port +- Declared: `endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1` = `None` +- Observed: `endpoint.otel.http.petstore3.swagger.io.943bf4a41bd2` = `443` +- Architectural owner: `node.openapi.swagger-petstore---identity-ingest-excerpt` (Swagger Petstore - identity ingest excerpt) + +### exact — fiam.property.http-method +- Declared: `operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById` = `GET` +- Observed: `operation.otel.http.GET--api-v3-pet-petId.06cf52fa83f4` = `GET` +- Architectural owner: `node.openapi.swagger-petstore---identity-ingest-excerpt` (Swagger Petstore - identity ingest excerpt) + +### compatible-refinement — fiam.property.communication-protocol +- Declared: `binding.openapi.swagger-petstore---identity-ingest-excerpt.1` = `fiam.protocol.http` +- Observed: `binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97` = `fiam.protocol.http2` +- Architectural owner: `node.openapi.swagger-petstore---identity-ingest-excerpt` (Swagger Petstore - identity ingest excerpt) + +### observed-only — fiam.property.network-protocol-version +- Declared: `binding.openapi.swagger-petstore---identity-ingest-excerpt.1` = `None` +- Observed: `binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97` = `2` +- Architectural owner: `node.openapi.swagger-petstore---identity-ingest-excerpt` (Swagger Petstore - identity ingest excerpt) + +## Coverage findings + +- **observed** operation: `operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById` diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/petstore-openapi-plus-otel.lens.yaml b/history/FIAM_v0.2_Draft6/real-world/composite/petstore-openapi-plus-otel.lens.yaml new file mode 100644 index 0000000..876168f --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/petstore-openapi-plus-otel.lens.yaml @@ -0,0 +1,164 @@ +lens: fiam.lens.declared-vs-observed +lens_version: 0.2-draft.4 +model: model.openapi.swagger-petstore---identity-ingest-excerpt.catalog +summary: + pairs: 5 + property_findings: 5 + classifications: + compatible-refinement: 1 + exact: 2 + observed-only: 2 + coverage: + observed: 1 +findings: +- declared_ref: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + observed_ref: endpoint.otel.http.petstore3.swagger.io.943bf4a41bd2 + entity_kind: endpoint + predicate: fiam.property.server-address + classification: exact + declared_value: petstore3.swagger.io + observed_value: petstore3.swagger.io + owner: + node_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + name: Swagger Petstore - identity ingest excerpt + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: reconcile:http + confidence: 0.95 + declared_evidence: + - mode: fiam.evidence.declared + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/servers/0/url' + confidence: 1.0 + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-stream + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: attribute:server.address + confidence: 1.0 +- declared_ref: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + observed_ref: endpoint.otel.http.petstore3.swagger.io.943bf4a41bd2 + entity_kind: endpoint + predicate: fiam.property.server-port + classification: observed-only + declared_value: null + observed_value: 443 + owner: + node_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + name: Swagger Petstore - identity ingest excerpt + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: reconcile:http + confidence: 0.95 + declared_evidence: [] + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-stream + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: attribute:server.port + confidence: 1.0 +- declared_ref: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + observed_ref: operation.otel.http.GET--api-v3-pet-petId.06cf52fa83f4 + entity_kind: operation + predicate: fiam.property.http-method + classification: exact + declared_value: GET + observed_value: GET + owner: + node_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + name: Swagger Petstore - identity ingest excerpt + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: reconcile:http + confidence: 0.97 + declared_evidence: + - mode: fiam.evidence.declared + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get' + confidence: 1.0 + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-stream + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: attribute:http.request.method + confidence: 1.0 +- declared_ref: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + observed_ref: binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97 + entity_kind: binding + predicate: fiam.property.communication-protocol + classification: compatible-refinement + declared_value: fiam.protocol.http + observed_value: fiam.protocol.http2 + owner: + node_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + name: Swagger Petstore - identity ingest excerpt + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: reconcile:http + confidence: 0.96 + declared_evidence: + - mode: fiam.evidence.declared + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/servers/0' + confidence: 1.0 + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-stream + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: attribute:network.protocol.version + confidence: 1.0 +- declared_ref: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + observed_ref: binding.otel.http.swagger-petstore-petstore3.swagger.io.197130b60b97 + entity_kind: binding + predicate: fiam.property.network-protocol-version + classification: observed-only + declared_value: null + observed_value: '2' + owner: + node_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + name: Swagger Petstore - identity ingest excerpt + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: reconcile:http + confidence: 0.96 + declared_evidence: [] + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-stream + ref: artifact.otel.stream.petstore-get-pet-http2.otlp.272fc480612d + locator: attribute:network.protocol.version + confidence: 1.0 +coverage_findings: +- entity_kind: operation + classification: observed + declared_ref: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + owner: + node_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + name: Swagger Petstore - identity ingest excerpt +reconciliation_candidates: +- observed_ref: operation.otel.http.GET--api-v3-pet-petId.06cf52fa83f4 + entity_kind: operation + status: matched + candidates: + - declared_ref: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + binding_ref: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + endpoint_ref: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + node_ref: node.openapi.swagger-petstore---identity-ingest-excerpt + score: 1.0 + signals: + - http-method + - http-route-exact + - server-address diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/postgres-declared-plus-runtime.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/composite/postgres-declared-plus-runtime.fiam.yaml new file mode 100644 index 0000000..9877748 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/postgres-declared-plus-runtime.fiam.yaml @@ -0,0 +1,1293 @@ +fiam_version: '0.2' +instance: + id: specimen.resource.shared-postgresql-table.catalog + kind: model + title: Shared PostgreSQL table integration — runtime catalog + status: provisional + intent: Incremental FIAM catalog combining declared architecture with aggregated runtime observations. +nodes: +- id: node.app-a + kind: system-node + name: Application A + node_type: fiam.node-type.service +- id: node.app-b + kind: system-node + name: Application B + node_type: fiam.node-type.service +- id: node.otel.database.postgresql.db.internal:5432.03855f9892af + kind: system-node + name: postgresql at db.internal:5432 + node_type: fiam.node-type.database + facets: + identity_tuple: + kind: database + system: postgresql + logical_address: db.internal:5432 + zone: + - '' + - '' + - '' + - '' + - '' +- id: node.otel.service.Application-A.cfbc55b42036 + kind: system-node + name: Application A + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: Application A +- id: node.otel.service.Application-B.e415ac492d2e + kind: system-node + name: Application B + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: Application B +- id: node.postgres + kind: system-node + name: PostgreSQL + node_type: fiam.node-type.database +ports: +- id: port.app-a.pg + owner: node.app-a + participations: + - contract: contract.sql + mode: requires +- id: port.app-b.pg + owner: node.app-b + participations: + - contract: contract.sql + mode: requires +- id: port.otel.db.Application-A-postgresql.aa791c002404 + kind: port + owner: node.otel.service.Application-A.cfbc55b42036 + participations: + - contract: contract.otel.db.Application-A-postgresql.d8124174d2c9 + mode: requires + roles: + - fiam.role.database-client +- id: port.otel.db.Application-B-postgresql.655f3e58fb43 + kind: port + owner: node.otel.service.Application-B.e415ac492d2e + participations: + - contract: contract.otel.db.Application-B-postgresql.f40dfb73e126 + mode: requires + roles: + - fiam.role.database-client +- id: port.pg.provider + owner: node.postgres + participations: + - contract: contract.sql + mode: offers +contracts: +- id: contract.otel.db.Application-A-postgresql.d8124174d2c9 + kind: interface-contract + name: Observed postgresql client surface — Application A + operations: + - id: operation.otel.db.INSERT-public.integration_exchange.92bf26c60bf6 + kind: operation + name: INSERT + interaction_style: fiam.interaction-style.command + effect: fiam.effect.write +- id: contract.otel.db.Application-B-postgresql.f40dfb73e126 + kind: interface-contract + name: Observed postgresql client surface — Application B + operations: + - id: operation.otel.db.SELECT-public.integration_exchange.2b77ce48158e + kind: operation + name: SELECT + interaction_style: fiam.interaction-style.query + effect: fiam.effect.read +- id: contract.sql + kind: interface-contract + purpose: + - fiam.purpose.transactional-data-access + operations: + - id: operation.sql.read + name: SELECT + effect: fiam.effect.read + - id: operation.sql.write + name: INSERT/UPDATE + effect: fiam.effect.write +endpoints: +- id: endpoint.otel.db.db.internal:5432.f2c4974a69d0 + kind: endpoint + name: db.internal:5432 + address_scheme: fiam.address-scheme.host-port + facets: + identity_tuple: + address: db.internal:5432 + address_scheme: fiam.address-scheme.host-port + zone: + - '' + - '' + - '' + - '' + - '' + logical_server_address: db.internal + address: db.internal:5432 +- id: endpoint.pg + kind: endpoint + address: db.internal:5432 +bindings: +- id: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + kind: binding + contract: contract.otel.db.Application-A-postgresql.d8124174d2c9 + consumer_ports: + - port.otel.db.Application-A-postgresql.aa791c002404 + operations: + - operation.otel.db.INSERT-public.integration_exchange.92bf26c60bf6 + communication_stack: + - role: fiam.stack-role.database-protocol + term: fiam.protocol.postgresql-frontend-backend + facets: + identity_tuple: + kind: database-binding + service_node: node.otel.service.Application-A.cfbc55b42036 + system: postgresql + logical_address: db.internal:5432 + zone: + - '' + - '' + - '' + - '' + - '' + endpoints: + - endpoint.otel.db.db.internal:5432.f2c4974a69d0 +- id: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + kind: binding + contract: contract.otel.db.Application-B-postgresql.f40dfb73e126 + consumer_ports: + - port.otel.db.Application-B-postgresql.655f3e58fb43 + operations: + - operation.otel.db.SELECT-public.integration_exchange.2b77ce48158e + communication_stack: + - role: fiam.stack-role.database-protocol + term: fiam.protocol.postgresql-frontend-backend + facets: + identity_tuple: + kind: database-binding + service_node: node.otel.service.Application-B.e415ac492d2e + system: postgresql + logical_address: db.internal:5432 + zone: + - '' + - '' + - '' + - '' + - '' + endpoints: + - endpoint.otel.db.db.internal:5432.f2c4974a69d0 +- id: binding.pg + contract: contract.sql + provider_port: port.pg.provider + consumer_ports: + - port.app-a.pg + - port.app-b.pg + endpoints: + - endpoint.pg + communication_stack: + - role: fiam.stack-role.database-protocol + term: fiam.protocol.postgresql-frontend-backend + - role: fiam.stack-role.transport + term: fiam.transport.tcp +information_resources: +- id: resource.otel.db.public.integration_exchange.84bc7a7ef21d + kind: information-resource + name: public.integration_exchange + resource_kind: fiam.information-resource.relational-table + resource_scope: fiam.resource-scope.concrete-collection + selectors: + - kind: fiam.resource-selector.sql-qualified-name + value: public.integration_exchange + facets: + identity_tuple: + kind: database-resource + system: postgresql + logical_server: db.internal:5432 + namespace: integration + collection: public.integration_exchange + zone: + - '' + - '' + - '' + - '' + - '' + owner: node.otel.database.postgresql.db.internal:5432.03855f9892af +- id: resource.pg.exchange + kind: information-resource + name: public.integration_exchange + resource_kind: fiam.information-resource.relational-table + resource_scope: fiam.resource-scope.shared-state + owner: node.postgres + selectors: + - kind: fiam.resource-selector.sql-qualified-name + value: public.integration_exchange + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +interactions: +- id: interaction.app-a.write + kind: interaction + operation: operation.sql.write + binding: binding.pg +- id: interaction.app-b.read + kind: interaction + operation: operation.sql.read + binding: binding.pg +- id: interaction.sample.201134bc52a0f40f21e5656a.eeeeeeeeeeeeeeee + kind: interaction + operation: operation.otel.db.INSERT-public.integration_exchange.92bf26c60bf6 + contract: contract.otel.db.Application-A-postgresql.d8124174d2c9 + binding: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + interaction_style: fiam.interaction-style.command + temporal_semantics: fiam.temporal.synchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + initiator: node.otel.service.Application-A.cfbc55b42036 + responder: node.otel.database.postgresql.db.internal:5432.03855f9892af + facets: + otel_trace_id: '44444444444444444444444444444444' + otel_span_id: eeeeeeeeeeeeeeee + otel_span_kind: client + instrumentation_scope: runtime-fixture + observed_service: node.otel.service.Application-A.cfbc55b42036 +- id: interaction.sample.508461318135f08b1d916347.ffffffffffffffff + kind: interaction + operation: operation.otel.db.SELECT-public.integration_exchange.2b77ce48158e + contract: contract.otel.db.Application-B-postgresql.f40dfb73e126 + binding: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + interaction_style: fiam.interaction-style.query + temporal_semantics: fiam.temporal.synchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + initiator: node.otel.service.Application-B.e415ac492d2e + responder: node.otel.database.postgresql.db.internal:5432.03855f9892af + facets: + otel_trace_id: '55555555555555555555555555555555' + otel_span_id: ffffffffffffffff + otel_span_kind: client + instrumentation_scope: runtime-fixture + observed_service: node.otel.service.Application-B.e415ac492d2e +assertions: +- id: assertion.app-a.write-table + assertion_kind: relation + subject: interaction.app-a.write + predicate: fiam.relation.writes-to + polarity: asserted + object_ref: resource.pg.exchange + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.app-b.read-table + assertion_kind: relation + subject: interaction.app-b.read + predicate: fiam.relation.reads-from + polarity: asserted + object_ref: resource.pg.exchange + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.otel.076e17e9609942ef39ea + assertion_kind: relation + subject: operation.otel.db.INSERT-public.integration_exchange.92bf26c60bf6 + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.otel.db.public.integration_exchange.84bc7a7ef21d + evidence: + mode: fiam.evidence.inferred + source: + type: database-resource-mapping + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: attribute:db.collection.name + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.collection.name + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 0.92 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.08dc812b4690f70d2929 + assertion_kind: property + subject: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:03Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: aggregate:201134bc52a0f40f21e5656a + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:201134bc52a0f40f21e5656a + aggregation_key: 201134bc52a0f40f21e5656a + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + facets: &id001 + aggregation_key: 201134bc52a0f40f21e5656a + domain: database + role: client + operation_ref: operation.otel.db.INSERT-public.integration_exchange.92bf26c60bf6 + local_node_ref: node.otel.service.Application-A.cfbc55b42036 + remote_node_ref: node.otel.database.postgresql.db.internal:5432.03855f9892af + resource_ref: resource.otel.db.public.integration_exchange.84bc7a7ef21d + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.1c820c4ec27c5909e792 + assertion_kind: property + subject: resource.otel.db.public.integration_exchange.84bc7a7ef21d + predicate: fiam.property.database-namespace + polarity: asserted + value: integration + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: attribute:db.namespace + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.namespace + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + - trace:55555555555555555555555555555555/span:ffffffffffffffff + sample_batch_hashes: + - 5caf942874298c0c6561692829ef7e02987bb61ca9e97bdc3d01781143d2d3fd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.1ca8d16998e960371e13 + assertion_kind: property + subject: operation.otel.db.SELECT-public.integration_exchange.2b77ce48158e + predicate: fiam.property.database-operation-name + polarity: asserted + value: SELECT + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: attribute:db.operation.name + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.operation.name + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.1cd682abedc6075275e0 + assertion_kind: property + subject: resource.otel.db.public.integration_exchange.84bc7a7ef21d + predicate: fiam.property.database-collection-name + polarity: asserted + value: public.integration_exchange + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: attribute:db.collection.name + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.collection.name + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + - trace:55555555555555555555555555555555/span:ffffffffffffffff + sample_batch_hashes: + - 5caf942874298c0c6561692829ef7e02987bb61ca9e97bdc3d01781143d2d3fd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.1f5766edd4ccf570c8ff + assertion_kind: property + subject: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:03Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: aggregate:201134bc52a0f40f21e5656a + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:201134bc52a0f40f21e5656a + aggregation_key: 201134bc52a0f40f21e5656a + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.2d09d71c7673ce21d6db + assertion_kind: property + subject: node.otel.service.Application-A.cfbc55b42036 + predicate: fiam.property.service-name + polarity: asserted + value: Application A + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: attribute:service.name + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.32d894c7e2c12b287e53 + assertion_kind: property + subject: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:04Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: aggregate:508461318135f08b1d916347 + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:508461318135f08b1d916347 + aggregation_key: 508461318135f08b1d916347 + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + facets: &id002 + aggregation_key: 508461318135f08b1d916347 + domain: database + role: client + operation_ref: operation.otel.db.SELECT-public.integration_exchange.2b77ce48158e + local_node_ref: node.otel.service.Application-B.e415ac492d2e + remote_node_ref: node.otel.database.postgresql.db.internal:5432.03855f9892af + resource_ref: resource.otel.db.public.integration_exchange.84bc7a7ef21d + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.370ca75692d9390b726d + assertion_kind: relation + subject: interaction.sample.508461318135f08b1d916347.ffffffffffffffff + predicate: fiam.relation.reads-from + polarity: asserted + object_ref: resource.otel.db.public.integration_exchange.84bc7a7ef21d + evidence: + mode: fiam.evidence.inferred + source: + type: database-operation-semantics + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: inference:database-operation-effect + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: inference:database-operation-effect + db.operation.name: SELECT + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 0.97 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.4bf94821972e913192a4 + assertion_kind: property + subject: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: aggregate:508461318135f08b1d916347 + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:508461318135f08b1d916347 + aggregation_key: 508461318135f08b1d916347 + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.5fb409ee4ea4c44f644f + assertion_kind: property + subject: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.postgresql-frontend-backend + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: attribute:db.system.name + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.system.name + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.664d49f369e7d24aedfa + assertion_kind: property + subject: node.otel.service.Application-B.e415ac492d2e + predicate: fiam.property.service-name + polarity: asserted + value: Application B + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: attribute:service.name + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.6c231f1fc419eda4896b + assertion_kind: property + subject: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: aggregate:201134bc52a0f40f21e5656a + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:201134bc52a0f40f21e5656a + aggregation_key: 201134bc52a0f40f21e5656a + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.7fa714481a8ca9e549b4 + assertion_kind: relation + subject: node.otel.service.Application-B.e415ac492d2e + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: node.app-b + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: reconcile:service-identity + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:service-identity + signals: &id004 + - service-name + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 0.92 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.8652d9d1b886ff9e8bf3 + assertion_kind: property + subject: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:04Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: aggregate:508461318135f08b1d916347 + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:508461318135f08b1d916347 + aggregation_key: 508461318135f08b1d916347 + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.86d71a04d26ead055b8b + assertion_kind: property + subject: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + predicate: fiam.property.database-system-name + polarity: asserted + value: postgresql + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: attribute:db.system.name + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.system.name + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.88937c2b701ad7fcb35f + assertion_kind: property + subject: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: aggregate:508461318135f08b1d916347 + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:508461318135f08b1d916347 + aggregation_key: 508461318135f08b1d916347 + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.9016b0861072359b9854 + assertion_kind: property + subject: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: aggregate:508461318135f08b1d916347 + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:508461318135f08b1d916347 + aggregation_key: 508461318135f08b1d916347 + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.b29c029d95086f3dd029 + assertion_kind: property + subject: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: aggregate:201134bc52a0f40f21e5656a + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:201134bc52a0f40f21e5656a + aggregation_key: 201134bc52a0f40f21e5656a + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.b3713db26c560c3ee9d5 + assertion_kind: property + subject: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + predicate: fiam.property.database-system-name + polarity: asserted + value: postgresql + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: attribute:db.system.name + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.system.name + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.b8b88b338bdbcf224bcf + assertion_kind: relation + subject: resource.otel.db.public.integration_exchange.84bc7a7ef21d + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: resource.pg.exchange + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: reconcile:database + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:database + signals: + - collection-name + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + - trace:55555555555555555555555555555555/span:ffffffffffffffff + sample_batch_hashes: + - 5caf942874298c0c6561692829ef7e02987bb61ca9e97bdc3d01781143d2d3fd + observer: otel-ingest/v0.2-draft.4 + confidence: 0.96 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.c9e19d3908d56afb37cf + assertion_kind: relation + subject: operation.otel.db.SELECT-public.integration_exchange.2b77ce48158e + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.otel.db.public.integration_exchange.84bc7a7ef21d + evidence: + mode: fiam.evidence.inferred + source: + type: database-resource-mapping + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: attribute:db.collection.name + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.collection.name + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 0.92 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.da953652e040b330be45 + assertion_kind: relation + subject: interaction.sample.201134bc52a0f40f21e5656a.eeeeeeeeeeeeeeee + predicate: fiam.relation.writes-to + polarity: asserted + object_ref: resource.otel.db.public.integration_exchange.84bc7a7ef21d + evidence: + mode: fiam.evidence.inferred + source: + type: database-operation-semantics + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: inference:database-operation-effect + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: inference:database-operation-effect + db.operation.name: INSERT + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 0.97 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.dc6aa9632189ad6eb6d3 + assertion_kind: property + subject: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.postgresql-frontend-backend + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: attribute:db.system.name + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.system.name + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.e15a0ff0385cd28589e0 + assertion_kind: relation + subject: node.otel.service.Application-A.cfbc55b42036 + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: node.app-a + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: reconcile:service-identity + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:service-identity + signals: &id003 + - service-name + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 0.92 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.ec2eaad15d9e0f29b7ce + assertion_kind: property + subject: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: aggregate:201134bc52a0f40f21e5656a + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:201134bc52a0f40f21e5656a + aggregation_key: 201134bc52a0f40f21e5656a + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.fa3009f24f9b5306bdd3 + assertion_kind: property + subject: operation.otel.db.INSERT-public.integration_exchange.92bf26c60bf6 + predicate: fiam.property.database-operation-name + polarity: asserted + value: INSERT + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + locator: attribute:db.operation.name + metadata: + source: real-world/otel/postgres-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.operation.name + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.pg.collection-element + assertion_kind: relation + subject: shape.pg.exchange-table + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.pg.exchange-row + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.element + slot: row +- id: assertion.pg.read-produces + assertion_kind: relation + subject: interaction.app-b.read + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.pg.exchange-row + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.sql-row +- id: assertion.pg.table-conforms + assertion_kind: relation + subject: resource.pg.exchange + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.pg.exchange-table + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.pg.table-element + assertion_kind: relation + subject: resource.pg.exchange + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.pg.exchange-row + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.element + slot: row +- id: assertion.pg.write-accepts + assertion_kind: relation + subject: interaction.app-a.write + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.pg.exchange-row + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.request + representation: fiam.representation.sql-row +x-references: +- https://www.postgresql.org/docs/current/ddl-basics.html +- https://www.postgresql.org/docs/current/infoschema-tables.html +information_shapes: +- id: shape.pg.exchange-row + kind: information-shape + name: integration_exchange row + shape_kind: fiam.information-shape.object +- id: shape.pg.exchange-table + kind: information-shape + name: integration_exchange collection + shape_kind: fiam.information-shape.collection +artifacts: +- id: artifact.otel.stream.postgres-runtime.otlp.7a0859b8db91 + kind: artifact + name: OTLP runtime stream + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/postgres-runtime.otlp.json + facets: + format: OTLP/JSON + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + latest_batch_hash: 5caf942874298c0c6561692829ef7e02987bb61ca9e97bdc3d01781143d2d3fd + describes: + - interaction.sample.201134bc52a0f40f21e5656a.eeeeeeeeeeeeeeee + - interaction.sample.508461318135f08b1d916347.ffffffffffffffff +- id: artifact.pg.exchange-ddl + kind: artifact + name: integration_exchange DDL + artifact_type: fiam.artifact.sql-ddl + describes: + - resource.pg.exchange + - shape.pg.exchange-table + - shape.pg.exchange-row + locator: db://public.integration_exchange/ddl +extensions: + org.fiam.catalog: + version: 0.2-draft.4 + processed_batches: + - 5caf942874298c0c6561692829ef7e02987bb61ca9e97bdc3d01781143d2d3fd + declared_entity_ids: + - artifact.pg.exchange-ddl + - binding.pg + - contract.sql + - endpoint.pg + - interaction.app-a.write + - interaction.app-b.read + - node.app-a + - node.app-b + - node.postgres + - operation.sql.read + - operation.sql.write + - port.app-a.pg + - port.app-b.pg + - port.pg.provider + - resource.pg.exchange + - shape.pg.exchange-row + - shape.pg.exchange-table + last_ingest_at: '2026-09-09T07:00:04Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: sample + sample_size: 3 + org.fiam.runtime_aggregates: + - id: aggregate.otel.201134bc52a0f40f21e5656a + domain: database + role: client + operation: operation.otel.db.INSERT-public.integration_exchange.92bf26c60bf6 + binding: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + local_node: node.otel.service.Application-A.cfbc55b42036 + remote_node: node.otel.database.postgresql.db.internal:5432.03855f9892af + channel: null + resource: resource.otel.db.public.integration_exchange.84bc7a7ef21d + database_system: postgresql + effect: write + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:03Z' + last_seen: '2026-09-09T07:00:03Z' + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + - id: aggregate.otel.508461318135f08b1d916347 + domain: database + role: client + operation: operation.otel.db.SELECT-public.integration_exchange.2b77ce48158e + binding: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + local_node: node.otel.service.Application-B.e415ac492d2e + remote_node: node.otel.database.postgresql.db.internal:5432.03855f9892af + channel: null + resource: resource.otel.db.public.integration_exchange.84bc7a7ef21d + database_system: postgresql + effect: read + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:04Z' + last_seen: '2026-09-09T07:00:04Z' + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + org.fiam.runtime_topology_observations: + - id: topology.otel.database.c1ddfac34c71b4b8d3f9 + domain: database + count: 1 + first_seen: '2026-09-09T07:00:04Z' + last_seen: '2026-09-09T07:00:04Z' + sample_correlations: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + kind: resource-read + from: node.otel.service.Application-B.e415ac492d2e + to_resource: resource.otel.db.public.integration_exchange.84bc7a7ef21d + binding: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + correlation: span-resource + - id: topology.otel.database.d2681a2839139c054290 + domain: database + count: 1 + first_seen: '2026-09-09T07:00:03Z' + last_seen: '2026-09-09T07:00:03Z' + sample_correlations: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + kind: resource-write + from: node.otel.service.Application-A.cfbc55b42036 + to_resource: resource.otel.db.public.integration_exchange.84bc7a7ef21d + binding: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + correlation: span-resource + org.fiam.runtime_unresolved: [] + org.fiam.reconciliation_candidates: + - observed_ref: node.otel.service.Application-A.cfbc55b42036 + entity_kind: system-node + status: matched + candidates: + - declared_ref: node.app-a + score: 0.7 + signals: *id003 + - observed_ref: node.otel.service.Application-B.e415ac492d2e + entity_kind: system-node + status: matched + candidates: + - declared_ref: node.app-b + score: 0.7 + signals: *id004 + - observed_ref: resource.otel.db.public.integration_exchange.84bc7a7ef21d + entity_kind: information-resource + status: matched + candidates: + - declared_ref: resource.pg.exchange + score: 0.75 + signals: + - collection-name +zones: +- id: zone.otel.unscoped + kind: zone + name: Unscoped runtime observations + zone_type: fiam.zone-type.unscoped + members: + - node.otel.service.Application-A.cfbc55b42036 + - node.otel.service.Application-B.e415ac492d2e diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/security-api-declared-plus-observed.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/composite/security-api-declared-plus-observed.fiam.yaml new file mode 100644 index 0000000..3f7569c --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/security-api-declared-plus-observed.fiam.yaml @@ -0,0 +1,1389 @@ +fiam_version: '0.2' +instance: + id: model.openapi.estate-security-api.catalog + kind: model + title: OpenAPI ingest — Estate Security API — runtime catalog + status: provisional + intent: Incremental FIAM catalog combining declared architecture with aggregated runtime observations. +nodes: +- id: node.openapi.estate-security-api + kind: system-node + name: Estate Security API + node_type: fiam.node-type.service +- id: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + kind: system-node + name: Estate Security API + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: petstore3.swagger.io + service_name: Estate Security API +ports: +- id: port.openapi.estate-security-api + owner: node.openapi.estate-security-api + participations: + - contract: contract.openapi.estate-security-api + mode: offers +- id: port.otel.http.Estate-Security-API.530db556431d + kind: port + owner: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + participations: + - contract: contract.otel.http.Estate-Security-API.1dd49a95178d + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.openapi.estate-security-api + kind: interface-contract + name: Estate Security API + contract_forms: + - fiam.contract-form.openapi + operations: + - id: operation.openapi.estate-security-api.createItem + kind: operation + name: createItem + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.write + purpose: + - fiam.purpose.mutation + x-http-method: POST + x-openapi-path: /items + x-openapi-operation-id: createItem + - id: operation.openapi.estate-security-api.listItems + kind: operation + name: listItems + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /items + x-openapi-operation-id: listItems + - id: operation.openapi.estate-security-api.optionalInfo + kind: operation + name: optionalInfo + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /optional + x-openapi-operation-id: optionalInfo + - id: operation.openapi.estate-security-api.publicInfo + kind: operation + name: publicInfo + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /public + x-openapi-operation-id: publicInfo +- id: contract.otel.http.Estate-Security-API.1dd49a95178d + kind: interface-contract + name: Observed HTTP surface — Estate Security API + operations: + - id: operation.otel.http.GET--items.d210cde96bfe + kind: operation + name: GET /items + interaction_style: fiam.interaction-style.request-response + x-http-method: GET + x-http-route: /items +endpoints: +- id: endpoint.openapi.estate-security-api.1 + kind: endpoint + name: OpenAPI server 1 + address: https://security.example.test + address_scheme: fiam.address-scheme.https-url +- id: endpoint.otel.http.security.example.test.b578c891ea81 + kind: endpoint + name: security.example.test + address_scheme: fiam.address-scheme.https-url + facets: + identity_tuple: + address: https://security.example.test + address_scheme: fiam.address-scheme.https-url + zone: + - '' + - '' + - '' + - '' + - '' + logical_server_address: security.example.test + address: https://security.example.test +bindings: +- id: binding.openapi.estate-security-api.1 + kind: binding + contract: contract.openapi.estate-security-api + provider_port: port.openapi.estate-security-api + endpoints: + - endpoint.openapi.estate-security-api.1 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.openapi.estate-security-api.listItems + - operation.openapi.estate-security-api.createItem + - operation.openapi.estate-security-api.optionalInfo + - operation.openapi.estate-security-api.publicInfo +- id: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + kind: binding + contract: contract.otel.http.Estate-Security-API.1dd49a95178d + provider_port: port.otel.http.Estate-Security-API.530db556431d + endpoints: + - endpoint.otel.http.security.example.test.b578c891ea81 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http2 + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.otel.http.GET--items.d210cde96bfe + facets: + identity_tuple: + kind: http-binding + service_node: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + server_address: security.example.test + server_port: 443 + zone: + - '' + - '' + - '' + - '' + - '' +information_resources: +- id: resource.openapi.estate-security-api.items + kind: information-resource + owner: node.openapi.estate-security-api + name: /items + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /items +- id: resource.openapi.estate-security-api.optional + kind: information-resource + owner: node.openapi.estate-security-api + name: /optional + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /optional +- id: resource.openapi.estate-security-api.public + kind: information-resource + owner: node.openapi.estate-security-api + name: /public + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /public +information_shapes: +- id: shape.openapi.estate-security-api.Item + kind: information-shape + name: Item + shape_kind: fiam.information-shape.object + facets: + openapi_component: Item +- id: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + kind: information-shape + name: listItems response + shape_kind: fiam.information-shape.collection + facets: + openapi_pointer: '#/paths/~1items/get/responses/200/content/application~1json/schema' +artifacts: +- id: artifact.openapi.estate-security-api + kind: artifact + name: security-api.yaml + artifact_type: fiam.artifact.api-description + describes: + - contract.openapi.estate-security-api + - shape.openapi.estate-security-api.Item + - shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + - security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + - security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + - security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + locator: real-world/openapi/estate-hardening/security-api.yaml + facets: + openapi_version: 3.2.0 + document_version: 1.0.0 + source_file: security-api.yaml +- id: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + kind: artifact + name: OTLP runtime stream + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/estate-hardening/security-api-list-items.otlp.json + facets: + format: OTLP/JSON + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + latest_batch_hash: 43fefde097aeb470bb1b3865b5bc067640484182dacd2f99157cd2126c9295ef + describes: + - interaction.sample.58316c4b6aac715d6c057fb5.1122334455667788 +security: +- id: security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + applies_to: contract.openapi.estate-security-api + authentication: fiam.security.authentication.openid-connect + facets: + openapi_security_scheme: oidc + openapi_security_type: openIdConnect + requirement_alternative: 1 + requirement_operator: and-within-alternative + required_scopes: + - items.read + openapi_openIdConnectUrl: https://id.example.test/.well-known/openid-configuration + credential_artifacts: + - fiam.credential.id-token + - fiam.credential.access-token +- id: security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + applies_to: operation.openapi.estate-security-api.createItem + authentication: fiam.security.authentication.api-key + facets: + openapi_security_scheme: apiKey + openapi_security_type: apiKey + requirement_alternative: 1 + requirement_operator: and-within-alternative + required_scopes: [] + openapi_name: X-API-Key + openapi_in: header + credential_artifacts: + - fiam.credential.api-key +- id: security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + applies_to: operation.openapi.estate-security-api.optionalInfo + authentication: fiam.security.authentication.openid-connect + facets: + openapi_security_scheme: oidc + openapi_security_type: openIdConnect + requirement_alternative: 2 + requirement_operator: and-within-alternative + required_scopes: [] + openapi_openIdConnectUrl: https://id.example.test/.well-known/openid-configuration + credential_artifacts: + - fiam.credential.id-token + - fiam.credential.access-token +assertions: +- id: assertion.openapi.0001 + assertion_kind: property + subject: contract.openapi.estate-security-api + predicate: fiam.property.security-override + polarity: asserted + value: declared + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0002 + assertion_kind: property + subject: security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + predicate: fiam.property.security-override + polarity: asserted + value: required + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/security/0/oidc' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + applies_to: contract.openapi.estate-security-api +- id: assertion.openapi.0003 + assertion_kind: property + subject: binding.openapi.estate-security-api.1 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/servers/0' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0004 + assertion_kind: property + subject: endpoint.openapi.estate-security-api.1 + predicate: fiam.property.server-address + polarity: asserted + value: security.example.test + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/servers/0/url' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0005 + assertion_kind: property + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0006 + assertion_kind: property + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.property.http-route + polarity: asserted + value: /items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0007 + assertion_kind: relation + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0008 + assertion_kind: relation + subject: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.Item + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get/responses/200/content/application~1json/schema/items' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + slot: items + role: fiam.shape-role.element +- id: assertion.openapi.0009 + assertion_kind: relation + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get/responses/200/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + role: fiam.shape-role.response +- id: assertion.openapi.0010 + assertion_kind: relation + subject: binding.openapi.estate-security-api.1 + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get/responses/200/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + operation_ref: operation.openapi.estate-security-api.listItems + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.openapi.0011 + assertion_kind: property + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.property.security-override + polarity: asserted + value: operation + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0012 + assertion_kind: property + subject: security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + predicate: fiam.property.security-override + polarity: asserted + value: required + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/security/0/apiKey' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + applies_to: operation.openapi.estate-security-api.createItem +- id: assertion.openapi.0013 + assertion_kind: property + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.property.http-method + polarity: asserted + value: POST + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0014 + assertion_kind: property + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.property.http-route + polarity: asserted + value: /items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0015 + assertion_kind: relation + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0016 + assertion_kind: relation + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.Item + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/requestBody/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + role: fiam.shape-role.request +- id: assertion.openapi.0017 + assertion_kind: relation + subject: binding.openapi.estate-security-api.1 + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.Item + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/requestBody/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + operation_ref: operation.openapi.estate-security-api.createItem + role: fiam.shape-role.request + representation: fiam.representation.json +- id: assertion.openapi.0018 + assertion_kind: property + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.property.security-override + polarity: asserted + value: anonymous-alternative + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0019 + assertion_kind: property + subject: security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + predicate: fiam.property.security-override + polarity: asserted + value: required + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get/security/1/oidc' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + applies_to: operation.openapi.estate-security-api.optionalInfo +- id: assertion.openapi.0020 + assertion_kind: property + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0021 + assertion_kind: property + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.property.http-route + polarity: asserted + value: /optional + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0022 + assertion_kind: relation + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.optional + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0023 + assertion_kind: property + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.property.security-override + polarity: asserted + value: none + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0024 + assertion_kind: property + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0025 + assertion_kind: property + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.property.http-route + polarity: asserted + value: /public + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0026 + assertion_kind: relation + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.public + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.otel.0c013b9bfca2e06ee4d9 + assertion_kind: property + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T01:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: aggregate:58316c4b6aac715d6c057fb5 + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:58316c4b6aac715d6c057fb5 + aggregation_key: 58316c4b6aac715d6c057fb5 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: &id001 + aggregation_key: 58316c4b6aac715d6c057fb5 + domain: http + role: server + operation_ref: operation.otel.http.GET--items.d210cde96bfe + local_node_ref: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.1e0a4e5e28d5cf3becdb + assertion_kind: relation + subject: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: node.openapi.estate-security-api + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:http + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:http + signals: &id002 + - http-method + - http-route-exact + - server-address + score: 1.0 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.94 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.25864fd816ddf62afacd + assertion_kind: property + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: aggregate:58316c4b6aac715d6c057fb5 + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:58316c4b6aac715d6c057fb5 + aggregation_key: 58316c4b6aac715d6c057fb5 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.303cc12daf188231639d + assertion_kind: property + subject: endpoint.otel.http.security.example.test.b578c891ea81 + predicate: fiam.property.server-address + polarity: asserted + value: security.example.test + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:server.address + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:server.address + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.35589efcc9bddeb5cbce + assertion_kind: property + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http2 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:network.protocol.version + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:network.protocol.version + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.40191da00a8093cd6a8d + assertion_kind: property + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: aggregate:58316c4b6aac715d6c057fb5 + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:58316c4b6aac715d6c057fb5 + aggregation_key: 58316c4b6aac715d6c057fb5 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.477a30d93b905248cbd6 + assertion_kind: property + subject: interaction.sample.58316c4b6aac715d6c057fb5.1122334455667788 + predicate: fiam.property.http-response-status-code + polarity: asserted + value: 200 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:http.response.status_code + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.response.status_code + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.499e3268cadc16df61b8 + assertion_kind: relation + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: binding.openapi.estate-security-api.1 + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:http + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:http + signals: *id002 + score: 1.0 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.96 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.4e624f09924fd090d149 + assertion_kind: property + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T01:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: aggregate:58316c4b6aac715d6c057fb5 + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:58316c4b6aac715d6c057fb5 + aggregation_key: 58316c4b6aac715d6c057fb5 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.6b9158ee7e12db7c08bb + assertion_kind: property + subject: operation.otel.http.GET--items.d210cde96bfe + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:http.request.method + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.request.method + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.7eae4a2ccaf380107bac + assertion_kind: property + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: aggregate:58316c4b6aac715d6c057fb5 + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:58316c4b6aac715d6c057fb5 + aggregation_key: 58316c4b6aac715d6c057fb5 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.8b8036aa238aa607dc96 + assertion_kind: relation + subject: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: node.openapi.estate-security-api + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:service-identity + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:service-identity + signals: &id003 + - service-name + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.92 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.c9329ce50d77ad4498b2 + assertion_kind: relation + subject: operation.otel.http.GET--items.d210cde96bfe + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: operation.openapi.estate-security-api.listItems + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:http + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:http + signals: *id002 + score: 1.0 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.97 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.d54cc10e94399ee53344 + assertion_kind: property + subject: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + predicate: fiam.property.service-namespace + polarity: asserted + value: petstore3.swagger.io + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:service.namespace + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.namespace + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.de7c69afccbdf234bccd + assertion_kind: relation + subject: endpoint.otel.http.security.example.test.b578c891ea81 + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: endpoint.openapi.estate-security-api.1 + evidence: + mode: fiam.evidence.inferred + source: + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:http + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: reconcile:http + signals: *id002 + score: 1.0 + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 0.95 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.e8528004dca55453b943 + assertion_kind: property + subject: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + predicate: fiam.property.network-protocol-version + polarity: asserted + value: '2' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:network.protocol.version + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:network.protocol.version + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.eb376a12ea09822f6d92 + assertion_kind: property + subject: endpoint.otel.http.security.example.test.b578c891ea81 + predicate: fiam.property.server-port + polarity: asserted + value: 443 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:server.port + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:server.port + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.f2f7c94c1a8a662b226e + assertion_kind: property + subject: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + predicate: fiam.property.service-name + polarity: asserted + value: Estate Security API + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:service.name + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +- id: assertion.otel.f5a4d4e2dcf69ced2545 + assertion_kind: property + subject: operation.otel.http.GET--items.d210cde96bfe + predicate: fiam.property.http-route + polarity: asserted + value: /items + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:http.route + metadata: + source: real-world/otel/estate-hardening/security-api-list-items.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.route + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T01:00:00Z' + valid_time: + valid_from: '2026-09-09T01:00:00Z' + valid_until: '2026-09-09T01:00:00Z' + observed_at: '2026-09-09T01:00:00Z' +extensions: + org.fiam.catalog: + version: 0.2-draft.4 + processed_batches: + - 43fefde097aeb470bb1b3865b5bc067640484182dacd2f99157cd2126c9295ef + declared_entity_ids: + - artifact.openapi.estate-security-api + - binding.openapi.estate-security-api.1 + - contract.openapi.estate-security-api + - endpoint.openapi.estate-security-api.1 + - node.openapi.estate-security-api + - operation.openapi.estate-security-api.createItem + - operation.openapi.estate-security-api.listItems + - operation.openapi.estate-security-api.optionalInfo + - operation.openapi.estate-security-api.publicInfo + - port.openapi.estate-security-api + - resource.openapi.estate-security-api.items + - resource.openapi.estate-security-api.optional + - resource.openapi.estate-security-api.public + - security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + - security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + - security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + - shape.openapi.estate-security-api.Item + - shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + last_ingest_at: '2026-09-09T01:00:00Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: sample + sample_size: 3 + org.fiam.runtime_aggregates: + - id: aggregate.otel.58316c4b6aac715d6c057fb5 + domain: http + role: server + operation: operation.otel.http.GET--items.d210cde96bfe + binding: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + local_node: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + remote_node: null + channel: null + resource: null + method: GET + route: /items + count: 1 + error_count: 0 + first_seen: '2026-09-09T01:00:00Z' + last_seen: '2026-09-09T01:00:00Z' + sample_spans: + - trace:aabbccddeeff00112233445566778899/span:1122334455667788 + org.fiam.runtime_topology_observations: [] + org.fiam.runtime_unresolved: [] + org.fiam.reconciliation_candidates: + - observed_ref: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + entity_kind: system-node + status: matched + candidates: + - declared_ref: node.openapi.estate-security-api + score: 0.7 + signals: *id003 + - observed_ref: operation.otel.http.GET--items.d210cde96bfe + entity_kind: operation + status: matched + candidates: + - declared_ref: operation.openapi.estate-security-api.listItems + binding_ref: binding.openapi.estate-security-api.1 + endpoint_ref: endpoint.openapi.estate-security-api.1 + node_ref: node.openapi.estate-security-api + score: 1.0 + signals: *id002 + - declared_ref: operation.openapi.estate-security-api.createItem + binding_ref: binding.openapi.estate-security-api.1 + endpoint_ref: endpoint.openapi.estate-security-api.1 + node_ref: node.openapi.estate-security-api + score: 0.7 + signals: + - http-route-exact + - server-address + - declared_ref: operation.openapi.estate-security-api.optionalInfo + binding_ref: binding.openapi.estate-security-api.1 + endpoint_ref: endpoint.openapi.estate-security-api.1 + node_ref: node.openapi.estate-security-api + score: 0.5 + signals: + - http-method + - server-address + - declared_ref: operation.openapi.estate-security-api.publicInfo + binding_ref: binding.openapi.estate-security-api.1 + endpoint_ref: endpoint.openapi.estate-security-api.1 + node_ref: node.openapi.estate-security-api + score: 0.5 + signals: + - http-method + - server-address +zones: +- id: zone.otel.unscoped + kind: zone + name: Unscoped runtime observations + zone_type: fiam.zone-type.unscoped + members: + - node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda +interactions: +- id: interaction.sample.58316c4b6aac715d6c057fb5.1122334455667788 + kind: interaction + operation: operation.otel.http.GET--items.d210cde96bfe + contract: contract.otel.http.Estate-Security-API.1dd49a95178d + binding: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + interaction_style: fiam.interaction-style.request-response + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + responder: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + facets: + otel_trace_id: aabbccddeeff00112233445566778899 + otel_span_id: '1122334455667788' + otel_span_kind: server + instrumentation_scope: example.http.instrumentation + observed_service: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/security-api-declared-plus-observed.lens.md b/history/FIAM_v0.2_Draft6/real-world/composite/security-api-declared-plus-observed.lens.md new file mode 100644 index 0000000..62287f0 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/security-api-declared-plus-observed.lens.md @@ -0,0 +1,48 @@ +# fiam.lens.declared-vs-observed result + +Model: `model.openapi.estate-security-api.catalog` + +## Property comparison + +- **compatible-refinement:** 1 +- **exact:** 2 +- **observed-only:** 2 + +## Coverage + +- **declared-only:** 3 +- **observed:** 1 + +## Property findings + +### compatible-refinement — fiam.property.communication-protocol +- Declared: `binding.openapi.estate-security-api.1` = `fiam.protocol.http` +- Observed: `binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742` = `fiam.protocol.http2` +- Architectural owner: `node.openapi.estate-security-api` (Estate Security API) + +### observed-only — fiam.property.network-protocol-version +- Declared: `binding.openapi.estate-security-api.1` = `None` +- Observed: `binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742` = `2` +- Architectural owner: `node.openapi.estate-security-api` (Estate Security API) + +### exact — fiam.property.http-method +- Declared: `operation.openapi.estate-security-api.listItems` = `GET` +- Observed: `operation.otel.http.GET--items.d210cde96bfe` = `GET` +- Architectural owner: `node.openapi.estate-security-api` (Estate Security API) + +### exact — fiam.property.server-address +- Declared: `endpoint.openapi.estate-security-api.1` = `security.example.test` +- Observed: `endpoint.otel.http.security.example.test.b578c891ea81` = `security.example.test` +- Architectural owner: `node.openapi.estate-security-api` (Estate Security API) + +### observed-only — fiam.property.server-port +- Declared: `endpoint.openapi.estate-security-api.1` = `None` +- Observed: `endpoint.otel.http.security.example.test.b578c891ea81` = `443` +- Architectural owner: `node.openapi.estate-security-api` (Estate Security API) + +## Coverage findings + +- **declared-only** operation: `operation.openapi.estate-security-api.createItem` +- **observed** operation: `operation.openapi.estate-security-api.listItems` +- **declared-only** operation: `operation.openapi.estate-security-api.optionalInfo` +- **declared-only** operation: `operation.openapi.estate-security-api.publicInfo` diff --git a/history/FIAM_v0.2_Draft6/real-world/composite/security-api-declared-plus-observed.lens.yaml b/history/FIAM_v0.2_Draft6/real-world/composite/security-api-declared-plus-observed.lens.yaml new file mode 100644 index 0000000..451c4b2 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/composite/security-api-declared-plus-observed.lens.yaml @@ -0,0 +1,215 @@ +lens: fiam.lens.declared-vs-observed +lens_version: 0.2-draft.4 +model: model.openapi.estate-security-api.catalog +summary: + pairs: 5 + property_findings: 5 + classifications: + compatible-refinement: 1 + exact: 2 + observed-only: 2 + coverage: + declared-only: 3 + observed: 1 +findings: +- declared_ref: binding.openapi.estate-security-api.1 + observed_ref: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + entity_kind: binding + predicate: fiam.property.communication-protocol + classification: compatible-refinement + declared_value: fiam.protocol.http + observed_value: fiam.protocol.http2 + owner: + node_ref: node.openapi.estate-security-api + name: Estate Security API + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:http + confidence: 0.96 + declared_evidence: + - mode: fiam.evidence.declared + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/servers/0' + confidence: 1.0 + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:network.protocol.version + confidence: 1.0 +- declared_ref: binding.openapi.estate-security-api.1 + observed_ref: binding.otel.http.Estate-Security-API-security.example.test.552aa6a69742 + entity_kind: binding + predicate: fiam.property.network-protocol-version + classification: observed-only + declared_value: null + observed_value: '2' + owner: + node_ref: node.openapi.estate-security-api + name: Estate Security API + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:http + confidence: 0.96 + declared_evidence: [] + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:network.protocol.version + confidence: 1.0 +- declared_ref: operation.openapi.estate-security-api.listItems + observed_ref: operation.otel.http.GET--items.d210cde96bfe + entity_kind: operation + predicate: fiam.property.http-method + classification: exact + declared_value: GET + observed_value: GET + owner: + node_ref: node.openapi.estate-security-api + name: Estate Security API + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:http + confidence: 0.97 + declared_evidence: + - mode: fiam.evidence.declared + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get' + confidence: 1.0 + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:http.request.method + confidence: 1.0 +- declared_ref: endpoint.openapi.estate-security-api.1 + observed_ref: endpoint.otel.http.security.example.test.b578c891ea81 + entity_kind: endpoint + predicate: fiam.property.server-address + classification: exact + declared_value: security.example.test + observed_value: security.example.test + owner: + node_ref: node.openapi.estate-security-api + name: Estate Security API + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:http + confidence: 0.95 + declared_evidence: + - mode: fiam.evidence.declared + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/servers/0/url' + confidence: 1.0 + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:server.address + confidence: 1.0 +- declared_ref: endpoint.openapi.estate-security-api.1 + observed_ref: endpoint.otel.http.security.example.test.b578c891ea81 + entity_kind: endpoint + predicate: fiam.property.server-port + classification: observed-only + declared_value: null + observed_value: 443 + owner: + node_ref: node.openapi.estate-security-api + name: Estate Security API + pair_evidence: + - mode: fiam.evidence.inferred + type: reconciliation-rule + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: reconcile:http + confidence: 0.95 + declared_evidence: [] + observed_evidence: + - mode: fiam.evidence.runtime-observed + type: otlp-trace-stream + ref: artifact.otel.stream.security-api-list-items.otlp.bce61e71971a + locator: attribute:server.port + confidence: 1.0 +coverage_findings: +- entity_kind: operation + classification: declared-only + declared_ref: operation.openapi.estate-security-api.createItem + owner: + node_ref: node.openapi.estate-security-api + name: Estate Security API +- entity_kind: operation + classification: observed + declared_ref: operation.openapi.estate-security-api.listItems + owner: + node_ref: node.openapi.estate-security-api + name: Estate Security API +- entity_kind: operation + classification: declared-only + declared_ref: operation.openapi.estate-security-api.optionalInfo + owner: + node_ref: node.openapi.estate-security-api + name: Estate Security API +- entity_kind: operation + classification: declared-only + declared_ref: operation.openapi.estate-security-api.publicInfo + owner: + node_ref: node.openapi.estate-security-api + name: Estate Security API +reconciliation_candidates: +- observed_ref: node.otel.service.petstore3.swagger.io.Estate-Security-API.01b865f9bfda + entity_kind: system-node + status: matched + candidates: + - declared_ref: node.openapi.estate-security-api + score: 0.7 + signals: + - service-name +- observed_ref: operation.otel.http.GET--items.d210cde96bfe + entity_kind: operation + status: matched + candidates: + - declared_ref: operation.openapi.estate-security-api.listItems + binding_ref: binding.openapi.estate-security-api.1 + endpoint_ref: endpoint.openapi.estate-security-api.1 + node_ref: node.openapi.estate-security-api + score: 1.0 + signals: + - http-method + - http-route-exact + - server-address + - declared_ref: operation.openapi.estate-security-api.createItem + binding_ref: binding.openapi.estate-security-api.1 + endpoint_ref: endpoint.openapi.estate-security-api.1 + node_ref: node.openapi.estate-security-api + score: 0.7 + signals: + - http-route-exact + - server-address + - declared_ref: operation.openapi.estate-security-api.optionalInfo + binding_ref: binding.openapi.estate-security-api.1 + endpoint_ref: endpoint.openapi.estate-security-api.1 + node_ref: node.openapi.estate-security-api + score: 0.5 + signals: + - http-method + - server-address + - declared_ref: operation.openapi.estate-security-api.publicInfo + binding_ref: binding.openapi.estate-security-api.1 + endpoint_ref: endpoint.openapi.estate-security-api.1 + node_ref: node.openapi.estate-security-api + score: 0.5 + signals: + - http-method + - server-address diff --git a/history/FIAM_v0.2_Draft6/real-world/declaration-matching/channel-declared.yaml b/history/FIAM_v0.2_Draft6/real-world/declaration-matching/channel-declared.yaml new file mode 100644 index 0000000..ab7be5b --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/declaration-matching/channel-declared.yaml @@ -0,0 +1,60 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.decl.channel +created_at: '2026-09-01T00:00:00Z' +source: + source_id: architecture.git + source_kind: fixture + source_ref: fixture://exchange.decl.channel + content_hash: null +observation: + mode: declared-snapshot + observation_scope: null + population_id: decl-channel + population: {} + domains: [] + snapshot_time: '2026-09-01T00:00:00Z' + aggregate_semantics: cumulative +records: + entities: + - section: nodes + entity: + id: node.producer + kind: system-node + name: node.producer + - section: nodes + entity: + id: node.consumer + kind: system-node + name: node.consumer + - section: channels + entity: + id: channel.orders + kind: channel + name: channel.orders + assertions: + - id: decl.channel + assertion_kind: relation + subject: node.producer + predicate: fiam.relation.uses + polarity: asserted + object_ref: channel.orders + evidence: + - mode: fiam.evidence.declared + source: + type: architecture-declaration + ref: fixture://decl + locator: fixture + observer: fixture + observed_at: '2026-09-01T00:00:00Z' + confidence: 0.99 + stance: supports + zone_memberships: [] + runtime_aggregates: [] + topology_observations: [] + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: + - node.producer + - node.consumer + - channel.orders diff --git a/history/FIAM_v0.2_Draft6/real-world/declaration-matching/channel-runtime.yaml b/history/FIAM_v0.2_Draft6/real-world/declaration-matching/channel-runtime.yaml new file mode 100644 index 0000000..591e419 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/declaration-matching/channel-runtime.yaml @@ -0,0 +1,51 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.rt.channel +created_at: '2026-09-09T00:00:00Z' +source: + source_id: runtime.channel + source_kind: fixture + source_ref: fixture://exchange.rt.channel + content_hash: null +observation: + mode: incremental + observation_scope: scope-channel + population_id: decl-channel + population: {} + domains: + - messaging + snapshot_time: '2026-09-09T00:00:00Z' + aggregate_semantics: cumulative +records: + entities: + - section: nodes + entity: + id: node.producer + kind: system-node + name: node.producer + - section: nodes + entity: + id: node.consumer + kind: system-node + name: node.consumer + - section: channels + entity: + id: channel.orders + kind: channel + name: channel.orders + assertions: [] + zone_memberships: [] + runtime_aggregates: [] + topology_observations: + - id: topology.channel + domain: messaging + kind: broker-mediated + from: node.producer + to: node.consumer + via_channel: channel.orders + count: 5 + first_seen: '2026-09-09T00:00:00Z' + last_seen: '2026-09-09T00:00:00Z' + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/declaration-matching/gateway-declared.yaml b/history/FIAM_v0.2_Draft6/real-world/declaration-matching/gateway-declared.yaml new file mode 100644 index 0000000..fae1cc2 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/declaration-matching/gateway-declared.yaml @@ -0,0 +1,60 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.decl.gateway +created_at: '2026-09-01T00:00:00Z' +source: + source_id: architecture.git + source_kind: fixture + source_ref: fixture://exchange.decl.gateway + content_hash: null +observation: + mode: declared-snapshot + observation_scope: null + population_id: decl-gateway + population: {} + domains: [] + snapshot_time: '2026-09-01T00:00:00Z' + aggregate_semantics: cumulative +records: + entities: + - section: nodes + entity: + id: node.client + kind: system-node + name: node.client + - section: nodes + entity: + id: node.gateway + kind: system-node + name: node.gateway + - section: nodes + entity: + id: node.server + kind: system-node + name: node.server + assertions: + - id: decl.gateway + assertion_kind: relation + subject: node.client + predicate: fiam.relation.uses + polarity: asserted + object_ref: node.server + evidence: + - mode: fiam.evidence.declared + source: + type: architecture-declaration + ref: fixture://decl + locator: fixture + observer: fixture + observed_at: '2026-09-01T00:00:00Z' + confidence: 0.99 + stance: supports + zone_memberships: [] + runtime_aggregates: [] + topology_observations: [] + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: + - node.client + - node.gateway + - node.server diff --git a/history/FIAM_v0.2_Draft6/real-world/declaration-matching/gateway-runtime.yaml b/history/FIAM_v0.2_Draft6/real-world/declaration-matching/gateway-runtime.yaml new file mode 100644 index 0000000..418ad36 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/declaration-matching/gateway-runtime.yaml @@ -0,0 +1,53 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.rt.gateway +created_at: '2026-09-09T00:00:00Z' +source: + source_id: runtime.gateway + source_kind: fixture + source_ref: fixture://exchange.rt.gateway + content_hash: null +observation: + mode: incremental + observation_scope: scope-gateway + population_id: decl-gateway + population: {} + domains: + - rpc + snapshot_time: '2026-09-09T00:00:00Z' + aggregate_semantics: cumulative +records: + entities: + - section: nodes + entity: + id: node.client + kind: system-node + name: node.client + - section: nodes + entity: + id: node.gateway + kind: system-node + name: node.gateway + - section: nodes + entity: + id: node.server + kind: system-node + name: node.server + assertions: [] + zone_memberships: [] + runtime_aggregates: [] + topology_observations: + - id: topology.gateway + domain: rpc + kind: direct-call + from: node.client + to: node.gateway + via_gateway: true + gateway: node.gateway + intended_target: node.server + count: 2 + first_seen: '2026-09-09T00:00:00Z' + last_seen: '2026-09-09T00:00:00Z' + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/declaration-matching/working-declared.yaml b/history/FIAM_v0.2_Draft6/real-world/declaration-matching/working-declared.yaml new file mode 100644 index 0000000..d57bab2 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/declaration-matching/working-declared.yaml @@ -0,0 +1,60 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.decl.working +created_at: '2026-09-01T00:00:00Z' +source: + source_id: architecture.git + source_kind: fixture + source_ref: fixture://exchange.decl.working + content_hash: null +observation: + mode: declared-snapshot + observation_scope: null + population_id: decl-working + population: {} + domains: [] + snapshot_time: '2026-09-01T00:00:00Z' + aggregate_semantics: cumulative +records: + entities: + - section: nodes + entity: + id: node.client.declared + kind: system-node + name: node.client.declared + - section: nodes + entity: + id: node.client.observed + kind: system-node + name: node.client.observed + - section: nodes + entity: + id: node.server3 + kind: system-node + name: node.server3 + assertions: + - id: decl.working + assertion_kind: relation + subject: node.client.observed + predicate: fiam.relation.uses + polarity: asserted + object_ref: node.server3 + evidence: + - mode: fiam.evidence.declared + source: + type: architecture-declaration + ref: fixture://decl + locator: fixture + observer: fixture + observed_at: '2026-09-01T00:00:00Z' + confidence: 0.99 + stance: supports + zone_memberships: [] + runtime_aggregates: [] + topology_observations: [] + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: + - node.client.declared + - node.client.observed + - node.server3 diff --git a/history/FIAM_v0.2_Draft6/real-world/declaration-matching/working-runtime.yaml b/history/FIAM_v0.2_Draft6/real-world/declaration-matching/working-runtime.yaml new file mode 100644 index 0000000..52ee9f0 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/declaration-matching/working-runtime.yaml @@ -0,0 +1,66 @@ +catalog_exchange_version: '0.2' +profile_id: fiam.catalog-exchange.v0.2 +exchange_id: exchange.rt.working +created_at: '2026-09-09T00:00:00Z' +source: + source_id: runtime.working + source_kind: fixture + source_ref: fixture://exchange.rt.working + content_hash: null +observation: + mode: incremental + observation_scope: scope-working + population_id: decl-working + population: {} + domains: + - rpc + snapshot_time: '2026-09-09T00:00:00Z' + aggregate_semantics: cumulative +records: + entities: + - section: nodes + entity: + id: node.client.declared + kind: system-node + name: node.client.declared + - section: nodes + entity: + id: node.client.observed + kind: system-node + name: node.client.observed + - section: nodes + entity: + id: node.server3 + kind: system-node + name: node.server3 + assertions: + - id: corr.working + assertion_kind: relation + subject: node.client.observed + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: node.client.declared + evidence: + - mode: fiam.evidence.runtime-observed + source: + type: reconciliation-rule + ref: fixture://working + locator: id-map + observer: fixture + observed_at: '2026-09-09T00:00:00Z' + confidence: 0.95 + stance: supports + zone_memberships: [] + runtime_aggregates: [] + topology_observations: + - id: topology.working + domain: rpc + kind: direct-call + from: node.client.observed + to: node.server3 + count: 2 + first_seen: '2026-09-09T00:00:00Z' + last_seen: '2026-09-09T00:00:00Z' + unresolved: [] + reconciliation_candidates: [] + declared_entity_ids: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/declared/estate-hardening/ambiguous-http.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/declared/estate-hardening/ambiguous-http.fiam.yaml new file mode 100644 index 0000000..f08dd57 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/declared/estate-hardening/ambiguous-http.fiam.yaml @@ -0,0 +1,106 @@ +fiam_version: '0.2' +instance: + id: model.declared.ambiguous-http + kind: model + title: Ambiguous HTTP declaration fixture + status: provisional +nodes: +- id: node.service.alpha + kind: system-node + name: alpha + node_type: fiam.node-type.service +- id: node.service.beta + kind: system-node + name: beta + node_type: fiam.node-type.service +ports: +- id: port.alpha.http + kind: port + owner: node.service.alpha + participations: [{contract: contract.alpha.http, mode: offers}] +- id: port.beta.http + kind: port + owner: node.service.beta + participations: [{contract: contract.beta.http, mode: offers}] +contracts: +- id: contract.alpha.http + kind: interface-contract + name: Alpha HTTP + operations: + - id: operation.alpha.get-pet + kind: operation + name: get pet alpha + interaction_style: fiam.interaction-style.request-response +- id: contract.beta.http + kind: interface-contract + name: Beta HTTP + operations: + - id: operation.beta.get-pet + kind: operation + name: get pet beta + interaction_style: fiam.interaction-style.request-response +endpoints: +- id: endpoint.alpha + kind: endpoint + address: https://alpha.example + address_scheme: fiam.address-scheme.https-url +- id: endpoint.beta + kind: endpoint + address: https://beta.example + address_scheme: fiam.address-scheme.https-url +bindings: +- id: binding.alpha + kind: binding + contract: contract.alpha.http + provider_port: port.alpha.http + operations: [operation.alpha.get-pet] + endpoints: [endpoint.alpha] + communication_stack: + - {role: fiam.stack-role.application-transfer-protocol, term: fiam.protocol.http} +- id: binding.beta + kind: binding + contract: contract.beta.http + provider_port: port.beta.http + operations: [operation.beta.get-pet] + endpoints: [endpoint.beta] + communication_stack: + - {role: fiam.stack-role.application-transfer-protocol, term: fiam.protocol.http} +artifacts: +- id: artifact.ambiguous-declaration + kind: artifact + name: ambiguous fixture + artifact_type: fiam.artifact.architecture-declaration +assertions: +- id: assertion.alpha.method + assertion_kind: property + subject: operation.alpha.get-pet + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: &decl + mode: fiam.evidence.declared + source: {type: architecture-fixture, ref: artifact.ambiguous-declaration, locator: alpha} + observer: fixture + confidence: 1.0 + stance: supports +- id: assertion.alpha.route + assertion_kind: property + subject: operation.alpha.get-pet + predicate: fiam.property.http-route + polarity: asserted + value: /pets/{id} + evidence: *decl +- id: assertion.beta.method + assertion_kind: property + subject: operation.beta.get-pet + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: *decl +- id: assertion.beta.route + assertion_kind: property + subject: operation.beta.get-pet + predicate: fiam.property.http-route + polarity: asserted + value: /pets/{id} + evidence: *decl diff --git a/history/FIAM_v0.2_Draft6/real-world/declared/petstore-http11-expectation.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/declared/petstore-http11-expectation.fiam.yaml new file mode 100644 index 0000000..60f30e8 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/declared/petstore-http11-expectation.fiam.yaml @@ -0,0 +1,394 @@ +fiam_version: '0.2' +instance: + id: model.openapi.swagger-petstore---identity-ingest-excerpt.expectation + kind: model + title: OpenAPI ingest — Swagger Petstore - identity ingest excerpt + declared expectation + status: provisional + intent: Declared FIAM architecture model generated from an OpenAPI 3.x description. +nodes: +- id: node.openapi.swagger-petstore---identity-ingest-excerpt + kind: system-node + name: Swagger Petstore - identity ingest excerpt + node_type: fiam.node-type.service +ports: +- id: port.openapi.swagger-petstore---identity-ingest-excerpt + owner: node.openapi.swagger-petstore---identity-ingest-excerpt + participations: + - contract: contract.openapi.swagger-petstore---identity-ingest-excerpt + mode: offers +contracts: +- id: contract.openapi.swagger-petstore---identity-ingest-excerpt + kind: interface-contract + name: Swagger Petstore - identity ingest excerpt + contract_forms: + - fiam.contract-form.openapi + operations: + - id: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + kind: operation + name: Find pet by ID + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /pet/{petId} + x-openapi-operation-id: getPetById +endpoints: +- id: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + kind: endpoint + name: OpenAPI server 1 + address: https://petstore3.swagger.io/api/v3 + address_scheme: fiam.address-scheme.https-url +bindings: +- id: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + kind: binding + contract: contract.openapi.swagger-petstore---identity-ingest-excerpt + provider_port: port.openapi.swagger-petstore---identity-ingest-excerpt + endpoints: + - endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById +information_resources: +- id: resource.openapi.swagger-petstore---identity-ingest-excerpt.pet-petId + kind: information-resource + owner: node.openapi.swagger-petstore---identity-ingest-excerpt + name: /pet/{petId} + resource_kind: fiam.information-resource.api-resource-object + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /pet/{petId} +information_shapes: +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + kind: information-shape + name: Category + shape_kind: fiam.information-shape.object + facets: + openapi_component: Category +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + kind: information-shape + name: Tag + shape_kind: fiam.information-shape.object + facets: + openapi_component: Tag +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + kind: information-shape + name: Pet + shape_kind: fiam.information-shape.object + facets: + openapi_component: Pet +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + kind: information-shape + name: Pet.photoUrls + shape_kind: fiam.information-shape.collection + facets: + openapi_pointer: '#/components/schemas/Pet/properties/photoUrls' +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls-element.4eb61207 + kind: information-shape + name: Pet.photoUrls element + shape_kind: fiam.information-shape.scalar + facets: + openapi_pointer: '#/components/schemas/Pet/properties/photoUrls/items' +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + kind: information-shape + name: Pet.tags + shape_kind: fiam.information-shape.collection + facets: + openapi_pointer: '#/components/schemas/Pet/properties/tags' +artifacts: +- id: artifact.openapi.swagger-petstore---identity-ingest-excerpt + kind: artifact + name: petstore-identity-excerpt.yaml + artifact_type: fiam.artifact.api-description + describes: + - contract.openapi.swagger-petstore---identity-ingest-excerpt + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls-element.4eb61207 + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + locator: https://petstore3.swagger.io/api/v3/openapi.json + facets: + openapi_version: 3.0.4 + document_version: 1.0.27 + source_file: petstore-identity-excerpt.yaml + source_note: Normalized semantic excerpt from live Swagger Petstore 1.0.27; examples, XML metadata and unrelated paths/components + intentionally omitted. +- id: artifact.declaration.petstore-http11-expectation + kind: artifact + name: petstore-http11-expectation.yaml + artifact_type: fiam.artifact.architecture-declaration + locator: real-world/declared/petstore-http11-expectation.yaml + facets: + source_note: Controlled mismatch fixture used to exercise the Declared-vs-Observed Lens; not a claim about the public + Swagger Petstore deployment. +assertions: +- id: assertion.openapi.0001 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/category' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports + facets: + slot: category + role: fiam.shape-role.envelope-member +- id: assertion.openapi.0002 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls-element.4eb61207 + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/photoUrls/items' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports + facets: + slot: items + role: fiam.shape-role.element +- id: assertion.openapi.0003 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/photoUrls' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports + facets: + slot: photoUrls + role: fiam.shape-role.envelope-member +- id: assertion.openapi.0004 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/tags/items' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports + facets: + slot: items + role: fiam.shape-role.element +- id: assertion.openapi.0005 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/tags' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports + facets: + slot: tags + role: fiam.shape-role.envelope-member +- id: assertion.openapi.0006 + assertion_kind: property + subject: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/servers/0' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0007 + assertion_kind: property + subject: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + predicate: fiam.property.server-address + polarity: asserted + value: petstore3.swagger.io + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/servers/0/url' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0008 + assertion_kind: property + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0009 + assertion_kind: property + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.property.http-route + polarity: asserted + value: /pet/{petId} + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0010 + assertion_kind: relation + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.swagger-petstore---identity-ingest-excerpt.pet-petId + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0011 + assertion_kind: relation + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get/responses/200/content/application~1json/schema' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports + facets: + role: fiam.shape-role.response +- id: assertion.openapi.0012 + assertion_kind: relation + subject: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get/responses/200/content/application~1json/schema' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.2 + confidence: 1.0 + stance: supports + facets: + operation_ref: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.openapi.0013 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + evidence: + mode: fiam.evidence.inferred + source: + type: schema-structural-fingerprint + ref: schema-structural-fingerprint + locator: fingerprint:sha256:43efaa02d70c55fa422ad1c0aa4bd532aac402499711a1f450bc1fab3efec4b4 + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + left: '#/components/schemas/Category' + right: '#/components/schemas/Tag' + algorithm: normalized-openapi-schema-sha256 + observer: openapi-ingest/v0.2-draft.2 + confidence: 0.75 + stance: supports +- id: assertion.declaration.0001 + assertion_kind: property + subject: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http1.1 + evidence: + mode: fiam.evidence.declared + source: + type: architecture-declaration + ref: artifact.declaration.petstore-http11-expectation + locator: expected_protocol + metadata: + source_file: petstore-http11-expectation.yaml + observer: governed-declaration/v0.2-draft.2 + confidence: 1.0 + stance: supports diff --git a/history/FIAM_v0.2_Draft6/real-world/declared/petstore-http11-expectation.yaml b/history/FIAM_v0.2_Draft6/real-world/declared/petstore-http11-expectation.yaml new file mode 100644 index 0000000..8b2dd80 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/declared/petstore-http11-expectation.yaml @@ -0,0 +1,6 @@ +kind: architecture-expectation +subject: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 +predicate: fiam.property.communication-protocol +value: fiam.protocol.http1.1 +statement: The deployed Petstore interface is expected to use HTTP/1.1. +source_note: Controlled mismatch fixture used to exercise the Declared-vs-Observed Lens; not a claim about the public Swagger Petstore deployment. diff --git a/history/FIAM_v0.2_Draft6/real-world/openapi/estate-hardening/security-api.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/openapi/estate-hardening/security-api.fiam.yaml new file mode 100644 index 0000000..34e6b13 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/openapi/estate-hardening/security-api.fiam.yaml @@ -0,0 +1,655 @@ +fiam_version: '0.2' +instance: + id: model.openapi.estate-security-api + kind: model + title: OpenAPI ingest — Estate Security API + status: provisional + intent: Declared FIAM architecture model generated from an OpenAPI 3.x description. +nodes: +- id: node.openapi.estate-security-api + kind: system-node + name: Estate Security API + node_type: fiam.node-type.service +ports: +- id: port.openapi.estate-security-api + owner: node.openapi.estate-security-api + participations: + - contract: contract.openapi.estate-security-api + mode: offers +contracts: +- id: contract.openapi.estate-security-api + kind: interface-contract + name: Estate Security API + contract_forms: + - fiam.contract-form.openapi + operations: + - id: operation.openapi.estate-security-api.listItems + kind: operation + name: listItems + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /items + x-openapi-operation-id: listItems + - id: operation.openapi.estate-security-api.createItem + kind: operation + name: createItem + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.write + purpose: + - fiam.purpose.mutation + x-http-method: POST + x-openapi-path: /items + x-openapi-operation-id: createItem + - id: operation.openapi.estate-security-api.optionalInfo + kind: operation + name: optionalInfo + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /optional + x-openapi-operation-id: optionalInfo + - id: operation.openapi.estate-security-api.publicInfo + kind: operation + name: publicInfo + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /public + x-openapi-operation-id: publicInfo +endpoints: +- id: endpoint.openapi.estate-security-api.1 + kind: endpoint + name: OpenAPI server 1 + address: https://security.example.test + address_scheme: fiam.address-scheme.https-url +bindings: +- id: binding.openapi.estate-security-api.1 + kind: binding + contract: contract.openapi.estate-security-api + provider_port: port.openapi.estate-security-api + endpoints: + - endpoint.openapi.estate-security-api.1 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.openapi.estate-security-api.listItems + - operation.openapi.estate-security-api.createItem + - operation.openapi.estate-security-api.optionalInfo + - operation.openapi.estate-security-api.publicInfo +information_resources: +- id: resource.openapi.estate-security-api.items + kind: information-resource + owner: node.openapi.estate-security-api + name: /items + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /items +- id: resource.openapi.estate-security-api.optional + kind: information-resource + owner: node.openapi.estate-security-api + name: /optional + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /optional +- id: resource.openapi.estate-security-api.public + kind: information-resource + owner: node.openapi.estate-security-api + name: /public + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /public +information_shapes: +- id: shape.openapi.estate-security-api.Item + kind: information-shape + name: Item + shape_kind: fiam.information-shape.object + facets: + openapi_component: Item +- id: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + kind: information-shape + name: listItems response + shape_kind: fiam.information-shape.collection + facets: + openapi_pointer: '#/paths/~1items/get/responses/200/content/application~1json/schema' +artifacts: +- id: artifact.openapi.estate-security-api + kind: artifact + name: security-api.yaml + artifact_type: fiam.artifact.api-description + describes: + - contract.openapi.estate-security-api + - shape.openapi.estate-security-api.Item + - shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + - security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + - security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + - security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + locator: real-world/openapi/estate-hardening/security-api.yaml + facets: + openapi_version: 3.2.0 + document_version: 1.0.0 + source_file: security-api.yaml +security: +- id: security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + applies_to: contract.openapi.estate-security-api + authentication: fiam.security.authentication.openid-connect + facets: + openapi_security_scheme: oidc + openapi_security_type: openIdConnect + requirement_alternative: 1 + requirement_operator: and-within-alternative + required_scopes: + - items.read + openapi_openIdConnectUrl: https://id.example.test/.well-known/openid-configuration + credential_artifacts: + - fiam.credential.id-token + - fiam.credential.access-token +- id: security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + applies_to: operation.openapi.estate-security-api.createItem + authentication: fiam.security.authentication.api-key + facets: + openapi_security_scheme: apiKey + openapi_security_type: apiKey + requirement_alternative: 1 + requirement_operator: and-within-alternative + required_scopes: [] + openapi_name: X-API-Key + openapi_in: header + credential_artifacts: + - fiam.credential.api-key +- id: security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + applies_to: operation.openapi.estate-security-api.optionalInfo + authentication: fiam.security.authentication.openid-connect + facets: + openapi_security_scheme: oidc + openapi_security_type: openIdConnect + requirement_alternative: 2 + requirement_operator: and-within-alternative + required_scopes: [] + openapi_openIdConnectUrl: https://id.example.test/.well-known/openid-configuration + credential_artifacts: + - fiam.credential.id-token + - fiam.credential.access-token +assertions: +- id: assertion.openapi.0001 + assertion_kind: property + subject: contract.openapi.estate-security-api + predicate: fiam.property.security-override + polarity: asserted + value: declared + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0002 + assertion_kind: property + subject: security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + predicate: fiam.property.security-override + polarity: asserted + value: required + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/security/0/oidc' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + applies_to: contract.openapi.estate-security-api +- id: assertion.openapi.0003 + assertion_kind: property + subject: binding.openapi.estate-security-api.1 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/servers/0' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0004 + assertion_kind: property + subject: endpoint.openapi.estate-security-api.1 + predicate: fiam.property.server-address + polarity: asserted + value: security.example.test + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/servers/0/url' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0005 + assertion_kind: property + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0006 + assertion_kind: property + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.property.http-route + polarity: asserted + value: /items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0007 + assertion_kind: relation + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0008 + assertion_kind: relation + subject: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.Item + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get/responses/200/content/application~1json/schema/items' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + slot: items + role: fiam.shape-role.element +- id: assertion.openapi.0009 + assertion_kind: relation + subject: operation.openapi.estate-security-api.listItems + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get/responses/200/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + role: fiam.shape-role.response +- id: assertion.openapi.0010 + assertion_kind: relation + subject: binding.openapi.estate-security-api.1 + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.inline.listItems-response.7b4df76d + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/get/responses/200/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + operation_ref: operation.openapi.estate-security-api.listItems + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.openapi.0011 + assertion_kind: property + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.property.security-override + polarity: asserted + value: operation + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0012 + assertion_kind: property + subject: security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + predicate: fiam.property.security-override + polarity: asserted + value: required + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/security/0/apiKey' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + applies_to: operation.openapi.estate-security-api.createItem +- id: assertion.openapi.0013 + assertion_kind: property + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.property.http-method + polarity: asserted + value: POST + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0014 + assertion_kind: property + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.property.http-route + polarity: asserted + value: /items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0015 + assertion_kind: relation + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.items + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0016 + assertion_kind: relation + subject: operation.openapi.estate-security-api.createItem + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.Item + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/requestBody/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + role: fiam.shape-role.request +- id: assertion.openapi.0017 + assertion_kind: relation + subject: binding.openapi.estate-security-api.1 + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.openapi.estate-security-api.Item + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1items/post/requestBody/content/application~1json/schema' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + operation_ref: operation.openapi.estate-security-api.createItem + role: fiam.shape-role.request + representation: fiam.representation.json +- id: assertion.openapi.0018 + assertion_kind: property + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.property.security-override + polarity: asserted + value: anonymous-alternative + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0019 + assertion_kind: property + subject: security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + predicate: fiam.property.security-override + polarity: asserted + value: required + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get/security/1/oidc' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + applies_to: operation.openapi.estate-security-api.optionalInfo +- id: assertion.openapi.0020 + assertion_kind: property + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0021 + assertion_kind: property + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.property.http-route + polarity: asserted + value: /optional + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0022 + assertion_kind: relation + subject: operation.openapi.estate-security-api.optionalInfo + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.optional + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1optional/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0023 + assertion_kind: property + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.property.security-override + polarity: asserted + value: none + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get/security' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0024 + assertion_kind: property + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0025 + assertion_kind: property + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.property.http-route + polarity: asserted + value: /public + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0026 + assertion_kind: relation + subject: operation.openapi.estate-security-api.publicInfo + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.estate-security-api.public + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.estate-security-api + locator: '#/paths/~1public/get' + metadata: + source_url: real-world/openapi/estate-hardening/security-api.yaml + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports diff --git a/history/FIAM_v0.2_Draft6/real-world/openapi/estate-hardening/security-api.security-coverage.yaml b/history/FIAM_v0.2_Draft6/real-world/openapi/estate-hardening/security-api.security-coverage.yaml new file mode 100644 index 0000000..cc547e6 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/openapi/estate-hardening/security-api.security-coverage.yaml @@ -0,0 +1,49 @@ +lens: fiam.lens.security-coverage +model: model.openapi.estate-security-api +summary: + anonymous-access-allowed: 1 + explicitly-unprotected: 1 + inherited-contract-security: 1 + operation-specific: 1 +operations: +- operation_ref: operation.openapi.estate-security-api.createItem + contract_ref: contract.openapi.estate-security-api + classification: operation-specific + alternatives: + - alternative: 1 + all_of: + - profile: security.openapi.estate-security-api.operation.openapi.estate-security-api.createItem.1.apiKey + authentication: fiam.security.authentication.api-key + scheme: apiKey + scopes: [] + runtime_observability: not-inferred-from-generic-OTLP +- operation_ref: operation.openapi.estate-security-api.listItems + contract_ref: contract.openapi.estate-security-api + classification: inherited-contract-security + alternatives: + - alternative: 1 + all_of: + - profile: security.openapi.estate-security-api.contract.openapi.estate-security-api.1.oidc + authentication: fiam.security.authentication.openid-connect + scheme: oidc + scopes: + - items.read + runtime_observability: not-inferred-from-generic-OTLP +- operation_ref: operation.openapi.estate-security-api.optionalInfo + contract_ref: contract.openapi.estate-security-api + classification: anonymous-access-allowed + alternatives: + - alternative: 2 + all_of: + - profile: security.openapi.estate-security-api.operation.openapi.estate-security-api.optionalInfo.2.oidc + authentication: fiam.security.authentication.openid-connect + scheme: oidc + scopes: [] + runtime_observability: not-inferred-from-generic-OTLP +- operation_ref: operation.openapi.estate-security-api.publicInfo + contract_ref: contract.openapi.estate-security-api + classification: explicitly-unprotected + alternatives: [] + runtime_observability: not-inferred-from-generic-OTLP +note: Generic OTLP does not prove authentication presence/absence; this lens reports declared coverage only unless an explicit + security telemetry source is added. diff --git a/history/FIAM_v0.2_Draft6/real-world/openapi/estate-hardening/security-api.yaml b/history/FIAM_v0.2_Draft6/real-world/openapi/estate-hardening/security-api.yaml new file mode 100644 index 0000000..4890772 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/openapi/estate-hardening/security-api.yaml @@ -0,0 +1,58 @@ +openapi: 3.2.0 +info: + title: Estate Security API + version: 1.0.0 +servers: + - url: https://security.example.test +components: + schemas: + Item: + type: object + properties: + id: {type: string} + securitySchemes: + oidc: + type: openIdConnect + openIdConnectUrl: https://id.example.test/.well-known/openid-configuration + apiKey: + type: apiKey + in: header + name: X-API-Key +security: + - oidc: [items.read] +paths: + /items: + get: + operationId: listItems + responses: + '200': + description: ok + content: + application/json: + schema: + type: array + items: {$ref: '#/components/schemas/Item'} + post: + operationId: createItem + security: + - apiKey: [] + requestBody: + content: + application/json: + schema: {$ref: '#/components/schemas/Item'} + responses: + '204': {description: created} + /optional: + get: + operationId: optionalInfo + security: + - {} + - oidc: [] + responses: + '200': {description: ok} + /public: + get: + operationId: publicInfo + security: [] + responses: + '200': {description: ok} diff --git a/history/FIAM_v0.2_Draft6/real-world/openapi/petstore-identity-excerpt.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/openapi/petstore-identity-excerpt.fiam.yaml new file mode 100644 index 0000000..f1cb499 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/openapi/petstore-identity-excerpt.fiam.yaml @@ -0,0 +1,369 @@ +fiam_version: '0.2' +instance: + id: model.openapi.swagger-petstore---identity-ingest-excerpt + kind: model + title: OpenAPI ingest — Swagger Petstore - identity ingest excerpt + status: provisional + intent: Declared FIAM architecture model generated from an OpenAPI 3.x description. +nodes: +- id: node.openapi.swagger-petstore---identity-ingest-excerpt + kind: system-node + name: Swagger Petstore - identity ingest excerpt + node_type: fiam.node-type.service +ports: +- id: port.openapi.swagger-petstore---identity-ingest-excerpt + owner: node.openapi.swagger-petstore---identity-ingest-excerpt + participations: + - contract: contract.openapi.swagger-petstore---identity-ingest-excerpt + mode: offers +contracts: +- id: contract.openapi.swagger-petstore---identity-ingest-excerpt + kind: interface-contract + name: Swagger Petstore - identity ingest excerpt + contract_forms: + - fiam.contract-form.openapi + operations: + - id: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + kind: operation + name: Find pet by ID + description: '' + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read + purpose: + - fiam.purpose.query + x-http-method: GET + x-openapi-path: /pet/{petId} + x-openapi-operation-id: getPetById +endpoints: +- id: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + kind: endpoint + name: OpenAPI server 1 + address: https://petstore3.swagger.io/api/v3 + address_scheme: fiam.address-scheme.https-url +bindings: +- id: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + kind: binding + contract: contract.openapi.swagger-petstore---identity-ingest-excerpt + provider_port: port.openapi.swagger-petstore---identity-ingest-excerpt + endpoints: + - endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById +information_resources: +- id: resource.openapi.swagger-petstore---identity-ingest-excerpt.pet-petId + kind: information-resource + owner: node.openapi.swagger-petstore---identity-ingest-excerpt + name: /pet/{petId} + resource_kind: fiam.information-resource.api-resource-object + resource_scope: fiam.resource-scope.logical-selection + selectors: + - kind: fiam.resource-selector.http-path-template + value: /pet/{petId} +information_shapes: +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + kind: information-shape + name: Category + shape_kind: fiam.information-shape.object + facets: + openapi_component: Category +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + kind: information-shape + name: Tag + shape_kind: fiam.information-shape.object + facets: + openapi_component: Tag +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + kind: information-shape + name: Pet + shape_kind: fiam.information-shape.object + facets: + openapi_component: Pet +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + kind: information-shape + name: Pet.photoUrls + shape_kind: fiam.information-shape.collection + facets: + openapi_pointer: '#/components/schemas/Pet/properties/photoUrls' +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls-element.4eb61207 + kind: information-shape + name: Pet.photoUrls element + shape_kind: fiam.information-shape.scalar + facets: + openapi_pointer: '#/components/schemas/Pet/properties/photoUrls/items' +- id: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + kind: information-shape + name: Pet.tags + shape_kind: fiam.information-shape.collection + facets: + openapi_pointer: '#/components/schemas/Pet/properties/tags' +artifacts: +- id: artifact.openapi.swagger-petstore---identity-ingest-excerpt + kind: artifact + name: petstore-identity-excerpt.yaml + artifact_type: fiam.artifact.api-description + describes: + - contract.openapi.swagger-petstore---identity-ingest-excerpt + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + - shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls-element.4eb61207 + - shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + locator: https://petstore3.swagger.io/api/v3/openapi.json + facets: + openapi_version: 3.0.4 + document_version: 1.0.27 + source_file: petstore-identity-excerpt.yaml + source_note: Normalized semantic excerpt from live Swagger Petstore 1.0.27; examples, XML metadata and unrelated paths/components + intentionally omitted. +assertions: +- id: assertion.openapi.0001 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/category' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + slot: category + role: fiam.shape-role.envelope-member +- id: assertion.openapi.0002 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls-element.4eb61207 + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/photoUrls/items' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + slot: items + role: fiam.shape-role.element +- id: assertion.openapi.0003 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.photoUrls.e31beede + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/photoUrls' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + slot: photoUrls + role: fiam.shape-role.envelope-member +- id: assertion.openapi.0004 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/tags/items' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + slot: items + role: fiam.shape-role.element +- id: assertion.openapi.0005 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.inline.Pet.tags.ecde95fc + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/components/schemas/Pet/properties/tags' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + slot: tags + role: fiam.shape-role.envelope-member +- id: assertion.openapi.0006 + assertion_kind: property + subject: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/servers/0' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0007 + assertion_kind: property + subject: endpoint.openapi.swagger-petstore---identity-ingest-excerpt.1 + predicate: fiam.property.server-address + polarity: asserted + value: petstore3.swagger.io + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/servers/0/url' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0008 + assertion_kind: property + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0009 + assertion_kind: property + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.property.http-route + polarity: asserted + value: /pet/{petId} + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0010 + assertion_kind: relation + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.openapi.swagger-petstore---identity-ingest-excerpt.pet-petId + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports +- id: assertion.openapi.0011 + assertion_kind: relation + subject: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get/responses/200/content/application~1json/schema' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + role: fiam.shape-role.response +- id: assertion.openapi.0012 + assertion_kind: relation + subject: binding.openapi.swagger-petstore---identity-ingest-excerpt.1 + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Pet + evidence: + mode: fiam.evidence.declared + source: + type: openapi-document + ref: artifact.openapi.swagger-petstore---identity-ingest-excerpt + locator: '#/paths/~1pet~1{petId}/get/responses/200/content/application~1json/schema' + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + observer: openapi-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + facets: + operation_ref: operation.openapi.swagger-petstore---identity-ingest-excerpt.getPetById + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.openapi.0013 + assertion_kind: relation + subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + evidence: + mode: fiam.evidence.inferred + source: + type: schema-structural-fingerprint + ref: schema-structural-fingerprint + locator: fingerprint:sha256:43efaa02d70c55fa422ad1c0aa4bd532aac402499711a1f450bc1fab3efec4b4 + metadata: + source_url: https://petstore3.swagger.io/api/v3/openapi.json + left: '#/components/schemas/Category' + right: '#/components/schemas/Tag' + algorithm: normalized-openapi-schema-sha256 + observer: openapi-ingest/v0.2-draft.4 + confidence: 0.75 + stance: supports diff --git a/history/FIAM_v0.2_Draft6/real-world/openapi/petstore-identity-excerpt.yaml b/history/FIAM_v0.2_Draft6/real-world/openapi/petstore-identity-excerpt.yaml new file mode 100644 index 0000000..5409f57 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/openapi/petstore-identity-excerpt.yaml @@ -0,0 +1,68 @@ +openapi: 3.0.4 +info: + title: Swagger Petstore - identity ingest excerpt + version: 1.0.27 + description: Normalized subset of the live Swagger Petstore OpenAPI document, retaining one operation and three component + schemas for FIAM ingest/identity testing. +servers: +- url: https://petstore3.swagger.io/api/v3 +paths: + /pet/{petId}: + get: + operationId: getPetById + summary: Find pet by ID + responses: + '200': + description: successful operation + content: + application/json: + schema: + $ref: '#/components/schemas/Pet' +components: + schemas: + Category: + type: object + properties: + id: + type: integer + format: int64 + name: + type: string + Tag: + type: object + properties: + id: + type: integer + format: int64 + name: + type: string + Pet: + type: object + required: + - name + - photoUrls + properties: + id: + type: integer + format: int64 + name: + type: string + category: + $ref: '#/components/schemas/Category' + photoUrls: + type: array + items: + type: string + tags: + type: array + items: + $ref: '#/components/schemas/Tag' + status: + type: string + enum: + - available + - pending + - sold +x-source-url: https://petstore3.swagger.io/api/v3/openapi.json +x-source-note: Normalized semantic excerpt from live Swagger Petstore 1.0.27; examples, XML metadata and unrelated paths/components + intentionally omitted. diff --git a/history/FIAM_v0.2_Draft6/real-world/openapi/petstore-identity-view.yaml b/history/FIAM_v0.2_Draft6/real-world/openapi/petstore-identity-view.yaml new file mode 100644 index 0000000..11be033 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/openapi/petstore-identity-view.yaml @@ -0,0 +1,15 @@ +policy: + query_semantics: Asserted same-entity-as defines query-time equivalence only; ids and evidence remain distinct. + default_inferred_threshold: 0.98 + required_independent_signals: 2 + automatic_promotion: disabled +equivalence_classes: [] +correspondence_candidates: +- subject: shape.openapi.swagger-petstore---identity-ingest-excerpt.Category + object_ref: shape.openapi.swagger-petstore---identity-ingest-excerpt.Tag + assertion_id: assertion.openapi.0009 + evidence_confidences: + - 0.75 + meets_default_inferred_signal_threshold: false + automatic_promotion: never + recommended_next_state: remain corresponds-to diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/ambiguous-http.otlp.json b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/ambiguous-http.otlp.json new file mode 100644 index 0000000..a1a3d34 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/ambiguous-http.otlp.json @@ -0,0 +1,65 @@ +{ + "resourceSpans": [ + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "gateway-observed" + } + }, + { + "key": "deployment.environment.name", + "value": { + "stringValue": "production" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "fixture" + }, + "spans": [ + { + "traceId": "88888888888888888888888888888888", + "spanId": "3333333333333333", + "kind": 2, + "name": "GET /pets/{id}", + "startTimeUnixNano": "1788937200000000000", + "endTimeUnixNano": "1788937200001000000", + "attributes": [ + { + "key": "http.request.method", + "value": { + "stringValue": "GET" + } + }, + { + "key": "http.route", + "value": { + "stringValue": "/pets/{id}" + } + }, + { + "key": "network.protocol.version", + "value": { + "stringValue": "2" + } + }, + { + "key": "http.response.status_code", + "value": { + "intValue": "200" + } + } + ] + } + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/gateway-rpc.otlp.json b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/gateway-rpc.otlp.json new file mode 100644 index 0000000..b4add33 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/gateway-rpc.otlp.json @@ -0,0 +1,133 @@ +{ + "resourceSpans": [ + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Telemetry Client" + } + }, + { + "key": "deployment.environment.name", + "value": { + "stringValue": "production" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "fixture" + }, + "spans": [ + { + "traceId": "77777777777777777777777777777777", + "spanId": "1111111111111111", + "kind": 3, + "name": "TelemetryService/StreamTelemetry", + "startTimeUnixNano": "1788937200000000000", + "endTimeUnixNano": "1788937200001000000", + "attributes": [ + { + "key": "rpc.system.name", + "value": { + "stringValue": "grpc" + } + }, + { + "key": "rpc.method", + "value": { + "stringValue": "TelemetryService/StreamTelemetry" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "telemetry.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "4317" + } + }, + { + "key": "service.peer.name", + "value": { + "stringValue": "Telemetry Aggregator" + } + } + ] + } + ] + } + ] + }, + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "istio-proxy" + } + }, + { + "key": "deployment.environment.name", + "value": { + "stringValue": "production" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "fixture" + }, + "spans": [ + { + "traceId": "77777777777777777777777777777777", + "spanId": "2222222222222222", + "kind": 2, + "name": "TelemetryService/StreamTelemetry", + "startTimeUnixNano": "1788937200001000000", + "endTimeUnixNano": "1788937200002000000", + "attributes": [ + { + "key": "rpc.system.name", + "value": { + "stringValue": "grpc" + } + }, + { + "key": "rpc.method", + "value": { + "stringValue": "TelemetryService/StreamTelemetry" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "telemetry.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "4317" + } + } + ], + "parentSpanId": "1111111111111111" + } + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/multi-environment-same-service.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/multi-environment-same-service.fiam.yaml new file mode 100644 index 0000000..f6065d8 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/multi-environment-same-service.fiam.yaml @@ -0,0 +1,1006 @@ +fiam_version: '0.2' +instance: + id: model.otel.catalog.multi-environment-same-service.otlp + kind: model + title: OpenTelemetry runtime catalog — multi-environment-same-service.otlp.json + status: provisional + intent: Incremental runtime-observed FIAM architecture catalog generated from OTLP/JSON traces. +extensions: + org.fiam.catalog: + version: 0.2-draft.4 + processed_batches: + - 656bc4d902ff5021181fd11c940ca031d229374bfa7126f549415c9cf3aa5bd6 + declared_entity_ids: [] + last_ingest_at: '2026-09-09T07:00:01Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: sample + sample_size: 3 + org.fiam.runtime_aggregates: + - id: aggregate.otel.601422a02280880a31bcc77b + domain: http + role: server + operation: operation.otel.http.GET--health.530d5e19fd7d + binding: binding.otel.http.payments-svc.internal.dc67574d063d + local_node: node.otel.service.billing.payments.ee44a67aa292 + remote_node: null + channel: null + resource: null + method: GET + route: /health + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:01Z' + last_seen: '2026-09-09T07:00:01Z' + sample_spans: + - trace:66666666666666666666666666666666/span:ffffffffffffffff + - id: aggregate.otel.f22666a8f28c36e51b8a30dc + domain: http + role: server + operation: operation.otel.http.GET--health.1bca5d9ba934 + binding: binding.otel.http.payments-svc.internal.01e5f92d98ee + local_node: node.otel.service.billing.payments.64dd7995e506 + remote_node: null + channel: null + resource: null + method: GET + route: /health + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:00Z' + last_seen: '2026-09-09T07:00:00Z' + sample_spans: + - trace:55555555555555555555555555555555/span:eeeeeeeeeeeeeeee + org.fiam.runtime_topology_observations: [] + org.fiam.runtime_unresolved: [] + org.fiam.reconciliation_candidates: [] +artifacts: +- id: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + kind: artifact + name: OTLP runtime stream + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + facets: + format: OTLP/JSON + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + latest_batch_hash: 656bc4d902ff5021181fd11c940ca031d229374bfa7126f549415c9cf3aa5bd6 + describes: + - interaction.sample.601422a02280880a31bcc77b.ffffffffffffffff + - interaction.sample.f22666a8f28c36e51b8a30dc.eeeeeeeeeeeeeeee +zones: +- id: zone.otel.cluster.prod-eu1.160e33b268c2 + kind: zone + name: prod-eu1 + zone_type: fiam.zone-type.cluster + members: + - node.otel.service.billing.payments.64dd7995e506 + parent: zone.otel.environment.production.1521d207f3b6 +- id: zone.otel.cluster.stg-eu1.555e4e8f22d0 + kind: zone + name: stg-eu1 + zone_type: fiam.zone-type.cluster + members: + - node.otel.service.billing.payments.ee44a67aa292 + parent: zone.otel.environment.staging.1c755e62060a +- id: zone.otel.environment.production.1521d207f3b6 + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.otel.service.billing.payments.64dd7995e506 +- id: zone.otel.environment.staging.1c755e62060a + kind: zone + name: staging + zone_type: fiam.zone-type.deployment-environment + members: + - node.otel.service.billing.payments.ee44a67aa292 +nodes: +- id: node.otel.service.billing.payments.64dd7995e506 + kind: system-node + name: payments + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: billing + service_name: payments + environment: production + cluster_name: prod-eu1 +- id: node.otel.service.billing.payments.ee44a67aa292 + kind: system-node + name: payments + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: billing + service_name: payments + environment: staging + cluster_name: stg-eu1 +ports: +- id: port.otel.http.payments.0053aa499fed + kind: port + owner: node.otel.service.billing.payments.ee44a67aa292 + participations: + - contract: contract.otel.http.payments.9388c06e1e22 + mode: offers + roles: + - fiam.role.server +- id: port.otel.http.payments.60591bcbc87e + kind: port + owner: node.otel.service.billing.payments.64dd7995e506 + participations: + - contract: contract.otel.http.payments.1ba6edca2397 + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.otel.http.payments.1ba6edca2397 + kind: interface-contract + name: Observed HTTP surface — payments + operations: + - id: operation.otel.http.GET--health.1bca5d9ba934 + kind: operation + name: GET /health + interaction_style: fiam.interaction-style.request-response + x-http-method: GET + x-http-route: /health +- id: contract.otel.http.payments.9388c06e1e22 + kind: interface-contract + name: Observed HTTP surface — payments + operations: + - id: operation.otel.http.GET--health.530d5e19fd7d + kind: operation + name: GET /health + interaction_style: fiam.interaction-style.request-response + x-http-method: GET + x-http-route: /health +endpoints: +- id: endpoint.otel.http.svc.internal.11433a67a0e7 + kind: endpoint + name: svc.internal + address_scheme: fiam.address-scheme.https-url + facets: + identity_tuple: + address: https://svc.internal + address_scheme: fiam.address-scheme.https-url + zone: + - production + - prod-eu1 + - '' + - '' + - '' + logical_server_address: svc.internal + address: https://svc.internal +- id: endpoint.otel.http.svc.internal.5a8e84eebbf1 + kind: endpoint + name: svc.internal + address_scheme: fiam.address-scheme.https-url + facets: + identity_tuple: + address: https://svc.internal + address_scheme: fiam.address-scheme.https-url + zone: + - staging + - stg-eu1 + - '' + - '' + - '' + logical_server_address: svc.internal + address: https://svc.internal +bindings: +- id: binding.otel.http.payments-svc.internal.01e5f92d98ee + kind: binding + contract: contract.otel.http.payments.1ba6edca2397 + provider_port: port.otel.http.payments.60591bcbc87e + endpoints: + - endpoint.otel.http.svc.internal.11433a67a0e7 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.otel.http.GET--health.1bca5d9ba934 + facets: + identity_tuple: + kind: http-binding + service_node: node.otel.service.billing.payments.64dd7995e506 + server_address: svc.internal + server_port: 443 + zone: + - production + - prod-eu1 + - '' + - '' + - '' +- id: binding.otel.http.payments-svc.internal.dc67574d063d + kind: binding + contract: contract.otel.http.payments.9388c06e1e22 + provider_port: port.otel.http.payments.0053aa499fed + endpoints: + - endpoint.otel.http.svc.internal.5a8e84eebbf1 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.otel.http.GET--health.530d5e19fd7d + facets: + identity_tuple: + kind: http-binding + service_node: node.otel.service.billing.payments.ee44a67aa292 + server_address: svc.internal + server_port: 443 + zone: + - staging + - stg-eu1 + - '' + - '' + - '' +assertions: +- id: assertion.otel.0bd36b1ca8bac94ca410 + assertion_kind: property + subject: binding.otel.http.payments-svc.internal.dc67574d063d + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: aggregate:601422a02280880a31bcc77b + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:601422a02280880a31bcc77b + aggregation_key: 601422a02280880a31bcc77b + sample_spans: + - trace:66666666666666666666666666666666/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: &id001 + aggregation_key: 601422a02280880a31bcc77b + domain: http + role: server + operation_ref: operation.otel.http.GET--health.530d5e19fd7d + local_node_ref: node.otel.service.billing.payments.ee44a67aa292 + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.115526186ece2ff17e67 + assertion_kind: property + subject: operation.otel.http.GET--health.530d5e19fd7d + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:http.request.method + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.request.method + sample_spans: + - trace:66666666666666666666666666666666/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.1a0cea22cece3dee13f4 + assertion_kind: property + subject: binding.otel.http.payments-svc.internal.dc67574d063d + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: aggregate:601422a02280880a31bcc77b + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:601422a02280880a31bcc77b + aggregation_key: 601422a02280880a31bcc77b + sample_spans: + - trace:66666666666666666666666666666666/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.1da9d8631c04bbbe311a + assertion_kind: property + subject: binding.otel.http.payments-svc.internal.01e5f92d98ee + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:network.protocol.version + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:network.protocol.version + sample_spans: + - trace:55555555555555555555555555555555/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.2dc2c17a6768b5df832b + assertion_kind: property + subject: endpoint.otel.http.svc.internal.11433a67a0e7 + predicate: fiam.property.server-address + polarity: asserted + value: svc.internal + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:server.address + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:server.address + sample_spans: + - trace:55555555555555555555555555555555/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.320410a2a561f4985aac + assertion_kind: property + subject: endpoint.otel.http.svc.internal.11433a67a0e7 + predicate: fiam.property.server-port + polarity: asserted + value: 443 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:server.port + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:server.port + sample_spans: + - trace:55555555555555555555555555555555/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.393f4d2a69596f2b0549 + assertion_kind: property + subject: node.otel.service.billing.payments.ee44a67aa292 + predicate: fiam.property.service-namespace + polarity: asserted + value: billing + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:service.namespace + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.namespace + sample_spans: + - trace:66666666666666666666666666666666/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.4108cb1fd1838330a6d4 + assertion_kind: property + subject: endpoint.otel.http.svc.internal.5a8e84eebbf1 + predicate: fiam.property.server-port + polarity: asserted + value: 443 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:server.port + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:server.port + sample_spans: + - trace:66666666666666666666666666666666/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.512b89d0b4828b20f2b8 + assertion_kind: property + subject: interaction.sample.f22666a8f28c36e51b8a30dc.eeeeeeeeeeeeeeee + predicate: fiam.property.http-response-status-code + polarity: asserted + value: 200 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:http.response.status_code + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.response.status_code + sample_spans: + - trace:55555555555555555555555555555555/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.5ce08e13e3d0920d8080 + assertion_kind: property + subject: interaction.sample.601422a02280880a31bcc77b.ffffffffffffffff + predicate: fiam.property.http-response-status-code + polarity: asserted + value: 200 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:http.response.status_code + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.response.status_code + sample_spans: + - trace:66666666666666666666666666666666/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.85eb43d490d684d67401 + assertion_kind: property + subject: binding.otel.http.payments-svc.internal.dc67574d063d + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:01Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: aggregate:601422a02280880a31bcc77b + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:601422a02280880a31bcc77b + aggregation_key: 601422a02280880a31bcc77b + sample_spans: + - trace:66666666666666666666666666666666/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.9019dff02beab7248a92 + assertion_kind: property + subject: operation.otel.http.GET--health.530d5e19fd7d + predicate: fiam.property.http-route + polarity: asserted + value: /health + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:http.route + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.route + sample_spans: + - trace:66666666666666666666666666666666/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.9e23390ed28479b2ba58 + assertion_kind: property + subject: binding.otel.http.payments-svc.internal.01e5f92d98ee + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: aggregate:f22666a8f28c36e51b8a30dc + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:f22666a8f28c36e51b8a30dc + aggregation_key: f22666a8f28c36e51b8a30dc + sample_spans: + - trace:55555555555555555555555555555555/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: &id002 + aggregation_key: f22666a8f28c36e51b8a30dc + domain: http + role: server + operation_ref: operation.otel.http.GET--health.1bca5d9ba934 + local_node_ref: node.otel.service.billing.payments.64dd7995e506 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.a3630982580cd13d2534 + assertion_kind: property + subject: node.otel.service.billing.payments.ee44a67aa292 + predicate: fiam.property.service-name + polarity: asserted + value: payments + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:service.name + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:66666666666666666666666666666666/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.a5e1d360611b1b3c3838 + assertion_kind: property + subject: binding.otel.http.payments-svc.internal.dc67574d063d + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:network.protocol.version + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:network.protocol.version + sample_spans: + - trace:66666666666666666666666666666666/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.af11804d5dd72152c301 + assertion_kind: property + subject: operation.otel.http.GET--health.1bca5d9ba934 + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:http.request.method + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.request.method + sample_spans: + - trace:55555555555555555555555555555555/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.bbc9f89142fa1c72a539 + assertion_kind: property + subject: binding.otel.http.payments-svc.internal.dc67574d063d + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: aggregate:601422a02280880a31bcc77b + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:601422a02280880a31bcc77b + aggregation_key: 601422a02280880a31bcc77b + sample_spans: + - trace:66666666666666666666666666666666/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.c2fbf373d6ecc85c7a79 + assertion_kind: property + subject: binding.otel.http.payments-svc.internal.01e5f92d98ee + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: aggregate:f22666a8f28c36e51b8a30dc + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:f22666a8f28c36e51b8a30dc + aggregation_key: f22666a8f28c36e51b8a30dc + sample_spans: + - trace:55555555555555555555555555555555/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.d19e2f249cdbeb2ef847 + assertion_kind: property + subject: node.otel.service.billing.payments.64dd7995e506 + predicate: fiam.property.service-namespace + polarity: asserted + value: billing + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:service.namespace + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.namespace + sample_spans: + - trace:55555555555555555555555555555555/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.dbb44e105a5f5c348294 + assertion_kind: property + subject: binding.otel.http.payments-svc.internal.01e5f92d98ee + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: aggregate:f22666a8f28c36e51b8a30dc + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:f22666a8f28c36e51b8a30dc + aggregation_key: f22666a8f28c36e51b8a30dc + sample_spans: + - trace:55555555555555555555555555555555/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.e1cce2fc77b4055f166e + assertion_kind: property + subject: node.otel.service.billing.payments.64dd7995e506 + predicate: fiam.property.service-name + polarity: asserted + value: payments + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:service.name + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:55555555555555555555555555555555/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.e2cd7cf3929fcc58242e + assertion_kind: property + subject: binding.otel.http.payments-svc.internal.01e5f92d98ee + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: aggregate:f22666a8f28c36e51b8a30dc + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:f22666a8f28c36e51b8a30dc + aggregation_key: f22666a8f28c36e51b8a30dc + sample_spans: + - trace:55555555555555555555555555555555/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.eb34b1b3dd331a0122ca + assertion_kind: property + subject: endpoint.otel.http.svc.internal.5a8e84eebbf1 + predicate: fiam.property.server-address + polarity: asserted + value: svc.internal + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:server.address + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:server.address + sample_spans: + - trace:66666666666666666666666666666666/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.faf6480d3ce4ee0c4a0c + assertion_kind: property + subject: operation.otel.http.GET--health.1bca5d9ba934 + predicate: fiam.property.http-route + polarity: asserted + value: /health + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: attribute:http.route + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.route + sample_spans: + - trace:55555555555555555555555555555555/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.fe38404dc1c7705ae104 + assertion_kind: property + subject: binding.otel.http.payments-svc.internal.dc67574d063d + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:01Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: aggregate:601422a02280880a31bcc77b + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:601422a02280880a31bcc77b + aggregation_key: 601422a02280880a31bcc77b + sample_spans: + - trace:66666666666666666666666666666666/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.ffbf9f52efac13bab5dd + assertion_kind: property + subject: binding.otel.http.payments-svc.internal.01e5f92d98ee + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multi-environment-same-service.otlp.eb0c08c24334 + locator: aggregate:f22666a8f28c36e51b8a30dc + metadata: + source: real-world/otel/estate-hardening/multi-environment-same-service.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:f22666a8f28c36e51b8a30dc + aggregation_key: f22666a8f28c36e51b8a30dc + sample_spans: + - trace:55555555555555555555555555555555/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +interactions: +- id: interaction.sample.601422a02280880a31bcc77b.ffffffffffffffff + kind: interaction + operation: operation.otel.http.GET--health.530d5e19fd7d + contract: contract.otel.http.payments.9388c06e1e22 + binding: binding.otel.http.payments-svc.internal.dc67574d063d + interaction_style: fiam.interaction-style.request-response + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + responder: node.otel.service.billing.payments.ee44a67aa292 + facets: + otel_trace_id: '66666666666666666666666666666666' + otel_span_id: ffffffffffffffff + otel_span_kind: server + instrumentation_scope: fixture + observed_service: node.otel.service.billing.payments.ee44a67aa292 +- id: interaction.sample.f22666a8f28c36e51b8a30dc.eeeeeeeeeeeeeeee + kind: interaction + operation: operation.otel.http.GET--health.1bca5d9ba934 + contract: contract.otel.http.payments.1ba6edca2397 + binding: binding.otel.http.payments-svc.internal.01e5f92d98ee + interaction_style: fiam.interaction-style.request-response + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + responder: node.otel.service.billing.payments.64dd7995e506 + facets: + otel_trace_id: '55555555555555555555555555555555' + otel_span_id: eeeeeeeeeeeeeeee + otel_span_kind: server + instrumentation_scope: fixture + observed_service: node.otel.service.billing.payments.64dd7995e506 diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/multi-environment-same-service.otlp.json b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/multi-environment-same-service.otlp.json new file mode 100644 index 0000000..1aad351 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/multi-environment-same-service.otlp.json @@ -0,0 +1,174 @@ +{ + "resourceSpans": [ + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "payments" + } + }, + { + "key": "service.namespace", + "value": { + "stringValue": "billing" + } + }, + { + "key": "deployment.environment.name", + "value": { + "stringValue": "production" + } + }, + { + "key": "k8s.cluster.name", + "value": { + "stringValue": "prod-eu1" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "fixture" + }, + "spans": [ + { + "traceId": "55555555555555555555555555555555", + "spanId": "eeeeeeeeeeeeeeee", + "kind": 2, + "name": "GET /health", + "startTimeUnixNano": "1788937200000000000", + "endTimeUnixNano": "1788937200001000000", + "attributes": [ + { + "key": "http.request.method", + "value": { + "stringValue": "GET" + } + }, + { + "key": "http.route", + "value": { + "stringValue": "/health" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "svc.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "443" + } + }, + { + "key": "url.scheme", + "value": { + "stringValue": "https" + } + }, + { + "key": "http.response.status_code", + "value": { + "intValue": "200" + } + } + ] + } + ] + } + ] + }, + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "payments" + } + }, + { + "key": "service.namespace", + "value": { + "stringValue": "billing" + } + }, + { + "key": "deployment.environment.name", + "value": { + "stringValue": "staging" + } + }, + { + "key": "k8s.cluster.name", + "value": { + "stringValue": "stg-eu1" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "fixture" + }, + "spans": [ + { + "traceId": "66666666666666666666666666666666", + "spanId": "ffffffffffffffff", + "kind": 2, + "name": "GET /health", + "startTimeUnixNano": "1788937201000000000", + "endTimeUnixNano": "1788937201001000000", + "attributes": [ + { + "key": "http.request.method", + "value": { + "stringValue": "GET" + } + }, + { + "key": "http.route", + "value": { + "stringValue": "/health" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "svc.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "443" + } + }, + { + "key": "url.scheme", + "value": { + "stringValue": "https" + } + }, + { + "key": "http.response.status_code", + "value": { + "intValue": "200" + } + } + ] + } + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-db-no-resource.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-db-no-resource.fiam.yaml new file mode 100644 index 0000000..e2c782d --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-db-no-resource.fiam.yaml @@ -0,0 +1,427 @@ +fiam_version: '0.2' +instance: + id: model.otel.catalog.partial-db-no-resource.otlp + kind: model + title: OpenTelemetry runtime catalog — partial-db-no-resource.otlp.json + status: provisional + intent: Incremental runtime-observed FIAM architecture catalog generated from OTLP/JSON traces. +extensions: + org.fiam.catalog: + version: 0.2-draft.4 + processed_batches: + - 29678dbb79af1ea88a8df8becdc0c3fb2fb3ef0686c4f4d601b01b4711eb9306 + declared_entity_ids: [] + last_ingest_at: '2026-09-09T07:00:00Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: sample + sample_size: 3 + org.fiam.runtime_aggregates: + - id: aggregate.otel.2398bbdc294c3ad6372f847e + domain: database + role: client + operation: operation.otel.db.SELECT-namespace.a8e2c67964b4 + binding: binding.otel.db.worker-postgresql-db.internal:5432.30c1a1a62d47 + local_node: node.otel.service.worker.0770bd57ffcb + remote_node: node.otel.database.postgresql.db.internal:5432.cd3968b1790d + channel: null + resource: null + database_system: postgresql + effect: read + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:00Z' + last_seen: '2026-09-09T07:00:00Z' + sample_spans: + - trace:33333333333333333333333333333333/span:cccccccccccccccc + org.fiam.runtime_topology_observations: [] + org.fiam.runtime_unresolved: + - id: unresolved.database.ced055fd8ee08bc71c25 + domain: database + reason: database span identifies a system/operation but no stable namespace or collection resource + sample_span: trace:33333333333333333333333333333333/span:cccccccccccccccc + org.fiam.reconciliation_candidates: [] +artifacts: +- id: artifact.otel.stream.partial-db-no-resource.otlp.d3922f651b9b + kind: artifact + name: OTLP runtime stream + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/estate-hardening/partial-db-no-resource.otlp.json + facets: + format: OTLP/JSON + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + latest_batch_hash: 29678dbb79af1ea88a8df8becdc0c3fb2fb3ef0686c4f4d601b01b4711eb9306 + describes: + - interaction.sample.2398bbdc294c3ad6372f847e.cccccccccccccccc +zones: +- id: zone.otel.environment.production.1521d207f3b6 + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.otel.service.worker.0770bd57ffcb +nodes: +- id: node.otel.database.postgresql.db.internal:5432.cd3968b1790d + kind: system-node + name: postgresql at db.internal:5432 + node_type: fiam.node-type.database + facets: + identity_tuple: + kind: database + system: postgresql + logical_address: db.internal:5432 + zone: + - production + - '' + - '' + - '' + - '' +- id: node.otel.service.worker.0770bd57ffcb + kind: system-node + name: worker + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: worker + environment: production +ports: +- id: port.otel.db.worker-postgresql.e109bcd58fb8 + kind: port + owner: node.otel.service.worker.0770bd57ffcb + participations: + - contract: contract.otel.db.worker-postgresql.9fde94b8a328 + mode: requires + roles: + - fiam.role.database-client +contracts: +- id: contract.otel.db.worker-postgresql.9fde94b8a328 + kind: interface-contract + name: Observed postgresql client surface — worker + operations: + - id: operation.otel.db.SELECT-namespace.a8e2c67964b4 + kind: operation + name: SELECT + interaction_style: fiam.interaction-style.query + effect: fiam.effect.read +endpoints: +- id: endpoint.otel.db.db.internal:5432.8ee99dc3a4d7 + kind: endpoint + name: db.internal:5432 + address_scheme: fiam.address-scheme.host-port + facets: + identity_tuple: + address: db.internal:5432 + address_scheme: fiam.address-scheme.host-port + zone: + - production + - '' + - '' + - '' + - '' + logical_server_address: db.internal + address: db.internal:5432 +bindings: +- id: binding.otel.db.worker-postgresql-db.internal:5432.30c1a1a62d47 + kind: binding + contract: contract.otel.db.worker-postgresql.9fde94b8a328 + consumer_ports: + - port.otel.db.worker-postgresql.e109bcd58fb8 + operations: + - operation.otel.db.SELECT-namespace.a8e2c67964b4 + communication_stack: + - role: fiam.stack-role.database-protocol + term: fiam.protocol.postgresql-frontend-backend + facets: + identity_tuple: + kind: database-binding + service_node: node.otel.service.worker.0770bd57ffcb + system: postgresql + logical_address: db.internal:5432 + zone: + - production + - '' + - '' + - '' + - '' + endpoints: + - endpoint.otel.db.db.internal:5432.8ee99dc3a4d7 +assertions: +- id: assertion.otel.103db66bf037bf60c2dc + assertion_kind: property + subject: node.otel.service.worker.0770bd57ffcb + predicate: fiam.property.service-name + polarity: asserted + value: worker + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-db-no-resource.otlp.d3922f651b9b + locator: attribute:service.name + metadata: + source: real-world/otel/estate-hardening/partial-db-no-resource.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:33333333333333333333333333333333/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.18fa40bd5cd7c3ac3e2a + assertion_kind: property + subject: binding.otel.db.worker-postgresql-db.internal:5432.30c1a1a62d47 + predicate: fiam.property.database-system-name + polarity: asserted + value: postgresql + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-db-no-resource.otlp.d3922f651b9b + locator: attribute:db.system.name + metadata: + source: real-world/otel/estate-hardening/partial-db-no-resource.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.system.name + sample_spans: + - trace:33333333333333333333333333333333/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.47e9f28649447f25a112 + assertion_kind: property + subject: binding.otel.db.worker-postgresql-db.internal:5432.30c1a1a62d47 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.postgresql-frontend-backend + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-db-no-resource.otlp.d3922f651b9b + locator: attribute:db.system.name + metadata: + source: real-world/otel/estate-hardening/partial-db-no-resource.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.system.name + sample_spans: + - trace:33333333333333333333333333333333/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.686959c167dca5097e25 + assertion_kind: property + subject: binding.otel.db.worker-postgresql-db.internal:5432.30c1a1a62d47 + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-db-no-resource.otlp.d3922f651b9b + locator: aggregate:2398bbdc294c3ad6372f847e + metadata: + source: real-world/otel/estate-hardening/partial-db-no-resource.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2398bbdc294c3ad6372f847e + aggregation_key: 2398bbdc294c3ad6372f847e + sample_spans: + - trace:33333333333333333333333333333333/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: &id001 + aggregation_key: 2398bbdc294c3ad6372f847e + domain: database + role: client + operation_ref: operation.otel.db.SELECT-namespace.a8e2c67964b4 + local_node_ref: node.otel.service.worker.0770bd57ffcb + remote_node_ref: node.otel.database.postgresql.db.internal:5432.cd3968b1790d + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.8162b9d40bee7683c7e5 + assertion_kind: property + subject: binding.otel.db.worker-postgresql-db.internal:5432.30c1a1a62d47 + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-db-no-resource.otlp.d3922f651b9b + locator: aggregate:2398bbdc294c3ad6372f847e + metadata: + source: real-world/otel/estate-hardening/partial-db-no-resource.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2398bbdc294c3ad6372f847e + aggregation_key: 2398bbdc294c3ad6372f847e + sample_spans: + - trace:33333333333333333333333333333333/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.8f980ea4665114e62e39 + assertion_kind: property + subject: binding.otel.db.worker-postgresql-db.internal:5432.30c1a1a62d47 + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-db-no-resource.otlp.d3922f651b9b + locator: aggregate:2398bbdc294c3ad6372f847e + metadata: + source: real-world/otel/estate-hardening/partial-db-no-resource.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2398bbdc294c3ad6372f847e + aggregation_key: 2398bbdc294c3ad6372f847e + sample_spans: + - trace:33333333333333333333333333333333/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.b70c97b02d235c47bc6b + assertion_kind: property + subject: operation.otel.db.SELECT-namespace.a8e2c67964b4 + predicate: fiam.property.database-operation-name + polarity: asserted + value: SELECT + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-db-no-resource.otlp.d3922f651b9b + locator: attribute:db.operation.name + metadata: + source: real-world/otel/estate-hardening/partial-db-no-resource.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.operation.name + sample_spans: + - trace:33333333333333333333333333333333/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.e761ac55c6ba1f95e269 + assertion_kind: property + subject: binding.otel.db.worker-postgresql-db.internal:5432.30c1a1a62d47 + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-db-no-resource.otlp.d3922f651b9b + locator: aggregate:2398bbdc294c3ad6372f847e + metadata: + source: real-world/otel/estate-hardening/partial-db-no-resource.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2398bbdc294c3ad6372f847e + aggregation_key: 2398bbdc294c3ad6372f847e + sample_spans: + - trace:33333333333333333333333333333333/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.f1d9c3bd729c9af3f63e + assertion_kind: property + subject: binding.otel.db.worker-postgresql-db.internal:5432.30c1a1a62d47 + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-db-no-resource.otlp.d3922f651b9b + locator: aggregate:2398bbdc294c3ad6372f847e + metadata: + source: real-world/otel/estate-hardening/partial-db-no-resource.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2398bbdc294c3ad6372f847e + aggregation_key: 2398bbdc294c3ad6372f847e + sample_spans: + - trace:33333333333333333333333333333333/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +interactions: +- id: interaction.sample.2398bbdc294c3ad6372f847e.cccccccccccccccc + kind: interaction + operation: operation.otel.db.SELECT-namespace.a8e2c67964b4 + contract: contract.otel.db.worker-postgresql.9fde94b8a328 + binding: binding.otel.db.worker-postgresql-db.internal:5432.30c1a1a62d47 + interaction_style: fiam.interaction-style.query + temporal_semantics: fiam.temporal.synchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + initiator: node.otel.service.worker.0770bd57ffcb + responder: node.otel.database.postgresql.db.internal:5432.cd3968b1790d + facets: + otel_trace_id: '33333333333333333333333333333333' + otel_span_id: cccccccccccccccc + otel_span_kind: client + instrumentation_scope: fixture + observed_service: node.otel.service.worker.0770bd57ffcb diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-db-no-resource.otlp.json b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-db-no-resource.otlp.json new file mode 100644 index 0000000..dca5c80 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-db-no-resource.otlp.json @@ -0,0 +1,65 @@ +{ + "resourceSpans": [ + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "worker" + } + }, + { + "key": "deployment.environment.name", + "value": { + "stringValue": "production" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "fixture" + }, + "spans": [ + { + "traceId": "33333333333333333333333333333333", + "spanId": "cccccccccccccccc", + "kind": 3, + "name": "SELECT", + "startTimeUnixNano": "1788937200000000000", + "endTimeUnixNano": "1788937200001000000", + "attributes": [ + { + "key": "db.system.name", + "value": { + "stringValue": "postgresql" + } + }, + { + "key": "db.operation.name", + "value": { + "stringValue": "SELECT" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "db.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "5432" + } + } + ] + } + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-http-no-route.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-http-no-route.fiam.yaml new file mode 100644 index 0000000..86cc0dc --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-http-no-route.fiam.yaml @@ -0,0 +1,520 @@ +fiam_version: '0.2' +instance: + id: model.otel.catalog.partial-http-no-route.otlp + kind: model + title: OpenTelemetry runtime catalog — partial-http-no-route.otlp.json + status: provisional + intent: Incremental runtime-observed FIAM architecture catalog generated from OTLP/JSON traces. +extensions: + org.fiam.catalog: + version: 0.2-draft.4 + processed_batches: + - 37be1eeb9a2073af32fc9d6facc790f5165c79664b5b4eb297482baa8d4e463c + declared_entity_ids: [] + last_ingest_at: '2026-09-09T07:00:00Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: sample + sample_size: 3 + org.fiam.runtime_aggregates: + - id: aggregate.otel.73cf5028302912a084cce12d + domain: http + role: server + operation: operation.otel.http.GET-unknown-route.440f6bec7704 + binding: binding.otel.http.orders-api-orders.example.internal.e1b6030b885a + local_node: node.otel.service.commerce.orders-api.b34fc33498db + remote_node: null + channel: null + resource: null + method: GET + route: unknown-route + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:00Z' + last_seen: '2026-09-09T07:00:00Z' + sample_spans: + - trace:44444444444444444444444444444444/span:dddddddddddddddd + org.fiam.runtime_topology_observations: [] + org.fiam.runtime_unresolved: + - id: unresolved.http-route.b185d0f87ef9b250274d + domain: http + reason: HTTP span has no low-cardinality http.route; mapped to unknown-route and raw url.path was not promoted into architecture + identity + sample_span: trace:44444444444444444444444444444444/span:dddddddddddddddd + org.fiam.reconciliation_candidates: [] +artifacts: +- id: artifact.otel.stream.partial-http-no-route.otlp.d4012c138339 + kind: artifact + name: OTLP runtime stream + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/estate-hardening/partial-http-no-route.otlp.json + facets: + format: OTLP/JSON + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + latest_batch_hash: 37be1eeb9a2073af32fc9d6facc790f5165c79664b5b4eb297482baa8d4e463c + describes: + - interaction.sample.73cf5028302912a084cce12d.dddddddddddddddd +zones: +- id: zone.otel.environment.production.1521d207f3b6 + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.otel.service.commerce.orders-api.b34fc33498db +nodes: +- id: node.otel.service.commerce.orders-api.b34fc33498db + kind: system-node + name: orders-api + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: commerce + service_name: orders-api + environment: production +ports: +- id: port.otel.http.orders-api.5ed85d04bee2 + kind: port + owner: node.otel.service.commerce.orders-api.b34fc33498db + participations: + - contract: contract.otel.http.orders-api.864d6e5ea200 + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.otel.http.orders-api.864d6e5ea200 + kind: interface-contract + name: Observed HTTP surface — orders-api + operations: + - id: operation.otel.http.GET-unknown-route.440f6bec7704 + kind: operation + name: GET unknown-route + interaction_style: fiam.interaction-style.request-response + x-http-method: GET + x-http-route: unknown-route +endpoints: +- id: endpoint.otel.http.orders.example.internal.f18408429ad4 + kind: endpoint + name: orders.example.internal + address_scheme: fiam.address-scheme.https-url + facets: + identity_tuple: + address: https://orders.example.internal + address_scheme: fiam.address-scheme.https-url + zone: + - production + - '' + - '' + - '' + - '' + logical_server_address: orders.example.internal + address: https://orders.example.internal +bindings: +- id: binding.otel.http.orders-api-orders.example.internal.e1b6030b885a + kind: binding + contract: contract.otel.http.orders-api.864d6e5ea200 + provider_port: port.otel.http.orders-api.5ed85d04bee2 + endpoints: + - endpoint.otel.http.orders.example.internal.f18408429ad4 + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http2 + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + operations: + - operation.otel.http.GET-unknown-route.440f6bec7704 + facets: + identity_tuple: + kind: http-binding + service_node: node.otel.service.commerce.orders-api.b34fc33498db + server_address: orders.example.internal + server_port: 443 + zone: + - production + - '' + - '' + - '' + - '' +assertions: +- id: assertion.otel.0fe996a77e26e51fe1e1 + assertion_kind: property + subject: node.otel.service.commerce.orders-api.b34fc33498db + predicate: fiam.property.service-namespace + polarity: asserted + value: commerce + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-http-no-route.otlp.d4012c138339 + locator: attribute:service.namespace + metadata: + source: real-world/otel/estate-hardening/partial-http-no-route.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.namespace + sample_spans: + - trace:44444444444444444444444444444444/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.1892b5365dc0e2fb3441 + assertion_kind: property + subject: binding.otel.http.orders-api-orders.example.internal.e1b6030b885a + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-http-no-route.otlp.d4012c138339 + locator: aggregate:73cf5028302912a084cce12d + metadata: + source: real-world/otel/estate-hardening/partial-http-no-route.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:73cf5028302912a084cce12d + aggregation_key: 73cf5028302912a084cce12d + sample_spans: + - trace:44444444444444444444444444444444/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: &id001 + aggregation_key: 73cf5028302912a084cce12d + domain: http + role: server + operation_ref: operation.otel.http.GET-unknown-route.440f6bec7704 + local_node_ref: node.otel.service.commerce.orders-api.b34fc33498db + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.2ff319124460ed6c25ec + assertion_kind: property + subject: binding.otel.http.orders-api-orders.example.internal.e1b6030b885a + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-http-no-route.otlp.d4012c138339 + locator: aggregate:73cf5028302912a084cce12d + metadata: + source: real-world/otel/estate-hardening/partial-http-no-route.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:73cf5028302912a084cce12d + aggregation_key: 73cf5028302912a084cce12d + sample_spans: + - trace:44444444444444444444444444444444/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.44faedc0c971e31c2227 + assertion_kind: property + subject: endpoint.otel.http.orders.example.internal.f18408429ad4 + predicate: fiam.property.server-port + polarity: asserted + value: 443 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-http-no-route.otlp.d4012c138339 + locator: attribute:server.port + metadata: + source: real-world/otel/estate-hardening/partial-http-no-route.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:server.port + sample_spans: + - trace:44444444444444444444444444444444/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.71526a6093429d662574 + assertion_kind: property + subject: binding.otel.http.orders-api-orders.example.internal.e1b6030b885a + predicate: fiam.property.network-protocol-version + polarity: asserted + value: '2' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-http-no-route.otlp.d4012c138339 + locator: attribute:network.protocol.version + metadata: + source: real-world/otel/estate-hardening/partial-http-no-route.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:network.protocol.version + sample_spans: + - trace:44444444444444444444444444444444/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.7ac96eadb7b42111f036 + assertion_kind: property + subject: operation.otel.http.GET-unknown-route.440f6bec7704 + predicate: fiam.property.http-method + polarity: asserted + value: GET + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-http-no-route.otlp.d4012c138339 + locator: attribute:http.request.method + metadata: + source: real-world/otel/estate-hardening/partial-http-no-route.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.request.method + sample_spans: + - trace:44444444444444444444444444444444/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.801eafc728a65db30353 + assertion_kind: property + subject: interaction.sample.73cf5028302912a084cce12d.dddddddddddddddd + predicate: fiam.property.http-response-status-code + polarity: asserted + value: 200 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-http-no-route.otlp.d4012c138339 + locator: attribute:http.response.status_code + metadata: + source: real-world/otel/estate-hardening/partial-http-no-route.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:http.response.status_code + sample_spans: + - trace:44444444444444444444444444444444/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.8271f9002093c6d4ad84 + assertion_kind: property + subject: binding.otel.http.orders-api-orders.example.internal.e1b6030b885a + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-http-no-route.otlp.d4012c138339 + locator: aggregate:73cf5028302912a084cce12d + metadata: + source: real-world/otel/estate-hardening/partial-http-no-route.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:73cf5028302912a084cce12d + aggregation_key: 73cf5028302912a084cce12d + sample_spans: + - trace:44444444444444444444444444444444/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.8647ef1b07fc1d056e7b + assertion_kind: property + subject: binding.otel.http.orders-api-orders.example.internal.e1b6030b885a + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.http2 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-http-no-route.otlp.d4012c138339 + locator: attribute:network.protocol.version + metadata: + source: real-world/otel/estate-hardening/partial-http-no-route.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:network.protocol.version + sample_spans: + - trace:44444444444444444444444444444444/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.88c36f2d8432558cb9b9 + assertion_kind: property + subject: binding.otel.http.orders-api-orders.example.internal.e1b6030b885a + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-http-no-route.otlp.d4012c138339 + locator: aggregate:73cf5028302912a084cce12d + metadata: + source: real-world/otel/estate-hardening/partial-http-no-route.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:73cf5028302912a084cce12d + aggregation_key: 73cf5028302912a084cce12d + sample_spans: + - trace:44444444444444444444444444444444/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.dd4afbbdb685514cfc5b + assertion_kind: property + subject: binding.otel.http.orders-api-orders.example.internal.e1b6030b885a + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-http-no-route.otlp.d4012c138339 + locator: aggregate:73cf5028302912a084cce12d + metadata: + source: real-world/otel/estate-hardening/partial-http-no-route.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:73cf5028302912a084cce12d + aggregation_key: 73cf5028302912a084cce12d + sample_spans: + - trace:44444444444444444444444444444444/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.fe2fb4e0c0e1cc563a74 + assertion_kind: property + subject: node.otel.service.commerce.orders-api.b34fc33498db + predicate: fiam.property.service-name + polarity: asserted + value: orders-api + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-http-no-route.otlp.d4012c138339 + locator: attribute:service.name + metadata: + source: real-world/otel/estate-hardening/partial-http-no-route.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:44444444444444444444444444444444/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.ffd6a5660f911ff2b2b1 + assertion_kind: property + subject: endpoint.otel.http.orders.example.internal.f18408429ad4 + predicate: fiam.property.server-address + polarity: asserted + value: orders.example.internal + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-http-no-route.otlp.d4012c138339 + locator: attribute:server.address + metadata: + source: real-world/otel/estate-hardening/partial-http-no-route.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:server.address + sample_spans: + - trace:44444444444444444444444444444444/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +interactions: +- id: interaction.sample.73cf5028302912a084cce12d.dddddddddddddddd + kind: interaction + operation: operation.otel.http.GET-unknown-route.440f6bec7704 + contract: contract.otel.http.orders-api.864d6e5ea200 + binding: binding.otel.http.orders-api-orders.example.internal.e1b6030b885a + interaction_style: fiam.interaction-style.request-response + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + responder: node.otel.service.commerce.orders-api.b34fc33498db + facets: + otel_trace_id: '44444444444444444444444444444444' + otel_span_id: dddddddddddddddd + otel_span_kind: server + instrumentation_scope: fixture + observed_service: node.otel.service.commerce.orders-api.b34fc33498db diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-http-no-route.otlp.json b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-http-no-route.otlp.json new file mode 100644 index 0000000..e34bb66 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-http-no-route.otlp.json @@ -0,0 +1,89 @@ +{ + "resourceSpans": [ + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "orders-api" + } + }, + { + "key": "service.namespace", + "value": { + "stringValue": "commerce" + } + }, + { + "key": "deployment.environment.name", + "value": { + "stringValue": "production" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "fixture" + }, + "spans": [ + { + "traceId": "44444444444444444444444444444444", + "spanId": "dddddddddddddddd", + "kind": 2, + "name": "GET /orders/99812", + "startTimeUnixNano": "1788937200000000000", + "endTimeUnixNano": "1788937200001000000", + "attributes": [ + { + "key": "http.request.method", + "value": { + "stringValue": "GET" + } + }, + { + "key": "url.path", + "value": { + "stringValue": "/orders/99812" + } + }, + { + "key": "url.scheme", + "value": { + "stringValue": "https" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "orders.example.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "443" + } + }, + { + "key": "network.protocol.version", + "value": { + "stringValue": "2" + } + }, + { + "key": "http.response.status_code", + "value": { + "intValue": "200" + } + } + ] + } + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-messaging-send-only.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-messaging-send-only.fiam.yaml new file mode 100644 index 0000000..63ee5db --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-messaging-send-only.fiam.yaml @@ -0,0 +1,485 @@ +fiam_version: '0.2' +instance: + id: model.otel.catalog.partial-messaging-send-only.otlp + kind: model + title: OpenTelemetry runtime catalog — partial-messaging-send-only.otlp.json + status: provisional + intent: Incremental runtime-observed FIAM architecture catalog generated from OTLP/JSON traces. +extensions: + org.fiam.catalog: + version: 0.2-draft.4 + processed_batches: + - 8f919a30398b1790aafe7d6d8f38b3067d42bc012132c895f2461de3d72ff452 + declared_entity_ids: [] + last_ingest_at: '2026-09-09T07:00:00Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: sample + sample_size: 3 + org.fiam.runtime_aggregates: + - id: aggregate.otel.944fabd557ce234abfcb228b + domain: messaging + role: producer + operation: operation.otel.messaging.send-orders.v1.2a5f01340e3e + binding: binding.otel.messaging.producer-kafka-orders.v1-producer.cadd41535c6b + local_node: node.otel.service.producer.45939b8d5c78 + remote_node: node.otel.broker.kafka.kafka.internal:9092.2feb21fac052 + channel: channel.otel.messaging.orders.v1.e747f6f8b407 + resource: null + messaging_system: kafka + operation_type: send + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:00Z' + last_seen: '2026-09-09T07:00:00Z' + sample_spans: + - trace:22222222222222222222222222222222/span:bbbbbbbbbbbbbbbb + org.fiam.runtime_topology_observations: [] + org.fiam.runtime_unresolved: + - id: unresolved.messaging-producer.a166b3165a78b97e1e38 + domain: messaging + reason: producer span has no observed downstream linked span in this batch + sample_span: trace:22222222222222222222222222222222/span:bbbbbbbbbbbbbbbb + channel: channel.otel.messaging.orders.v1.e747f6f8b407 + org.fiam.reconciliation_candidates: [] +artifacts: +- id: artifact.otel.stream.partial-messaging-send-only.otlp.1cbc8d72bde6 + kind: artifact + name: OTLP runtime stream + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json + facets: + format: OTLP/JSON + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + latest_batch_hash: 8f919a30398b1790aafe7d6d8f38b3067d42bc012132c895f2461de3d72ff452 + describes: + - interaction.sample.944fabd557ce234abfcb228b.bbbbbbbbbbbbbbbb +zones: +- id: zone.otel.environment.production.1521d207f3b6 + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.otel.service.producer.45939b8d5c78 +nodes: +- id: node.otel.broker.kafka.kafka.internal:9092.2feb21fac052 + kind: system-node + name: kafka at kafka.internal:9092 + node_type: fiam.node-type.broker + facets: + identity_tuple: + kind: broker + system: kafka + logical_address: kafka.internal:9092 + zone: + - production + - '' + - '' + - '' + - '' +- id: node.otel.service.producer.45939b8d5c78 + kind: system-node + name: producer + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: producer + environment: production +ports: +- id: port.otel.messaging.producer-kafka-producer.47ab29377449 + kind: port + owner: node.otel.service.producer.45939b8d5c78 + participations: + - contract: contract.otel.messaging.producer-kafka.9e0e565e2f76 + mode: requires + roles: + - fiam.role.producer +contracts: +- id: contract.otel.messaging.producer-kafka.9e0e565e2f76 + kind: interface-contract + name: Observed kafka surface — producer + operations: + - id: operation.otel.messaging.send-orders.v1.2a5f01340e3e + kind: operation + name: publish + interaction_style: fiam.interaction-style.publish +channels: +- id: channel.otel.messaging.orders.v1.e747f6f8b407 + kind: channel + name: orders.v1 + channel_type: fiam.channel.durable-topic + mediation: fiam.mediation.brokered + facets: + identity_tuple: + kind: messaging-channel + system: kafka + logical_broker: kafka.internal:9092 + destination: orders.v1 + zone: + - production + - '' + - '' + - '' + - '' + owner: node.otel.broker.kafka.kafka.internal:9092.2feb21fac052 +bindings: +- id: binding.otel.messaging.producer-kafka-orders.v1-producer.cadd41535c6b + kind: binding + contract: contract.otel.messaging.producer-kafka.9e0e565e2f76 + consumer_ports: + - port.otel.messaging.producer-kafka-producer.47ab29377449 + operations: + - operation.otel.messaging.send-orders.v1.2a5f01340e3e + communication_stack: + - role: fiam.stack-role.broker-protocol + term: fiam.protocol.kafka + channel: channel.otel.messaging.orders.v1.e747f6f8b407 + facets: + identity_tuple: + kind: messaging-binding + service_node: node.otel.service.producer.45939b8d5c78 + system: kafka + destination: orders.v1 + role: producer + zone: + - production + - '' + - '' + - '' + - '' +assertions: +- id: assertion.otel.05fd5ac4f8e860a1c427 + assertion_kind: property + subject: channel.otel.messaging.orders.v1.e747f6f8b407 + predicate: fiam.property.messaging-destination-name + polarity: asserted + value: orders.v1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-messaging-send-only.otlp.1cbc8d72bde6 + locator: attribute:messaging.destination.name + metadata: + source: real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.destination.name + sample_spans: + - trace:22222222222222222222222222222222/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.1e974561a0789d009031 + assertion_kind: property + subject: binding.otel.messaging.producer-kafka-orders.v1-producer.cadd41535c6b + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-messaging-send-only.otlp.1cbc8d72bde6 + locator: aggregate:944fabd557ce234abfcb228b + metadata: + source: real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:944fabd557ce234abfcb228b + aggregation_key: 944fabd557ce234abfcb228b + sample_spans: + - trace:22222222222222222222222222222222/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: &id001 + aggregation_key: 944fabd557ce234abfcb228b + domain: messaging + role: producer + operation_ref: operation.otel.messaging.send-orders.v1.2a5f01340e3e + local_node_ref: node.otel.service.producer.45939b8d5c78 + remote_node_ref: node.otel.broker.kafka.kafka.internal:9092.2feb21fac052 + channel_ref: channel.otel.messaging.orders.v1.e747f6f8b407 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.2249b4e1223a429b4019 + assertion_kind: property + subject: operation.otel.messaging.send-orders.v1.2a5f01340e3e + predicate: fiam.property.messaging-system + polarity: asserted + value: kafka + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-messaging-send-only.otlp.1cbc8d72bde6 + locator: attribute:messaging.system + metadata: + source: real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.system + sample_spans: + - trace:22222222222222222222222222222222/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.28a1d16a366c9c0b70e5 + assertion_kind: property + subject: operation.otel.messaging.send-orders.v1.2a5f01340e3e + predicate: fiam.property.messaging-operation-name + polarity: asserted + value: publish + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-messaging-send-only.otlp.1cbc8d72bde6 + locator: attribute:messaging.operation.name + metadata: + source: real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.operation.name + sample_spans: + - trace:22222222222222222222222222222222/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.618c45b8ef258daa0185 + assertion_kind: property + subject: binding.otel.messaging.producer-kafka-orders.v1-producer.cadd41535c6b + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-messaging-send-only.otlp.1cbc8d72bde6 + locator: aggregate:944fabd557ce234abfcb228b + metadata: + source: real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:944fabd557ce234abfcb228b + aggregation_key: 944fabd557ce234abfcb228b + sample_spans: + - trace:22222222222222222222222222222222/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.9db5e5ce30fa546a26a2 + assertion_kind: property + subject: binding.otel.messaging.producer-kafka-orders.v1-producer.cadd41535c6b + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.kafka + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-messaging-send-only.otlp.1cbc8d72bde6 + locator: attribute:messaging.system + metadata: + source: real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.system + sample_spans: + - trace:22222222222222222222222222222222/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.aa439d24edd3881148dc + assertion_kind: property + subject: binding.otel.messaging.producer-kafka-orders.v1-producer.cadd41535c6b + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-messaging-send-only.otlp.1cbc8d72bde6 + locator: aggregate:944fabd557ce234abfcb228b + metadata: + source: real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:944fabd557ce234abfcb228b + aggregation_key: 944fabd557ce234abfcb228b + sample_spans: + - trace:22222222222222222222222222222222/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.c95e3ee4ad0c1fb21619 + assertion_kind: property + subject: binding.otel.messaging.producer-kafka-orders.v1-producer.cadd41535c6b + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-messaging-send-only.otlp.1cbc8d72bde6 + locator: aggregate:944fabd557ce234abfcb228b + metadata: + source: real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:944fabd557ce234abfcb228b + aggregation_key: 944fabd557ce234abfcb228b + sample_spans: + - trace:22222222222222222222222222222222/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.d106907da769ffdd0de2 + assertion_kind: property + subject: binding.otel.messaging.producer-kafka-orders.v1-producer.cadd41535c6b + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-messaging-send-only.otlp.1cbc8d72bde6 + locator: aggregate:944fabd557ce234abfcb228b + metadata: + source: real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:944fabd557ce234abfcb228b + aggregation_key: 944fabd557ce234abfcb228b + sample_spans: + - trace:22222222222222222222222222222222/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.d1df60c407d26d7e137e + assertion_kind: property + subject: node.otel.service.producer.45939b8d5c78 + predicate: fiam.property.service-name + polarity: asserted + value: producer + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-messaging-send-only.otlp.1cbc8d72bde6 + locator: attribute:service.name + metadata: + source: real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:22222222222222222222222222222222/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.e9690d7f1468b37707b1 + assertion_kind: property + subject: operation.otel.messaging.send-orders.v1.2a5f01340e3e + predicate: fiam.property.messaging-operation-type + polarity: asserted + value: send + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-messaging-send-only.otlp.1cbc8d72bde6 + locator: attribute:messaging.operation.type + metadata: + source: real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.operation.type + sample_spans: + - trace:22222222222222222222222222222222/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +interactions: +- id: interaction.sample.944fabd557ce234abfcb228b.bbbbbbbbbbbbbbbb + kind: interaction + operation: operation.otel.messaging.send-orders.v1.2a5f01340e3e + contract: contract.otel.messaging.producer-kafka.9e0e565e2f76 + binding: binding.otel.messaging.producer-kafka-orders.v1-producer.cadd41535c6b + channel: channel.otel.messaging.orders.v1.e747f6f8b407 + interaction_style: fiam.interaction-style.publish + temporal_semantics: fiam.temporal.asynchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + producer: node.otel.service.producer.45939b8d5c78 + broker: node.otel.broker.kafka.kafka.internal:9092.2feb21fac052 + facets: + otel_trace_id: '22222222222222222222222222222222' + otel_span_id: bbbbbbbbbbbbbbbb + otel_span_kind: producer + instrumentation_scope: fixture + observed_service: node.otel.service.producer.45939b8d5c78 diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json new file mode 100644 index 0000000..9f39a26 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-messaging-send-only.otlp.json @@ -0,0 +1,77 @@ +{ + "resourceSpans": [ + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "producer" + } + }, + { + "key": "deployment.environment.name", + "value": { + "stringValue": "production" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "fixture" + }, + "spans": [ + { + "traceId": "22222222222222222222222222222222", + "spanId": "bbbbbbbbbbbbbbbb", + "kind": 4, + "name": "send orders", + "startTimeUnixNano": "1788937200000000000", + "endTimeUnixNano": "1788937200001000000", + "attributes": [ + { + "key": "messaging.system", + "value": { + "stringValue": "kafka" + } + }, + { + "key": "messaging.destination.name", + "value": { + "stringValue": "orders.v1" + } + }, + { + "key": "messaging.operation.type", + "value": { + "stringValue": "send" + } + }, + { + "key": "messaging.operation.name", + "value": { + "stringValue": "publish" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "kafka.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "9092" + } + } + ] + } + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-rpc-client-only.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-rpc-client-only.fiam.yaml new file mode 100644 index 0000000..799e533 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-rpc-client-only.fiam.yaml @@ -0,0 +1,455 @@ +fiam_version: '0.2' +instance: + id: model.otel.catalog.partial-rpc-client-only.otlp + kind: model + title: OpenTelemetry runtime catalog — partial-rpc-client-only.otlp.json + status: provisional + intent: Incremental runtime-observed FIAM architecture catalog generated from OTLP/JSON traces. +extensions: + org.fiam.catalog: + version: 0.2-draft.4 + processed_batches: + - 241ca024fa3ab08e7445faeb5e369f5f463afec5173ad8e2a83b8a324867d1c3 + declared_entity_ids: [] + last_ingest_at: '2026-09-09T07:00:00Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: sample + sample_size: 3 + org.fiam.runtime_aggregates: + - id: aggregate.otel.1112fd109a8fb91b675f6fdb + domain: rpc + role: client + operation: operation.otel.rpc.Get.d38e948c0a51 + binding: binding.otel.rpc.caller-grpc-inventory.internal:4317-client.64146a4c22b9 + local_node: node.otel.service.caller.6eba522fb50c + remote_node: node.otel.service.grpc.inventory.f64750b76211 + channel: null + resource: null + rpc_system: grpc + rpc_method: Inventory/Get + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:00Z' + last_seen: '2026-09-09T07:00:00Z' + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + org.fiam.runtime_topology_observations: [] + org.fiam.runtime_unresolved: + - id: unresolved.rpc-client.8662bee6bcf74c56587e + domain: rpc + reason: client span has no observed server child in this batch; topology remains partial under sampling + sample_span: trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + org.fiam.reconciliation_candidates: [] +artifacts: +- id: artifact.otel.stream.partial-rpc-client-only.otlp.bae23c0dab91 + kind: artifact + name: OTLP runtime stream + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/estate-hardening/partial-rpc-client-only.otlp.json + facets: + format: OTLP/JSON + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + latest_batch_hash: 241ca024fa3ab08e7445faeb5e369f5f463afec5173ad8e2a83b8a324867d1c3 + describes: + - interaction.sample.1112fd109a8fb91b675f6fdb.aaaaaaaaaaaaaaaa +zones: +- id: zone.otel.environment.production.1521d207f3b6 + kind: zone + name: production + zone_type: fiam.zone-type.deployment-environment + members: + - node.otel.service.caller.6eba522fb50c +nodes: +- id: node.otel.service.caller.6eba522fb50c + kind: system-node + name: caller + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: caller + environment: production +- id: node.otel.service.grpc.inventory.f64750b76211 + kind: system-node + name: inventory + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service + system: grpc + logical_address: inventory + zone: + - production + - '' + - '' + - '' + - '' +ports: +- id: port.otel.rpc.caller-grpc-client.59c261198e90 + kind: port + owner: node.otel.service.caller.6eba522fb50c + participations: + - contract: contract.otel.rpc.caller-grpc.4f83afc616fa + mode: requires + roles: + - fiam.role.client +contracts: +- id: contract.otel.rpc.caller-grpc.4f83afc616fa + kind: interface-contract + name: Observed grpc surface — caller + operations: + - id: operation.otel.rpc.Get.d38e948c0a51 + kind: operation + name: Inventory/Get + interaction_style: fiam.interaction-style.rpc + x-rpc-method: Inventory/Get +endpoints: +- id: endpoint.otel.rpc.inventory.internal:4317.d3e0341702e4 + kind: endpoint + name: inventory.internal:4317 + address_scheme: fiam.address-scheme.host-port + facets: + identity_tuple: + address: inventory.internal:4317 + address_scheme: fiam.address-scheme.host-port + zone: + - production + - '' + - '' + - '' + - '' + logical_server_address: inventory.internal + address: inventory.internal:4317 +bindings: +- id: binding.otel.rpc.caller-grpc-inventory.internal:4317-client.64146a4c22b9 + kind: binding + contract: contract.otel.rpc.caller-grpc.4f83afc616fa + operations: + - operation.otel.rpc.Get.d38e948c0a51 + communication_stack: + - role: fiam.stack-role.rpc-protocol + term: fiam.protocol.grpc + facets: + identity_tuple: + kind: rpc-binding + service_node: node.otel.service.caller.6eba522fb50c + system: grpc + logical_address: inventory.internal:4317 + role: client + zone: + - production + - '' + - '' + - '' + - '' + consumer_ports: + - port.otel.rpc.caller-grpc-client.59c261198e90 + endpoints: + - endpoint.otel.rpc.inventory.internal:4317.d3e0341702e4 +assertions: +- id: assertion.otel.00bb66174db102c12b1d + assertion_kind: property + subject: binding.otel.rpc.caller-grpc-inventory.internal:4317-client.64146a4c22b9 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.grpc + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-rpc-client-only.otlp.bae23c0dab91 + locator: attribute:rpc.system.name + metadata: + source: real-world/otel/estate-hardening/partial-rpc-client-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.system.name + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.29bafba1ff6f15b936e4 + assertion_kind: property + subject: binding.otel.rpc.caller-grpc-inventory.internal:4317-client.64146a4c22b9 + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-rpc-client-only.otlp.bae23c0dab91 + locator: aggregate:1112fd109a8fb91b675f6fdb + metadata: + source: real-world/otel/estate-hardening/partial-rpc-client-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:1112fd109a8fb91b675f6fdb + aggregation_key: 1112fd109a8fb91b675f6fdb + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: &id001 + aggregation_key: 1112fd109a8fb91b675f6fdb + domain: rpc + role: client + operation_ref: operation.otel.rpc.Get.d38e948c0a51 + local_node_ref: node.otel.service.caller.6eba522fb50c + remote_node_ref: node.otel.service.grpc.inventory.f64750b76211 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.3aa8430201e1256b7d3c + assertion_kind: property + subject: binding.otel.rpc.caller-grpc-inventory.internal:4317-client.64146a4c22b9 + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-rpc-client-only.otlp.bae23c0dab91 + locator: aggregate:1112fd109a8fb91b675f6fdb + metadata: + source: real-world/otel/estate-hardening/partial-rpc-client-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:1112fd109a8fb91b675f6fdb + aggregation_key: 1112fd109a8fb91b675f6fdb + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.4e9ce29747c42a71fd16 + assertion_kind: property + subject: operation.otel.rpc.Get.d38e948c0a51 + predicate: fiam.property.rpc-method + polarity: asserted + value: Inventory/Get + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-rpc-client-only.otlp.bae23c0dab91 + locator: attribute:rpc.method + metadata: + source: real-world/otel/estate-hardening/partial-rpc-client-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.method + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.58060808e85be715006b + assertion_kind: property + subject: node.otel.service.caller.6eba522fb50c + predicate: fiam.property.service-name + polarity: asserted + value: caller + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-rpc-client-only.otlp.bae23c0dab91 + locator: attribute:service.name + metadata: + source: real-world/otel/estate-hardening/partial-rpc-client-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.603f3c6b85f7870146b4 + assertion_kind: property + subject: binding.otel.rpc.caller-grpc-inventory.internal:4317-client.64146a4c22b9 + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-rpc-client-only.otlp.bae23c0dab91 + locator: aggregate:1112fd109a8fb91b675f6fdb + metadata: + source: real-world/otel/estate-hardening/partial-rpc-client-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:1112fd109a8fb91b675f6fdb + aggregation_key: 1112fd109a8fb91b675f6fdb + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.8c4e774bbbf2a31fb96a + assertion_kind: property + subject: binding.otel.rpc.caller-grpc-inventory.internal:4317-client.64146a4c22b9 + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-rpc-client-only.otlp.bae23c0dab91 + locator: aggregate:1112fd109a8fb91b675f6fdb + metadata: + source: real-world/otel/estate-hardening/partial-rpc-client-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:1112fd109a8fb91b675f6fdb + aggregation_key: 1112fd109a8fb91b675f6fdb + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.8ebfdb7ea1ff52e0929e + assertion_kind: property + subject: binding.otel.rpc.caller-grpc-inventory.internal:4317-client.64146a4c22b9 + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.partial-rpc-client-only.otlp.bae23c0dab91 + locator: aggregate:1112fd109a8fb91b675f6fdb + metadata: + source: real-world/otel/estate-hardening/partial-rpc-client-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:1112fd109a8fb91b675f6fdb + aggregation_key: 1112fd109a8fb91b675f6fdb + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.b664690cecd6bad4dede + assertion_kind: property + subject: binding.otel.rpc.caller-grpc-inventory.internal:4317-client.64146a4c22b9 + predicate: fiam.property.service-peer-name + polarity: asserted + value: inventory + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-rpc-client-only.otlp.bae23c0dab91 + locator: attribute:service.peer.name + metadata: + source: real-world/otel/estate-hardening/partial-rpc-client-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.peer.name + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.be6f92e5cbbd2a65900e + assertion_kind: property + subject: operation.otel.rpc.Get.d38e948c0a51 + predicate: fiam.property.rpc-system-name + polarity: asserted + value: grpc + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.partial-rpc-client-only.otlp.bae23c0dab91 + locator: attribute:rpc.system.name + metadata: + source: real-world/otel/estate-hardening/partial-rpc-client-only.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.system.name + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +interactions: +- id: interaction.sample.1112fd109a8fb91b675f6fdb.aaaaaaaaaaaaaaaa + kind: interaction + operation: operation.otel.rpc.Get.d38e948c0a51 + contract: contract.otel.rpc.caller-grpc.4f83afc616fa + binding: binding.otel.rpc.caller-grpc-inventory.internal:4317-client.64146a4c22b9 + interaction_style: fiam.interaction-style.rpc + temporal_semantics: fiam.temporal.synchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + initiator: node.otel.service.caller.6eba522fb50c + responder: node.otel.service.grpc.inventory.f64750b76211 + facets: + otel_trace_id: '11111111111111111111111111111111' + otel_span_id: aaaaaaaaaaaaaaaa + otel_span_kind: client + instrumentation_scope: fixture + observed_service: node.otel.service.caller.6eba522fb50c diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-rpc-client-only.otlp.json b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-rpc-client-only.otlp.json new file mode 100644 index 0000000..271c099 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/partial-rpc-client-only.otlp.json @@ -0,0 +1,71 @@ +{ + "resourceSpans": [ + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "caller" + } + }, + { + "key": "deployment.environment.name", + "value": { + "stringValue": "production" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "fixture" + }, + "spans": [ + { + "traceId": "11111111111111111111111111111111", + "spanId": "aaaaaaaaaaaaaaaa", + "kind": 3, + "name": "Inventory/Get", + "startTimeUnixNano": "1788937200000000000", + "endTimeUnixNano": "1788937200001000000", + "attributes": [ + { + "key": "rpc.system.name", + "value": { + "stringValue": "grpc" + } + }, + { + "key": "rpc.method", + "value": { + "stringValue": "Inventory/Get" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "inventory.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "4317" + } + }, + { + "key": "service.peer.name", + "value": { + "stringValue": "inventory" + } + } + ] + } + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/security-api-list-items.otlp.json b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/security-api-list-items.otlp.json new file mode 100644 index 0000000..d1e9cd2 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/estate-hardening/security-api-list-items.otlp.json @@ -0,0 +1,105 @@ +{ + "resourceSpans": [ + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Estate Security API" + } + }, + { + "key": "service.namespace", + "value": { + "stringValue": "petstore3.swagger.io" + } + }, + { + "key": "service.version", + "value": { + "stringValue": "1.0.27" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "example.http.instrumentation", + "version": "1.0.0" + }, + "spans": [ + { + "traceId": "aabbccddeeff00112233445566778899", + "spanId": "1122334455667788", + "name": "GET /items", + "kind": 2, + "startTimeUnixNano": "1788915600000000000", + "endTimeUnixNano": "1788915600035000000", + "attributes": [ + { + "key": "http.request.method", + "value": { + "stringValue": "GET" + } + }, + { + "key": "http.route", + "value": { + "stringValue": "/items" + } + }, + { + "key": "url.path", + "value": { + "stringValue": "/items" + } + }, + { + "key": "url.scheme", + "value": { + "stringValue": "https" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "security.example.test" + } + }, + { + "key": "server.port", + "value": { + "intValue": "443" + } + }, + { + "key": "network.protocol.version", + "value": { + "stringValue": "2" + } + }, + { + "key": "http.response.status_code", + "value": { + "intValue": "200" + } + }, + { + "key": "client.address", + "value": { + "stringValue": "192.0.2.42" + } + } + ], + "status": { + "code": 1 + } + } + ] + } + ] + } + ] +} diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/grpc-runtime.otlp.json b/history/FIAM_v0.2_Draft6/real-world/otel/grpc-runtime.otlp.json new file mode 100644 index 0000000..be49f6e --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/grpc-runtime.otlp.json @@ -0,0 +1,129 @@ +{ + "resourceSpans": [ + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Telemetry Client" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "runtime-fixture", + "version": "0.2-draft.3" + }, + "spans": [ + { + "traceId": "11111111111111111111111111111111", + "spanId": "aaaaaaaaaaaaaaaa", + "kind": 3, + "name": "TelemetryService/StreamTelemetry", + "startTimeUnixNano": "1788937200000000000", + "endTimeUnixNano": "1788937200050000000", + "attributes": [ + { + "key": "rpc.system.name", + "value": { + "stringValue": "grpc" + } + }, + { + "key": "rpc.method", + "value": { + "stringValue": "TelemetryService/StreamTelemetry" + } + }, + { + "key": "rpc.response.status_code", + "value": { + "stringValue": "OK" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "telemetry.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "4317" + } + } + ] + } + ] + } + ] + }, + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Telemetry Aggregator" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "runtime-fixture", + "version": "0.2-draft.3" + }, + "spans": [ + { + "traceId": "11111111111111111111111111111111", + "spanId": "bbbbbbbbbbbbbbbb", + "kind": 2, + "name": "TelemetryService/StreamTelemetry", + "startTimeUnixNano": "1788937200010000000", + "endTimeUnixNano": "1788937200060000000", + "attributes": [ + { + "key": "rpc.system.name", + "value": { + "stringValue": "grpc" + } + }, + { + "key": "rpc.method", + "value": { + "stringValue": "TelemetryService/StreamTelemetry" + } + }, + { + "key": "rpc.response.status_code", + "value": { + "stringValue": "OK" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "telemetry.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "4317" + } + } + ], + "parentSpanId": "aaaaaaaaaaaaaaaa" + } + ] + } + ] + } + ] +} diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/kafka-runtime.otlp.json b/history/FIAM_v0.2_Draft6/real-world/otel/kafka-runtime.otlp.json new file mode 100644 index 0000000..538dd96 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/kafka-runtime.otlp.json @@ -0,0 +1,158 @@ +{ + "resourceSpans": [ + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Order Service" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "runtime-fixture", + "version": "0.2-draft.3" + }, + "spans": [ + { + "traceId": "22222222222222222222222222222222", + "spanId": "cccccccccccccccc", + "kind": 4, + "name": "publish orders.v1", + "startTimeUnixNano": "1788937201000000000", + "endTimeUnixNano": "1788937201050000000", + "attributes": [ + { + "key": "messaging.system", + "value": { + "stringValue": "kafka" + } + }, + { + "key": "messaging.destination.name", + "value": { + "stringValue": "orders.v1" + } + }, + { + "key": "messaging.operation.name", + "value": { + "stringValue": "publish" + } + }, + { + "key": "messaging.operation.type", + "value": { + "stringValue": "send" + } + }, + { + "key": "messaging.message.id", + "value": { + "stringValue": "order-42" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "kafka.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "9092" + } + } + ] + } + ] + } + ] + }, + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Billing Service" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "runtime-fixture", + "version": "0.2-draft.3" + }, + "spans": [ + { + "traceId": "33333333333333333333333333333333", + "spanId": "dddddddddddddddd", + "kind": 5, + "name": "consume orders.v1", + "startTimeUnixNano": "1788937202000000000", + "endTimeUnixNano": "1788937202050000000", + "attributes": [ + { + "key": "messaging.system", + "value": { + "stringValue": "kafka" + } + }, + { + "key": "messaging.destination.name", + "value": { + "stringValue": "orders.v1" + } + }, + { + "key": "messaging.operation.name", + "value": { + "stringValue": "consume" + } + }, + { + "key": "messaging.operation.type", + "value": { + "stringValue": "process" + } + }, + { + "key": "messaging.message.id", + "value": { + "stringValue": "order-42" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "kafka.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "9092" + } + } + ], + "links": [ + { + "traceId": "22222222222222222222222222222222", + "spanId": "cccccccccccccccc" + } + ] + } + ] + } + ] + } + ] +} diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/multidomain-runtime.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/otel/multidomain-runtime.fiam.yaml new file mode 100644 index 0000000..1ca770e --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/multidomain-runtime.fiam.yaml @@ -0,0 +1,2922 @@ +fiam_version: '0.2' +instance: + id: model.otel.catalog.multidomain-runtime.otlp + kind: model + title: OpenTelemetry runtime catalog — multidomain-runtime.otlp.json + status: provisional + intent: Incremental runtime-observed FIAM architecture catalog generated from OTLP/JSON traces. +extensions: + org.fiam.catalog: + version: 0.2-draft.4 + processed_batches: + - 3d49ec82e4da1da6a0841eaca0c5530b8d9029eb488664a19eb388ab7fff7e7a + declared_entity_ids: [] + last_ingest_at: '2026-09-09T07:00:04Z' + runtime_policy: aggregate-by-architectural-tuple + occurrence_retention: sample + sample_size: 3 + org.fiam.runtime_aggregates: + - id: aggregate.otel.201134bc52a0f40f21e5656a + domain: database + role: client + operation: operation.otel.db.INSERT-public.integration_exchange.92bf26c60bf6 + binding: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + local_node: node.otel.service.Application-A.cfbc55b42036 + remote_node: node.otel.database.postgresql.db.internal:5432.03855f9892af + channel: null + resource: resource.otel.db.public.integration_exchange.84bc7a7ef21d + database_system: postgresql + effect: write + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:03Z' + last_seen: '2026-09-09T07:00:03Z' + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + - id: aggregate.otel.2ccec9f9ed32803fa562b76c + domain: rpc + role: client + operation: operation.otel.rpc.StreamTelemetry.552f69398b3d + binding: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + local_node: node.otel.service.Telemetry-Client.78936dd205bd + remote_node: null + channel: null + resource: null + rpc_system: grpc + rpc_method: TelemetryService/StreamTelemetry + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:00Z' + last_seen: '2026-09-09T07:00:00Z' + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + - id: aggregate.otel.43bc423016df8daaec891605 + domain: rpc + role: server + operation: operation.otel.rpc.StreamTelemetry.7785627aa978 + binding: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + local_node: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + remote_node: null + channel: null + resource: null + rpc_system: grpc + rpc_method: TelemetryService/StreamTelemetry + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:00.010000Z' + last_seen: '2026-09-09T07:00:00.010000Z' + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + - id: aggregate.otel.44cadec49111a7657123fa3d + domain: messaging + role: consumer + operation: operation.otel.messaging.receive-orders.v1.f57d4d4e31bc + binding: binding.otel.messaging.Audit-Service-kafka-orders.v1-consumer.a8f9f5454efb + local_node: node.otel.service.Audit-Service.8b3b698a106c + remote_node: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + channel: channel.otel.messaging.orders.v1.891b2277822e + resource: null + messaging_system: kafka + operation_type: receive + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:02.500000Z' + last_seen: '2026-09-09T07:00:02.500000Z' + sample_spans: + - trace:66666666666666666666666666666666/span:1212121212121212 + - id: aggregate.otel.508461318135f08b1d916347 + domain: database + role: client + operation: operation.otel.db.SELECT-public.integration_exchange.2b77ce48158e + binding: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + local_node: node.otel.service.Application-B.e415ac492d2e + remote_node: node.otel.database.postgresql.db.internal:5432.03855f9892af + channel: null + resource: resource.otel.db.public.integration_exchange.84bc7a7ef21d + database_system: postgresql + effect: read + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:04Z' + last_seen: '2026-09-09T07:00:04Z' + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + - id: aggregate.otel.581d83f560b25eaf272c5bc3 + domain: messaging + role: producer + operation: operation.otel.messaging.send-orders.v1.e27097565779 + binding: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + local_node: node.otel.service.Order-Service.a75279f84c2c + remote_node: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + channel: channel.otel.messaging.orders.v1.891b2277822e + resource: null + messaging_system: kafka + operation_type: send + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:01Z' + last_seen: '2026-09-09T07:00:01Z' + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + - id: aggregate.otel.8aaf289773e141a92dbc0b22 + domain: messaging + role: consumer + operation: operation.otel.messaging.process-orders.v1.2e3dfcfb341c + binding: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + local_node: node.otel.service.Billing-Service.d6ddce900d32 + remote_node: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + channel: channel.otel.messaging.orders.v1.891b2277822e + resource: null + messaging_system: kafka + operation_type: process + count: 1 + error_count: 0 + first_seen: '2026-09-09T07:00:02Z' + last_seen: '2026-09-09T07:00:02Z' + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + org.fiam.runtime_topology_observations: + - id: topology.otel.database.c1ddfac34c71b4b8d3f9 + domain: database + count: 1 + first_seen: '2026-09-09T07:00:04Z' + last_seen: '2026-09-09T07:00:04Z' + sample_correlations: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + kind: resource-read + from: node.otel.service.Application-B.e415ac492d2e + to_resource: resource.otel.db.public.integration_exchange.84bc7a7ef21d + binding: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + correlation: span-resource + - id: topology.otel.database.d2681a2839139c054290 + domain: database + count: 1 + first_seen: '2026-09-09T07:00:03Z' + last_seen: '2026-09-09T07:00:03Z' + sample_correlations: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + kind: resource-write + from: node.otel.service.Application-A.cfbc55b42036 + to_resource: resource.otel.db.public.integration_exchange.84bc7a7ef21d + binding: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + correlation: span-resource + - id: topology.otel.messaging.abbffa57dddbdb8182df + domain: messaging + count: 1 + first_seen: '2026-09-09T07:00:01Z' + last_seen: '2026-09-09T07:00:02Z' + sample_correlations: + - 22222222222222222222222222222222:cccccccccccccccc + kind: mediated-message-flow + from: node.otel.service.Order-Service.a75279f84c2c + to: node.otel.service.Billing-Service.d6ddce900d32 + via_channel: channel.otel.messaging.orders.v1.891b2277822e + correlation: span-link + - id: topology.otel.messaging.fcc4177258df796107d0 + domain: messaging + count: 1 + first_seen: '2026-09-09T07:00:01Z' + last_seen: '2026-09-09T07:00:02.500000Z' + sample_correlations: + - 22222222222222222222222222222222:cccccccccccccccc + kind: mediated-message-flow + from: node.otel.service.Order-Service.a75279f84c2c + to: node.otel.service.Audit-Service.8b3b698a106c + via_channel: channel.otel.messaging.orders.v1.891b2277822e + correlation: span-link + - id: topology.otel.rpc.68b29be9b90d97664917 + domain: rpc + count: 1 + first_seen: '2026-09-09T07:00:00Z' + last_seen: '2026-09-09T07:00:00.010000Z' + sample_correlations: + - 11111111111111111111111111111111:interaction.sample.2ccec9f9ed32803fa562b76c.aaaaaaaaaaaaaaaa->interaction.sample.43bc423016df8daaec891605.bbbbbbbbbbbbbbbb + kind: direct-call + from: node.otel.service.Telemetry-Client.78936dd205bd + to: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + binding: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + operation: operation.otel.rpc.StreamTelemetry.552f69398b3d + correlation: trace-parent + via_gateway: false + org.fiam.runtime_unresolved: [] + org.fiam.reconciliation_candidates: [] +artifacts: +- id: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + kind: artifact + name: OTLP runtime stream + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/multidomain-runtime.otlp.json + facets: + format: OTLP/JSON + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + latest_batch_hash: 3d49ec82e4da1da6a0841eaca0c5530b8d9029eb488664a19eb388ab7fff7e7a + describes: + - interaction.sample.201134bc52a0f40f21e5656a.eeeeeeeeeeeeeeee + - interaction.sample.2ccec9f9ed32803fa562b76c.aaaaaaaaaaaaaaaa + - interaction.sample.43bc423016df8daaec891605.bbbbbbbbbbbbbbbb + - interaction.sample.44cadec49111a7657123fa3d.1212121212121212 + - interaction.sample.508461318135f08b1d916347.ffffffffffffffff + - interaction.sample.581d83f560b25eaf272c5bc3.cccccccccccccccc + - interaction.sample.8aaf289773e141a92dbc0b22.dddddddddddddddd +zones: +- id: zone.otel.unscoped + kind: zone + name: Unscoped runtime observations + zone_type: fiam.zone-type.unscoped + members: + - node.otel.service.Telemetry-Client.78936dd205bd + - node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + - node.otel.service.Order-Service.a75279f84c2c + - node.otel.service.Billing-Service.d6ddce900d32 + - node.otel.service.Audit-Service.8b3b698a106c + - node.otel.service.Application-A.cfbc55b42036 + - node.otel.service.Application-B.e415ac492d2e +nodes: +- id: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + kind: system-node + name: kafka at kafka.internal:9092 + node_type: fiam.node-type.broker + facets: + identity_tuple: + kind: broker + system: kafka + logical_address: kafka.internal:9092 + zone: + - '' + - '' + - '' + - '' + - '' +- id: node.otel.database.postgresql.db.internal:5432.03855f9892af + kind: system-node + name: postgresql at db.internal:5432 + node_type: fiam.node-type.database + facets: + identity_tuple: + kind: database + system: postgresql + logical_address: db.internal:5432 + zone: + - '' + - '' + - '' + - '' + - '' +- id: node.otel.service.Application-A.cfbc55b42036 + kind: system-node + name: Application A + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: Application A +- id: node.otel.service.Application-B.e415ac492d2e + kind: system-node + name: Application B + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: Application B +- id: node.otel.service.Audit-Service.8b3b698a106c + kind: system-node + name: Audit Service + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: Audit Service +- id: node.otel.service.Billing-Service.d6ddce900d32 + kind: system-node + name: Billing Service + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: Billing Service +- id: node.otel.service.Order-Service.a75279f84c2c + kind: system-node + name: Order Service + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: Order Service +- id: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + kind: system-node + name: Telemetry Aggregator + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: Telemetry Aggregator +- id: node.otel.service.Telemetry-Client.78936dd205bd + kind: system-node + name: Telemetry Client + node_type: fiam.node-type.service + facets: + identity_tuple: + kind: service-deployment + service_namespace: '' + service_name: Telemetry Client +ports: +- id: port.otel.db.Application-A-postgresql.aa791c002404 + kind: port + owner: node.otel.service.Application-A.cfbc55b42036 + participations: + - contract: contract.otel.db.Application-A-postgresql.d8124174d2c9 + mode: requires + roles: + - fiam.role.database-client +- id: port.otel.db.Application-B-postgresql.655f3e58fb43 + kind: port + owner: node.otel.service.Application-B.e415ac492d2e + participations: + - contract: contract.otel.db.Application-B-postgresql.f40dfb73e126 + mode: requires + roles: + - fiam.role.database-client +- id: port.otel.messaging.Audit-Service-kafka-consumer.17376796040c + kind: port + owner: node.otel.service.Audit-Service.8b3b698a106c + participations: + - contract: contract.otel.messaging.Audit-Service-kafka.800efba6af2c + mode: requires + roles: + - fiam.role.consumer +- id: port.otel.messaging.Billing-Service-kafka-consumer.2375156d00c8 + kind: port + owner: node.otel.service.Billing-Service.d6ddce900d32 + participations: + - contract: contract.otel.messaging.Billing-Service-kafka.18363aba2a59 + mode: requires + roles: + - fiam.role.consumer +- id: port.otel.messaging.Order-Service-kafka-producer.998bdba5e0d9 + kind: port + owner: node.otel.service.Order-Service.a75279f84c2c + participations: + - contract: contract.otel.messaging.Order-Service-kafka.eb23fcd426e8 + mode: requires + roles: + - fiam.role.producer +- id: port.otel.rpc.Telemetry-Aggregator-grpc-server.97d1d4ec3f07 + kind: port + owner: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + participations: + - contract: contract.otel.rpc.Telemetry-Aggregator-grpc.514ae3c41ea1 + mode: offers + roles: + - fiam.role.server +- id: port.otel.rpc.Telemetry-Client-grpc-client.fd704ccd5456 + kind: port + owner: node.otel.service.Telemetry-Client.78936dd205bd + participations: + - contract: contract.otel.rpc.Telemetry-Client-grpc.7c8fe2572a80 + mode: requires + roles: + - fiam.role.client +contracts: +- id: contract.otel.db.Application-A-postgresql.d8124174d2c9 + kind: interface-contract + name: Observed postgresql client surface — Application A + operations: + - id: operation.otel.db.INSERT-public.integration_exchange.92bf26c60bf6 + kind: operation + name: INSERT + interaction_style: fiam.interaction-style.command + effect: fiam.effect.write +- id: contract.otel.db.Application-B-postgresql.f40dfb73e126 + kind: interface-contract + name: Observed postgresql client surface — Application B + operations: + - id: operation.otel.db.SELECT-public.integration_exchange.2b77ce48158e + kind: operation + name: SELECT + interaction_style: fiam.interaction-style.query + effect: fiam.effect.read +- id: contract.otel.messaging.Audit-Service-kafka.800efba6af2c + kind: interface-contract + name: Observed kafka surface — Audit Service + operations: + - id: operation.otel.messaging.receive-orders.v1.f57d4d4e31bc + kind: operation + name: poll + interaction_style: fiam.interaction-style.subscribe +- id: contract.otel.messaging.Billing-Service-kafka.18363aba2a59 + kind: interface-contract + name: Observed kafka surface — Billing Service + operations: + - id: operation.otel.messaging.process-orders.v1.2e3dfcfb341c + kind: operation + name: consume + interaction_style: fiam.interaction-style.subscribe +- id: contract.otel.messaging.Order-Service-kafka.eb23fcd426e8 + kind: interface-contract + name: Observed kafka surface — Order Service + operations: + - id: operation.otel.messaging.send-orders.v1.e27097565779 + kind: operation + name: publish + interaction_style: fiam.interaction-style.publish +- id: contract.otel.rpc.Telemetry-Aggregator-grpc.514ae3c41ea1 + kind: interface-contract + name: Observed grpc surface — Telemetry Aggregator + operations: + - id: operation.otel.rpc.StreamTelemetry.7785627aa978 + kind: operation + name: TelemetryService/StreamTelemetry + interaction_style: fiam.interaction-style.rpc + x-rpc-method: TelemetryService/StreamTelemetry +- id: contract.otel.rpc.Telemetry-Client-grpc.7c8fe2572a80 + kind: interface-contract + name: Observed grpc surface — Telemetry Client + operations: + - id: operation.otel.rpc.StreamTelemetry.552f69398b3d + kind: operation + name: TelemetryService/StreamTelemetry + interaction_style: fiam.interaction-style.rpc + x-rpc-method: TelemetryService/StreamTelemetry +endpoints: +- id: endpoint.otel.db.db.internal:5432.f2c4974a69d0 + kind: endpoint + name: db.internal:5432 + address_scheme: fiam.address-scheme.host-port + facets: + identity_tuple: + address: db.internal:5432 + address_scheme: fiam.address-scheme.host-port + zone: + - '' + - '' + - '' + - '' + - '' + logical_server_address: db.internal + address: db.internal:5432 +- id: endpoint.otel.rpc.telemetry.internal:4317.ea4b6583a12d + kind: endpoint + name: telemetry.internal:4317 + address_scheme: fiam.address-scheme.host-port + facets: + identity_tuple: + address: telemetry.internal:4317 + address_scheme: fiam.address-scheme.host-port + zone: + - '' + - '' + - '' + - '' + - '' + logical_server_address: telemetry.internal + address: telemetry.internal:4317 +bindings: +- id: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + kind: binding + contract: contract.otel.db.Application-A-postgresql.d8124174d2c9 + consumer_ports: + - port.otel.db.Application-A-postgresql.aa791c002404 + operations: + - operation.otel.db.INSERT-public.integration_exchange.92bf26c60bf6 + communication_stack: + - role: fiam.stack-role.database-protocol + term: fiam.protocol.postgresql-frontend-backend + facets: + identity_tuple: + kind: database-binding + service_node: node.otel.service.Application-A.cfbc55b42036 + system: postgresql + logical_address: db.internal:5432 + zone: + - '' + - '' + - '' + - '' + - '' + endpoints: + - endpoint.otel.db.db.internal:5432.f2c4974a69d0 +- id: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + kind: binding + contract: contract.otel.db.Application-B-postgresql.f40dfb73e126 + consumer_ports: + - port.otel.db.Application-B-postgresql.655f3e58fb43 + operations: + - operation.otel.db.SELECT-public.integration_exchange.2b77ce48158e + communication_stack: + - role: fiam.stack-role.database-protocol + term: fiam.protocol.postgresql-frontend-backend + facets: + identity_tuple: + kind: database-binding + service_node: node.otel.service.Application-B.e415ac492d2e + system: postgresql + logical_address: db.internal:5432 + zone: + - '' + - '' + - '' + - '' + - '' + endpoints: + - endpoint.otel.db.db.internal:5432.f2c4974a69d0 +- id: binding.otel.messaging.Audit-Service-kafka-orders.v1-consumer.a8f9f5454efb + kind: binding + contract: contract.otel.messaging.Audit-Service-kafka.800efba6af2c + consumer_ports: + - port.otel.messaging.Audit-Service-kafka-consumer.17376796040c + operations: + - operation.otel.messaging.receive-orders.v1.f57d4d4e31bc + communication_stack: + - role: fiam.stack-role.broker-protocol + term: fiam.protocol.kafka + channel: channel.otel.messaging.orders.v1.891b2277822e + facets: + identity_tuple: + kind: messaging-binding + service_node: node.otel.service.Audit-Service.8b3b698a106c + system: kafka + destination: orders.v1 + role: consumer + zone: + - '' + - '' + - '' + - '' + - '' +- id: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + kind: binding + contract: contract.otel.messaging.Billing-Service-kafka.18363aba2a59 + consumer_ports: + - port.otel.messaging.Billing-Service-kafka-consumer.2375156d00c8 + operations: + - operation.otel.messaging.process-orders.v1.2e3dfcfb341c + communication_stack: + - role: fiam.stack-role.broker-protocol + term: fiam.protocol.kafka + channel: channel.otel.messaging.orders.v1.891b2277822e + facets: + identity_tuple: + kind: messaging-binding + service_node: node.otel.service.Billing-Service.d6ddce900d32 + system: kafka + destination: orders.v1 + role: consumer + zone: + - '' + - '' + - '' + - '' + - '' +- id: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + kind: binding + contract: contract.otel.messaging.Order-Service-kafka.eb23fcd426e8 + consumer_ports: + - port.otel.messaging.Order-Service-kafka-producer.998bdba5e0d9 + operations: + - operation.otel.messaging.send-orders.v1.e27097565779 + communication_stack: + - role: fiam.stack-role.broker-protocol + term: fiam.protocol.kafka + channel: channel.otel.messaging.orders.v1.891b2277822e + facets: + identity_tuple: + kind: messaging-binding + service_node: node.otel.service.Order-Service.a75279f84c2c + system: kafka + destination: orders.v1 + role: producer + zone: + - '' + - '' + - '' + - '' + - '' +- id: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + kind: binding + contract: contract.otel.rpc.Telemetry-Aggregator-grpc.514ae3c41ea1 + operations: + - operation.otel.rpc.StreamTelemetry.7785627aa978 + communication_stack: + - role: fiam.stack-role.rpc-protocol + term: fiam.protocol.grpc + facets: + identity_tuple: + kind: rpc-binding + service_node: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + system: grpc + logical_address: telemetry.internal:4317 + role: server + zone: + - '' + - '' + - '' + - '' + - '' + provider_port: port.otel.rpc.Telemetry-Aggregator-grpc-server.97d1d4ec3f07 + endpoints: + - endpoint.otel.rpc.telemetry.internal:4317.ea4b6583a12d +- id: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + kind: binding + contract: contract.otel.rpc.Telemetry-Client-grpc.7c8fe2572a80 + operations: + - operation.otel.rpc.StreamTelemetry.552f69398b3d + communication_stack: + - role: fiam.stack-role.rpc-protocol + term: fiam.protocol.grpc + facets: + identity_tuple: + kind: rpc-binding + service_node: node.otel.service.Telemetry-Client.78936dd205bd + system: grpc + logical_address: telemetry.internal:4317 + role: client + zone: + - '' + - '' + - '' + - '' + - '' + consumer_ports: + - port.otel.rpc.Telemetry-Client-grpc-client.fd704ccd5456 + endpoints: + - endpoint.otel.rpc.telemetry.internal:4317.ea4b6583a12d +assertions: +- id: assertion.otel.058fac2f700d20110ddd + assertion_kind: property + subject: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.kafka + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:messaging.system + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.system + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.076e17e9609942ef39ea + assertion_kind: relation + subject: operation.otel.db.INSERT-public.integration_exchange.92bf26c60bf6 + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.otel.db.public.integration_exchange.84bc7a7ef21d + evidence: + mode: fiam.evidence.inferred + source: + type: database-resource-mapping + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:db.collection.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.collection.name + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 0.92 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.08dc812b4690f70d2929 + assertion_kind: property + subject: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:03Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:201134bc52a0f40f21e5656a + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:201134bc52a0f40f21e5656a + aggregation_key: 201134bc52a0f40f21e5656a + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + facets: &id002 + aggregation_key: 201134bc52a0f40f21e5656a + domain: database + role: client + operation_ref: operation.otel.db.INSERT-public.integration_exchange.92bf26c60bf6 + local_node_ref: node.otel.service.Application-A.cfbc55b42036 + remote_node_ref: node.otel.database.postgresql.db.internal:5432.03855f9892af + resource_ref: resource.otel.db.public.integration_exchange.84bc7a7ef21d + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.0942568c089c4b5a4c27 + assertion_kind: property + subject: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:01Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:581d83f560b25eaf272c5bc3 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:581d83f560b25eaf272c5bc3 + aggregation_key: 581d83f560b25eaf272c5bc3 + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: &id007 + aggregation_key: 581d83f560b25eaf272c5bc3 + domain: messaging + role: producer + operation_ref: operation.otel.messaging.send-orders.v1.e27097565779 + local_node_ref: node.otel.service.Order-Service.a75279f84c2c + remote_node_ref: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + channel_ref: channel.otel.messaging.orders.v1.891b2277822e + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.0b48772bc6b526328693 + assertion_kind: property + subject: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:8aaf289773e141a92dbc0b22 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:8aaf289773e141a92dbc0b22 + aggregation_key: 8aaf289773e141a92dbc0b22 + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + facets: &id001 + aggregation_key: 8aaf289773e141a92dbc0b22 + domain: messaging + role: consumer + operation_ref: operation.otel.messaging.process-orders.v1.2e3dfcfb341c + local_node_ref: node.otel.service.Billing-Service.d6ddce900d32 + remote_node_ref: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + channel_ref: channel.otel.messaging.orders.v1.891b2277822e + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.1406924e98e3fdf4217b + assertion_kind: property + subject: node.otel.service.Audit-Service.8b3b698a106c + predicate: fiam.property.service-name + polarity: asserted + value: Audit Service + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:service.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:66666666666666666666666666666666/span:1212121212121212 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02.500000Z' + valid_time: + valid_from: '2026-09-09T07:00:02.500000Z' + valid_until: '2026-09-09T07:00:02.500000Z' + observed_at: '2026-09-09T07:00:02.500000Z' +- id: assertion.otel.16564bbbbc499dd2dd77 + assertion_kind: property + subject: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + predicate: fiam.property.service-name + polarity: asserted + value: Telemetry Aggregator + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:service.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.1b791941a5e658021737 + assertion_kind: property + subject: binding.otel.messaging.Audit-Service-kafka-orders.v1-consumer.a8f9f5454efb + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:02.500000Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:44cadec49111a7657123fa3d + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:44cadec49111a7657123fa3d + aggregation_key: 44cadec49111a7657123fa3d + sample_spans: + - trace:66666666666666666666666666666666/span:1212121212121212 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02.500000Z' + facets: &id003 + aggregation_key: 44cadec49111a7657123fa3d + domain: messaging + role: consumer + operation_ref: operation.otel.messaging.receive-orders.v1.f57d4d4e31bc + local_node_ref: node.otel.service.Audit-Service.8b3b698a106c + remote_node_ref: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + channel_ref: channel.otel.messaging.orders.v1.891b2277822e + valid_time: + valid_from: '2026-09-09T07:00:02.500000Z' + valid_until: '2026-09-09T07:00:02.500000Z' + observed_at: '2026-09-09T07:00:02.500000Z' +- id: assertion.otel.1c820c4ec27c5909e792 + assertion_kind: property + subject: resource.otel.db.public.integration_exchange.84bc7a7ef21d + predicate: fiam.property.database-namespace + polarity: asserted + value: integration + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:db.namespace + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.namespace + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + - trace:55555555555555555555555555555555/span:ffffffffffffffff + sample_batch_hashes: + - 3d49ec82e4da1da6a0841eaca0c5530b8d9029eb488664a19eb388ab7fff7e7a + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.1ca8d16998e960371e13 + assertion_kind: property + subject: operation.otel.db.SELECT-public.integration_exchange.2b77ce48158e + predicate: fiam.property.database-operation-name + polarity: asserted + value: SELECT + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:db.operation.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.operation.name + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.1cd682abedc6075275e0 + assertion_kind: property + subject: resource.otel.db.public.integration_exchange.84bc7a7ef21d + predicate: fiam.property.database-collection-name + polarity: asserted + value: public.integration_exchange + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:db.collection.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.collection.name + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + - trace:55555555555555555555555555555555/span:ffffffffffffffff + sample_batch_hashes: + - 3d49ec82e4da1da6a0841eaca0c5530b8d9029eb488664a19eb388ab7fff7e7a + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.1d118a7e7df17974a296 + assertion_kind: property + subject: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:02Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:8aaf289773e141a92dbc0b22 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:8aaf289773e141a92dbc0b22 + aggregation_key: 8aaf289773e141a92dbc0b22 + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.1f5766edd4ccf570c8ff + assertion_kind: property + subject: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:03Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:201134bc52a0f40f21e5656a + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:201134bc52a0f40f21e5656a + aggregation_key: 201134bc52a0f40f21e5656a + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.20383a15dfff006d4259 + assertion_kind: property + subject: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:8aaf289773e141a92dbc0b22 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:8aaf289773e141a92dbc0b22 + aggregation_key: 8aaf289773e141a92dbc0b22 + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.2471a4303f4bde9cf4c5 + assertion_kind: property + subject: node.otel.service.Order-Service.a75279f84c2c + predicate: fiam.property.service-name + polarity: asserted + value: Order Service + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:service.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.2665e1f43365babd7372 + assertion_kind: property + subject: node.otel.service.Billing-Service.d6ddce900d32 + predicate: fiam.property.service-name + polarity: asserted + value: Billing Service + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:service.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.2904126e3395802c8ef9 + assertion_kind: property + subject: channel.otel.messaging.orders.v1.891b2277822e + predicate: fiam.property.messaging-destination-name + polarity: asserted + value: orders.v1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:messaging.destination.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.destination.name + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + - trace:33333333333333333333333333333333/span:dddddddddddddddd + - trace:66666666666666666666666666666666/span:1212121212121212 + sample_batch_hashes: + - 3d49ec82e4da1da6a0841eaca0c5530b8d9029eb488664a19eb388ab7fff7e7a + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.29c5a478c622c3d3247b + assertion_kind: property + subject: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:02Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:8aaf289773e141a92dbc0b22 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:8aaf289773e141a92dbc0b22 + aggregation_key: 8aaf289773e141a92dbc0b22 + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.2d09d71c7673ce21d6db + assertion_kind: property + subject: node.otel.service.Application-A.cfbc55b42036 + predicate: fiam.property.service-name + polarity: asserted + value: Application A + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:service.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.32d894c7e2c12b287e53 + assertion_kind: property + subject: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:04Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:508461318135f08b1d916347 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:508461318135f08b1d916347 + aggregation_key: 508461318135f08b1d916347 + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + facets: &id004 + aggregation_key: 508461318135f08b1d916347 + domain: database + role: client + operation_ref: operation.otel.db.SELECT-public.integration_exchange.2b77ce48158e + local_node_ref: node.otel.service.Application-B.e415ac492d2e + remote_node_ref: node.otel.database.postgresql.db.internal:5432.03855f9892af + resource_ref: resource.otel.db.public.integration_exchange.84bc7a7ef21d + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.370ca75692d9390b726d + assertion_kind: relation + subject: interaction.sample.508461318135f08b1d916347.ffffffffffffffff + predicate: fiam.relation.reads-from + polarity: asserted + object_ref: resource.otel.db.public.integration_exchange.84bc7a7ef21d + evidence: + mode: fiam.evidence.inferred + source: + type: database-operation-semantics + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: inference:database-operation-effect + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: inference:database-operation-effect + db.operation.name: SELECT + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 0.97 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.3abec1aeba924bc63894 + assertion_kind: property + subject: binding.otel.messaging.Audit-Service-kafka-orders.v1-consumer.a8f9f5454efb + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:02.500000Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:44cadec49111a7657123fa3d + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:44cadec49111a7657123fa3d + aggregation_key: 44cadec49111a7657123fa3d + sample_spans: + - trace:66666666666666666666666666666666/span:1212121212121212 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02.500000Z' + facets: *id003 + valid_time: + valid_from: '2026-09-09T07:00:02.500000Z' + valid_until: '2026-09-09T07:00:02.500000Z' + observed_at: '2026-09-09T07:00:02.500000Z' +- id: assertion.otel.434be08ba01f8d6aab9d + assertion_kind: property + subject: operation.otel.rpc.StreamTelemetry.552f69398b3d + predicate: fiam.property.rpc-system-name + polarity: asserted + value: grpc + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:rpc.system.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.system.name + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.48143cfd29eb7b6bafc3 + assertion_kind: property + subject: operation.otel.rpc.StreamTelemetry.7785627aa978 + predicate: fiam.property.rpc-system-name + polarity: asserted + value: grpc + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:rpc.system.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.system.name + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.488ba561f69eb2a73cd4 + assertion_kind: property + subject: operation.otel.messaging.process-orders.v1.2e3dfcfb341c + predicate: fiam.property.messaging-system + polarity: asserted + value: kafka + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:messaging.system + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.system + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.4bf94821972e913192a4 + assertion_kind: property + subject: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:508461318135f08b1d916347 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:508461318135f08b1d916347 + aggregation_key: 508461318135f08b1d916347 + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + facets: *id004 + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.5acbc8778a106fd34b70 + assertion_kind: property + subject: operation.otel.messaging.process-orders.v1.2e3dfcfb341c + predicate: fiam.property.messaging-operation-name + polarity: asserted + value: consume + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:messaging.operation.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.operation.name + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.5b34af908631ef11888c + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:43bc423016df8daaec891605 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:43bc423016df8daaec891605 + aggregation_key: 43bc423016df8daaec891605 + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + facets: &id005 + aggregation_key: 43bc423016df8daaec891605 + domain: rpc + role: server + operation_ref: operation.otel.rpc.StreamTelemetry.7785627aa978 + local_node_ref: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.5fb409ee4ea4c44f644f + assertion_kind: property + subject: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.postgresql-frontend-backend + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:db.system.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.system.name + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.646f35d7c4ab43786354 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:43bc423016df8daaec891605 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:43bc423016df8daaec891605 + aggregation_key: 43bc423016df8daaec891605 + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + facets: *id005 + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.664d49f369e7d24aedfa + assertion_kind: property + subject: node.otel.service.Application-B.e415ac492d2e + predicate: fiam.property.service-name + polarity: asserted + value: Application B + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:service.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.67f5cb7d53c3bc0b042c + assertion_kind: property + subject: operation.otel.rpc.StreamTelemetry.552f69398b3d + predicate: fiam.property.rpc-method + polarity: asserted + value: TelemetryService/StreamTelemetry + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:rpc.method + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.method + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.6a511b8ecaca6de254c3 + assertion_kind: property + subject: binding.otel.messaging.Audit-Service-kafka-orders.v1-consumer.a8f9f5454efb + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:44cadec49111a7657123fa3d + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:44cadec49111a7657123fa3d + aggregation_key: 44cadec49111a7657123fa3d + sample_spans: + - trace:66666666666666666666666666666666/span:1212121212121212 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02.500000Z' + facets: *id003 + valid_time: + valid_from: '2026-09-09T07:00:02.500000Z' + valid_until: '2026-09-09T07:00:02.500000Z' + observed_at: '2026-09-09T07:00:02.500000Z' +- id: assertion.otel.6b173bf6db8a03ed4c7c + assertion_kind: property + subject: operation.otel.messaging.process-orders.v1.2e3dfcfb341c + predicate: fiam.property.messaging-operation-type + polarity: asserted + value: process + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:messaging.operation.type + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.operation.type + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.6bbcaa4be952e1b93214 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:00.010000Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:43bc423016df8daaec891605 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:43bc423016df8daaec891605 + aggregation_key: 43bc423016df8daaec891605 + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + facets: *id005 + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.6c231f1fc419eda4896b + assertion_kind: property + subject: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:201134bc52a0f40f21e5656a + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:201134bc52a0f40f21e5656a + aggregation_key: 201134bc52a0f40f21e5656a + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.7406fe78cf99d3a341cb + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:2ccec9f9ed32803fa562b76c + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2ccec9f9ed32803fa562b76c + aggregation_key: 2ccec9f9ed32803fa562b76c + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: &id006 + aggregation_key: 2ccec9f9ed32803fa562b76c + domain: rpc + role: client + operation_ref: operation.otel.rpc.StreamTelemetry.552f69398b3d + local_node_ref: node.otel.service.Telemetry-Client.78936dd205bd + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.7db8e7fc7b81c9797c64 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.grpc + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:rpc.system.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.system.name + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.81b1e9e2534ae1b4b43e + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + predicate: fiam.property.runtime-last-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:2ccec9f9ed32803fa562b76c + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2ccec9f9ed32803fa562b76c + aggregation_key: 2ccec9f9ed32803fa562b76c + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id006 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.85bb706ed46a335b40d1 + assertion_kind: property + subject: operation.otel.rpc.StreamTelemetry.7785627aa978 + predicate: fiam.property.rpc-method + polarity: asserted + value: TelemetryService/StreamTelemetry + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:rpc.method + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.method + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.8652d9d1b886ff9e8bf3 + assertion_kind: property + subject: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:04Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:508461318135f08b1d916347 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:508461318135f08b1d916347 + aggregation_key: 508461318135f08b1d916347 + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + facets: *id004 + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.86d71a04d26ead055b8b + assertion_kind: property + subject: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + predicate: fiam.property.database-system-name + polarity: asserted + value: postgresql + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:db.system.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.system.name + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.88937c2b701ad7fcb35f + assertion_kind: property + subject: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:508461318135f08b1d916347 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:508461318135f08b1d916347 + aggregation_key: 508461318135f08b1d916347 + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + facets: *id004 + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.8911b188c96835519d73 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.grpc + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:rpc.system.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:rpc.system.name + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.9016b0861072359b9854 + assertion_kind: property + subject: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:508461318135f08b1d916347 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:508461318135f08b1d916347 + aggregation_key: 508461318135f08b1d916347 + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + facets: *id004 + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.9a601a9d9911501f88e0 + assertion_kind: property + subject: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:01Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:581d83f560b25eaf272c5bc3 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:581d83f560b25eaf272c5bc3 + aggregation_key: 581d83f560b25eaf272c5bc3 + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: *id007 + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.a51dca2be00d77d91fae + assertion_kind: property + subject: operation.otel.messaging.send-orders.v1.e27097565779 + predicate: fiam.property.messaging-operation-type + polarity: asserted + value: send + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:messaging.operation.type + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.operation.type + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.aafa0212fb3fdb91aff6 + assertion_kind: property + subject: binding.otel.messaging.Audit-Service-kafka-orders.v1-consumer.a8f9f5454efb + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.kafka + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:messaging.system + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.system + sample_spans: + - trace:66666666666666666666666666666666/span:1212121212121212 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02.500000Z' + valid_time: + valid_from: '2026-09-09T07:00:02.500000Z' + valid_until: '2026-09-09T07:00:02.500000Z' + observed_at: '2026-09-09T07:00:02.500000Z' +- id: assertion.otel.acb56a6457756f7993ca + assertion_kind: property + subject: node.otel.service.Telemetry-Client.78936dd205bd + predicate: fiam.property.service-name + polarity: asserted + value: Telemetry Client + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:service.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:service.name + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.af492a3d4c838f47b9ee + assertion_kind: property + subject: binding.otel.messaging.Audit-Service-kafka-orders.v1-consumer.a8f9f5454efb + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:44cadec49111a7657123fa3d + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:44cadec49111a7657123fa3d + aggregation_key: 44cadec49111a7657123fa3d + sample_spans: + - trace:66666666666666666666666666666666/span:1212121212121212 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02.500000Z' + facets: *id003 + valid_time: + valid_from: '2026-09-09T07:00:02.500000Z' + valid_until: '2026-09-09T07:00:02.500000Z' + observed_at: '2026-09-09T07:00:02.500000Z' +- id: assertion.otel.b29c029d95086f3dd029 + assertion_kind: property + subject: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:201134bc52a0f40f21e5656a + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:201134bc52a0f40f21e5656a + aggregation_key: 201134bc52a0f40f21e5656a + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.b2b5c8e23fbea5ee11be + assertion_kind: property + subject: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:581d83f560b25eaf272c5bc3 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:581d83f560b25eaf272c5bc3 + aggregation_key: 581d83f560b25eaf272c5bc3 + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: *id007 + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.b3713db26c560c3ee9d5 + assertion_kind: property + subject: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + predicate: fiam.property.database-system-name + polarity: asserted + value: postgresql + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:db.system.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.system.name + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.b406caa6cb3267597397 + assertion_kind: property + subject: operation.otel.messaging.send-orders.v1.e27097565779 + predicate: fiam.property.messaging-operation-name + polarity: asserted + value: publish + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:messaging.operation.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.operation.name + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.bf3fad20e85ef16edb3c + assertion_kind: property + subject: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + predicate: fiam.property.runtime-active + polarity: asserted + value: true + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:8aaf289773e141a92dbc0b22 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:8aaf289773e141a92dbc0b22 + aggregation_key: 8aaf289773e141a92dbc0b22 + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + facets: *id001 + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.c162387a3ed6aa897438 + assertion_kind: property + subject: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:581d83f560b25eaf272c5bc3 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:581d83f560b25eaf272c5bc3 + aggregation_key: 581d83f560b25eaf272c5bc3 + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: *id007 + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.c9e19d3908d56afb37cf + assertion_kind: relation + subject: operation.otel.db.SELECT-public.integration_exchange.2b77ce48158e + predicate: fiam.relation.targets + polarity: asserted + object_ref: resource.otel.db.public.integration_exchange.84bc7a7ef21d + evidence: + mode: fiam.evidence.inferred + source: + type: database-resource-mapping + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:db.collection.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.collection.name + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 0.92 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.ca392eabd5d7fdd02a90 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:2ccec9f9ed32803fa562b76c + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2ccec9f9ed32803fa562b76c + aggregation_key: 2ccec9f9ed32803fa562b76c + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id006 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.cb7d95335b6f057b8c29 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:00Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:2ccec9f9ed32803fa562b76c + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2ccec9f9ed32803fa562b76c + aggregation_key: 2ccec9f9ed32803fa562b76c + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id006 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.cce9983d494446f8b61f + assertion_kind: property + subject: operation.otel.messaging.send-orders.v1.e27097565779 + predicate: fiam.property.messaging-system + polarity: asserted + value: kafka + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:messaging.system + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.system + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.d7cfb566dcd3f7010951 + assertion_kind: property + subject: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.kafka + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:messaging.system + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.system + sample_spans: + - trace:33333333333333333333333333333333/span:dddddddddddddddd + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02Z' + valid_time: + valid_from: '2026-09-09T07:00:02Z' + valid_until: '2026-09-09T07:00:02Z' + observed_at: '2026-09-09T07:00:02Z' +- id: assertion.otel.da953652e040b330be45 + assertion_kind: relation + subject: interaction.sample.201134bc52a0f40f21e5656a.eeeeeeeeeeeeeeee + predicate: fiam.relation.writes-to + polarity: asserted + object_ref: resource.otel.db.public.integration_exchange.84bc7a7ef21d + evidence: + mode: fiam.evidence.inferred + source: + type: database-operation-semantics + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: inference:database-operation-effect + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: inference:database-operation-effect + db.operation.name: INSERT + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 0.97 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.daef738398125dd191fb + assertion_kind: property + subject: operation.otel.messaging.receive-orders.v1.f57d4d4e31bc + predicate: fiam.property.messaging-operation-name + polarity: asserted + value: poll + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:messaging.operation.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.operation.name + sample_spans: + - trace:66666666666666666666666666666666/span:1212121212121212 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02.500000Z' + valid_time: + valid_from: '2026-09-09T07:00:02.500000Z' + valid_until: '2026-09-09T07:00:02.500000Z' + observed_at: '2026-09-09T07:00:02.500000Z' +- id: assertion.otel.dc6aa9632189ad6eb6d3 + assertion_kind: property + subject: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + predicate: fiam.property.communication-protocol + polarity: asserted + value: fiam.protocol.postgresql-frontend-backend + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:db.system.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.system.name + sample_spans: + - trace:55555555555555555555555555555555/span:ffffffffffffffff + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:04Z' + valid_time: + valid_from: '2026-09-09T07:00:04Z' + valid_until: '2026-09-09T07:00:04Z' + observed_at: '2026-09-09T07:00:04Z' +- id: assertion.otel.dfe25a2b70c1dec57d69 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:2ccec9f9ed32803fa562b76c + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:2ccec9f9ed32803fa562b76c + aggregation_key: 2ccec9f9ed32803fa562b76c + sample_spans: + - trace:11111111111111111111111111111111/span:aaaaaaaaaaaaaaaa + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00Z' + facets: *id006 + valid_time: + valid_from: '2026-09-09T07:00:00Z' + valid_until: '2026-09-09T07:00:00Z' + observed_at: '2026-09-09T07:00:00Z' +- id: assertion.otel.e18584da3c2c1b6273b4 + assertion_kind: property + subject: operation.otel.messaging.receive-orders.v1.f57d4d4e31bc + predicate: fiam.property.messaging-operation-type + polarity: asserted + value: receive + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:messaging.operation.type + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.operation.type + sample_spans: + - trace:66666666666666666666666666666666/span:1212121212121212 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02.500000Z' + valid_time: + valid_from: '2026-09-09T07:00:02.500000Z' + valid_until: '2026-09-09T07:00:02.500000Z' + observed_at: '2026-09-09T07:00:02.500000Z' +- id: assertion.otel.e539d30cb8ecb8b13e74 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:43bc423016df8daaec891605 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:43bc423016df8daaec891605 + aggregation_key: 43bc423016df8daaec891605 + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + facets: *id005 + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.ec2eaad15d9e0f29b7ce + assertion_kind: property + subject: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + predicate: fiam.property.runtime-observation-count + polarity: asserted + value: 1 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:201134bc52a0f40f21e5656a + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:201134bc52a0f40f21e5656a + aggregation_key: 201134bc52a0f40f21e5656a + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + facets: *id002 + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +- id: assertion.otel.ed144c61299b5f17b6c1 + assertion_kind: property + subject: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + predicate: fiam.property.runtime-first-seen + polarity: asserted + value: '2026-09-09T07:00:00.010000Z' + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:43bc423016df8daaec891605 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:43bc423016df8daaec891605 + aggregation_key: 43bc423016df8daaec891605 + sample_spans: + - trace:11111111111111111111111111111111/span:bbbbbbbbbbbbbbbb + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:00.010000Z' + facets: *id005 + valid_time: + valid_from: '2026-09-09T07:00:00.010000Z' + valid_until: '2026-09-09T07:00:00.010000Z' + observed_at: '2026-09-09T07:00:00.010000Z' +- id: assertion.otel.ee0046d45a966b315d0d + assertion_kind: property + subject: operation.otel.messaging.receive-orders.v1.f57d4d4e31bc + predicate: fiam.property.messaging-system + polarity: asserted + value: kafka + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:messaging.system + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:messaging.system + sample_spans: + - trace:66666666666666666666666666666666/span:1212121212121212 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02.500000Z' + valid_time: + valid_from: '2026-09-09T07:00:02.500000Z' + valid_until: '2026-09-09T07:00:02.500000Z' + observed_at: '2026-09-09T07:00:02.500000Z' +- id: assertion.otel.ee4b862053d604a104d9 + assertion_kind: property + subject: binding.otel.messaging.Audit-Service-kafka-orders.v1-consumer.a8f9f5454efb + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:44cadec49111a7657123fa3d + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:44cadec49111a7657123fa3d + aggregation_key: 44cadec49111a7657123fa3d + sample_spans: + - trace:66666666666666666666666666666666/span:1212121212121212 + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:02.500000Z' + facets: *id003 + valid_time: + valid_from: '2026-09-09T07:00:02.500000Z' + valid_until: '2026-09-09T07:00:02.500000Z' + observed_at: '2026-09-09T07:00:02.500000Z' +- id: assertion.otel.f7ebe90dd903ccf1ee9e + assertion_kind: property + subject: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + predicate: fiam.property.runtime-error-count + polarity: asserted + value: 0 + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-aggregate + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: aggregate:581d83f560b25eaf272c5bc3 + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: aggregate:581d83f560b25eaf272c5bc3 + aggregation_key: 581d83f560b25eaf272c5bc3 + sample_spans: + - trace:22222222222222222222222222222222/span:cccccccccccccccc + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:01Z' + facets: *id007 + valid_time: + valid_from: '2026-09-09T07:00:01Z' + valid_until: '2026-09-09T07:00:01Z' + observed_at: '2026-09-09T07:00:01Z' +- id: assertion.otel.fa3009f24f9b5306bdd3 + assertion_kind: property + subject: operation.otel.db.INSERT-public.integration_exchange.92bf26c60bf6 + predicate: fiam.property.database-operation-name + polarity: asserted + value: INSERT + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-stream + ref: artifact.otel.stream.multidomain-runtime.otlp.c2267b7b9c04 + locator: attribute:db.operation.name + metadata: + source: real-world/otel/multidomain-runtime.otlp.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + locator_class: attribute:db.operation.name + sample_spans: + - trace:44444444444444444444444444444444/span:eeeeeeeeeeeeeeee + observer: otel-ingest/v0.2-draft.4 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T07:00:03Z' + valid_time: + valid_from: '2026-09-09T07:00:03Z' + valid_until: '2026-09-09T07:00:03Z' + observed_at: '2026-09-09T07:00:03Z' +interactions: +- id: interaction.sample.201134bc52a0f40f21e5656a.eeeeeeeeeeeeeeee + kind: interaction + operation: operation.otel.db.INSERT-public.integration_exchange.92bf26c60bf6 + contract: contract.otel.db.Application-A-postgresql.d8124174d2c9 + binding: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + interaction_style: fiam.interaction-style.command + temporal_semantics: fiam.temporal.synchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + initiator: node.otel.service.Application-A.cfbc55b42036 + responder: node.otel.database.postgresql.db.internal:5432.03855f9892af + facets: + otel_trace_id: '44444444444444444444444444444444' + otel_span_id: eeeeeeeeeeeeeeee + otel_span_kind: client + instrumentation_scope: runtime-fixture + observed_service: node.otel.service.Application-A.cfbc55b42036 +- id: interaction.sample.2ccec9f9ed32803fa562b76c.aaaaaaaaaaaaaaaa + kind: interaction + operation: operation.otel.rpc.StreamTelemetry.552f69398b3d + contract: contract.otel.rpc.Telemetry-Client-grpc.7c8fe2572a80 + binding: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + interaction_style: fiam.interaction-style.rpc + temporal_semantics: fiam.temporal.synchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + initiator: node.otel.service.Telemetry-Client.78936dd205bd + facets: + otel_trace_id: '11111111111111111111111111111111' + otel_span_id: aaaaaaaaaaaaaaaa + otel_span_kind: client + instrumentation_scope: runtime-fixture + observed_service: node.otel.service.Telemetry-Client.78936dd205bd +- id: interaction.sample.43bc423016df8daaec891605.bbbbbbbbbbbbbbbb + kind: interaction + operation: operation.otel.rpc.StreamTelemetry.7785627aa978 + contract: contract.otel.rpc.Telemetry-Aggregator-grpc.514ae3c41ea1 + binding: binding.otel.rpc.Telemetry-Aggregator-grpc-telemetry.internal:4317-server.4068bfb9f9f5 + interaction_style: fiam.interaction-style.rpc + temporal_semantics: fiam.temporal.synchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + responder: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + facets: + otel_trace_id: '11111111111111111111111111111111' + otel_span_id: bbbbbbbbbbbbbbbb + otel_span_kind: server + instrumentation_scope: runtime-fixture + observed_service: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + otel_parent_span_id: aaaaaaaaaaaaaaaa +- id: interaction.sample.44cadec49111a7657123fa3d.1212121212121212 + kind: interaction + operation: operation.otel.messaging.receive-orders.v1.f57d4d4e31bc + contract: contract.otel.messaging.Audit-Service-kafka.800efba6af2c + binding: binding.otel.messaging.Audit-Service-kafka-orders.v1-consumer.a8f9f5454efb + channel: channel.otel.messaging.orders.v1.891b2277822e + interaction_style: fiam.interaction-style.subscribe + temporal_semantics: fiam.temporal.asynchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + consumer: node.otel.service.Audit-Service.8b3b698a106c + broker: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + facets: + otel_trace_id: '66666666666666666666666666666666' + otel_span_id: '1212121212121212' + otel_span_kind: client + instrumentation_scope: runtime-fixture + observed_service: node.otel.service.Audit-Service.8b3b698a106c + otel_links: + - 22222222222222222222222222222222:cccccccccccccccc +- id: interaction.sample.508461318135f08b1d916347.ffffffffffffffff + kind: interaction + operation: operation.otel.db.SELECT-public.integration_exchange.2b77ce48158e + contract: contract.otel.db.Application-B-postgresql.f40dfb73e126 + binding: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + interaction_style: fiam.interaction-style.query + temporal_semantics: fiam.temporal.synchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + initiator: node.otel.service.Application-B.e415ac492d2e + responder: node.otel.database.postgresql.db.internal:5432.03855f9892af + facets: + otel_trace_id: '55555555555555555555555555555555' + otel_span_id: ffffffffffffffff + otel_span_kind: client + instrumentation_scope: runtime-fixture + observed_service: node.otel.service.Application-B.e415ac492d2e +- id: interaction.sample.581d83f560b25eaf272c5bc3.cccccccccccccccc + kind: interaction + operation: operation.otel.messaging.send-orders.v1.e27097565779 + contract: contract.otel.messaging.Order-Service-kafka.eb23fcd426e8 + binding: binding.otel.messaging.Order-Service-kafka-orders.v1-producer.9673ecd8d591 + channel: channel.otel.messaging.orders.v1.891b2277822e + interaction_style: fiam.interaction-style.publish + temporal_semantics: fiam.temporal.asynchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + producer: node.otel.service.Order-Service.a75279f84c2c + broker: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + facets: + otel_trace_id: '22222222222222222222222222222222' + otel_span_id: cccccccccccccccc + otel_span_kind: producer + instrumentation_scope: runtime-fixture + observed_service: node.otel.service.Order-Service.a75279f84c2c +- id: interaction.sample.8aaf289773e141a92dbc0b22.dddddddddddddddd + kind: interaction + operation: operation.otel.messaging.process-orders.v1.2e3dfcfb341c + contract: contract.otel.messaging.Billing-Service-kafka.18363aba2a59 + binding: binding.otel.messaging.Billing-Service-kafka-orders.v1-consumer.c996d365e90a + channel: channel.otel.messaging.orders.v1.891b2277822e + interaction_style: fiam.interaction-style.subscribe + temporal_semantics: fiam.temporal.asynchronous + execution_boundary: fiam.execution-boundary.remote-network + realization_status: fiam.interaction-status.completed + participants: + consumer: node.otel.service.Billing-Service.d6ddce900d32 + broker: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad + facets: + otel_trace_id: '33333333333333333333333333333333' + otel_span_id: dddddddddddddddd + otel_span_kind: consumer + instrumentation_scope: runtime-fixture + observed_service: node.otel.service.Billing-Service.d6ddce900d32 + otel_links: + - 22222222222222222222222222222222:cccccccccccccccc +channels: +- id: channel.otel.messaging.orders.v1.891b2277822e + kind: channel + name: orders.v1 + channel_type: fiam.channel.durable-topic + mediation: fiam.mediation.brokered + facets: + identity_tuple: + kind: messaging-channel + system: kafka + logical_broker: kafka.internal:9092 + destination: orders.v1 + zone: + - '' + - '' + - '' + - '' + - '' + owner: node.otel.broker.kafka.kafka.internal:9092.8069db3983ad +information_resources: +- id: resource.otel.db.public.integration_exchange.84bc7a7ef21d + kind: information-resource + name: public.integration_exchange + resource_kind: fiam.information-resource.relational-table + resource_scope: fiam.resource-scope.concrete-collection + selectors: + - kind: fiam.resource-selector.sql-qualified-name + value: public.integration_exchange + facets: + identity_tuple: + kind: database-resource + system: postgresql + logical_server: db.internal:5432 + namespace: integration + collection: public.integration_exchange + zone: + - '' + - '' + - '' + - '' + - '' + owner: node.otel.database.postgresql.db.internal:5432.03855f9892af diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/multidomain-runtime.otlp.json b/history/FIAM_v0.2_Draft6/real-world/otel/multidomain-runtime.otlp.json new file mode 100644 index 0000000..17f0670 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/multidomain-runtime.otlp.json @@ -0,0 +1,499 @@ +{ + "resourceSpans": [ + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Telemetry Client" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "runtime-fixture", + "version": "0.2-draft.3" + }, + "spans": [ + { + "traceId": "11111111111111111111111111111111", + "spanId": "aaaaaaaaaaaaaaaa", + "kind": 3, + "name": "TelemetryService/StreamTelemetry", + "startTimeUnixNano": "1788937200000000000", + "endTimeUnixNano": "1788937200050000000", + "attributes": [ + { + "key": "rpc.system.name", + "value": { + "stringValue": "grpc" + } + }, + { + "key": "rpc.method", + "value": { + "stringValue": "TelemetryService/StreamTelemetry" + } + }, + { + "key": "rpc.response.status_code", + "value": { + "stringValue": "OK" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "telemetry.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "4317" + } + } + ] + } + ] + } + ] + }, + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Telemetry Aggregator" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "runtime-fixture", + "version": "0.2-draft.3" + }, + "spans": [ + { + "traceId": "11111111111111111111111111111111", + "spanId": "bbbbbbbbbbbbbbbb", + "kind": 2, + "name": "TelemetryService/StreamTelemetry", + "startTimeUnixNano": "1788937200010000000", + "endTimeUnixNano": "1788937200060000000", + "attributes": [ + { + "key": "rpc.system.name", + "value": { + "stringValue": "grpc" + } + }, + { + "key": "rpc.method", + "value": { + "stringValue": "TelemetryService/StreamTelemetry" + } + }, + { + "key": "rpc.response.status_code", + "value": { + "stringValue": "OK" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "telemetry.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "4317" + } + } + ], + "parentSpanId": "aaaaaaaaaaaaaaaa" + } + ] + } + ] + }, + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Order Service" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "runtime-fixture", + "version": "0.2-draft.3" + }, + "spans": [ + { + "traceId": "22222222222222222222222222222222", + "spanId": "cccccccccccccccc", + "kind": 4, + "name": "publish orders.v1", + "startTimeUnixNano": "1788937201000000000", + "endTimeUnixNano": "1788937201050000000", + "attributes": [ + { + "key": "messaging.system", + "value": { + "stringValue": "kafka" + } + }, + { + "key": "messaging.destination.name", + "value": { + "stringValue": "orders.v1" + } + }, + { + "key": "messaging.operation.name", + "value": { + "stringValue": "publish" + } + }, + { + "key": "messaging.operation.type", + "value": { + "stringValue": "send" + } + }, + { + "key": "messaging.message.id", + "value": { + "stringValue": "order-42" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "kafka.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "9092" + } + } + ] + } + ] + } + ] + }, + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Billing Service" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "runtime-fixture", + "version": "0.2-draft.3" + }, + "spans": [ + { + "traceId": "33333333333333333333333333333333", + "spanId": "dddddddddddddddd", + "kind": 5, + "name": "consume orders.v1", + "startTimeUnixNano": "1788937202000000000", + "endTimeUnixNano": "1788937202050000000", + "attributes": [ + { + "key": "messaging.system", + "value": { + "stringValue": "kafka" + } + }, + { + "key": "messaging.destination.name", + "value": { + "stringValue": "orders.v1" + } + }, + { + "key": "messaging.operation.name", + "value": { + "stringValue": "consume" + } + }, + { + "key": "messaging.operation.type", + "value": { + "stringValue": "process" + } + }, + { + "key": "messaging.message.id", + "value": { + "stringValue": "order-42" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "kafka.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "9092" + } + } + ], + "links": [ + { + "traceId": "22222222222222222222222222222222", + "spanId": "cccccccccccccccc" + } + ] + } + ] + } + ] + }, + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Audit Service" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "runtime-fixture", + "version": "0.2-draft.3" + }, + "spans": [ + { + "traceId": "66666666666666666666666666666666", + "spanId": "1212121212121212", + "kind": 3, + "name": "poll orders.v1", + "startTimeUnixNano": "1788937202500000000", + "endTimeUnixNano": "1788937202550000000", + "attributes": [ + { + "key": "messaging.system", + "value": { + "stringValue": "kafka" + } + }, + { + "key": "messaging.destination.name", + "value": { + "stringValue": "orders.v1" + } + }, + { + "key": "messaging.operation.name", + "value": { + "stringValue": "poll" + } + }, + { + "key": "messaging.operation.type", + "value": { + "stringValue": "receive" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "kafka.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "9092" + } + } + ], + "links": [ + { + "traceId": "22222222222222222222222222222222", + "spanId": "cccccccccccccccc" + } + ] + } + ] + } + ] + }, + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Application A" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "runtime-fixture", + "version": "0.2-draft.3" + }, + "spans": [ + { + "traceId": "44444444444444444444444444444444", + "spanId": "eeeeeeeeeeeeeeee", + "kind": 3, + "name": "INSERT public.integration_exchange", + "startTimeUnixNano": "1788937203000000000", + "endTimeUnixNano": "1788937203050000000", + "attributes": [ + { + "key": "db.system.name", + "value": { + "stringValue": "postgresql" + } + }, + { + "key": "db.namespace", + "value": { + "stringValue": "integration" + } + }, + { + "key": "db.collection.name", + "value": { + "stringValue": "public.integration_exchange" + } + }, + { + "key": "db.operation.name", + "value": { + "stringValue": "INSERT" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "db.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "5432" + } + } + ] + } + ] + } + ] + }, + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Application B" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "runtime-fixture", + "version": "0.2-draft.3" + }, + "spans": [ + { + "traceId": "55555555555555555555555555555555", + "spanId": "ffffffffffffffff", + "kind": 3, + "name": "SELECT public.integration_exchange", + "startTimeUnixNano": "1788937204000000000", + "endTimeUnixNano": "1788937204050000000", + "attributes": [ + { + "key": "db.system.name", + "value": { + "stringValue": "postgresql" + } + }, + { + "key": "db.namespace", + "value": { + "stringValue": "integration" + } + }, + { + "key": "db.collection.name", + "value": { + "stringValue": "public.integration_exchange" + } + }, + { + "key": "db.operation.name", + "value": { + "stringValue": "SELECT" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "db.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "5432" + } + }, + { + "key": "db.query.text", + "value": { + "stringValue": "SELECT * FROM public.integration_exchange WHERE secret='do-not-copy'" + } + } + ] + } + ] + } + ] + } + ] +} diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/multidomain-runtime.topology.md b/history/FIAM_v0.2_Draft6/real-world/otel/multidomain-runtime.topology.md new file mode 100644 index 0000000..016cbd4 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/multidomain-runtime.topology.md @@ -0,0 +1,19 @@ +# Runtime Interaction Topology + +Model: `model.otel.catalog.multidomain-runtime.otlp` + +## Summary + +- **database:** 2 +- **messaging:** 2 +- **rpc:** 1 +- **unresolved:** 0 +- **working-set attachments:** 0 + +## Edges + +- Database: **Application B** → **public.integration_exchange** (`resource-read`) +- Database: **Application A** → **public.integration_exchange** (`resource-write`) +- Messaging: **Order Service** → `orders.v1` → **Billing Service** +- Messaging: **Order Service** → `orders.v1` → **Audit Service** +- RPC: **Telemetry Client** → **Telemetry Aggregator** diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/multidomain-runtime.topology.yaml b/history/FIAM_v0.2_Draft6/real-world/otel/multidomain-runtime.topology.yaml new file mode 100644 index 0000000..24e20a6 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/multidomain-runtime.topology.yaml @@ -0,0 +1,84 @@ +lens: fiam.lens.runtime-topology +lens_version: 0.2-draft.4 +model: model.otel.catalog.multidomain-runtime.otlp +summary: + edges: 5 + domains: + database: 2 + messaging: 2 + rpc: 1 + architectural_nodes: 7 + unresolved: 0 + working_set_attachments: 0 +edges: +- id: edge.topology.otel.database.c1ddfac34c71b4b8d3f9 + domain: database + kind: resource-read + count: 1 + first_seen: '2026-09-09T07:00:04Z' + last_seen: '2026-09-09T07:00:04Z' + correlation: span-resource + from: node.otel.service.Application-B.e415ac492d2e + observed_from: node.otel.service.Application-B.e415ac492d2e + to_resource: resource.otel.db.public.integration_exchange.84bc7a7ef21d + observed_to_resource: resource.otel.db.public.integration_exchange.84bc7a7ef21d + binding: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f + observed_binding: binding.otel.db.Application-B-postgresql-db.internal:5432.c789cc58162f +- id: edge.topology.otel.database.d2681a2839139c054290 + domain: database + kind: resource-write + count: 1 + first_seen: '2026-09-09T07:00:03Z' + last_seen: '2026-09-09T07:00:03Z' + correlation: span-resource + from: node.otel.service.Application-A.cfbc55b42036 + observed_from: node.otel.service.Application-A.cfbc55b42036 + to_resource: resource.otel.db.public.integration_exchange.84bc7a7ef21d + observed_to_resource: resource.otel.db.public.integration_exchange.84bc7a7ef21d + binding: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 + observed_binding: binding.otel.db.Application-A-postgresql-db.internal:5432.52e735ccd7c2 +- id: edge.topology.otel.messaging.abbffa57dddbdb8182df + domain: messaging + kind: mediated-message-flow + count: 1 + first_seen: '2026-09-09T07:00:01Z' + last_seen: '2026-09-09T07:00:02Z' + correlation: span-link + from: node.otel.service.Order-Service.a75279f84c2c + observed_from: node.otel.service.Order-Service.a75279f84c2c + to: node.otel.service.Billing-Service.d6ddce900d32 + observed_to: node.otel.service.Billing-Service.d6ddce900d32 + via_channel: channel.otel.messaging.orders.v1.891b2277822e + observed_via_channel: channel.otel.messaging.orders.v1.891b2277822e +- id: edge.topology.otel.messaging.fcc4177258df796107d0 + domain: messaging + kind: mediated-message-flow + count: 1 + first_seen: '2026-09-09T07:00:01Z' + last_seen: '2026-09-09T07:00:02.500000Z' + correlation: span-link + from: node.otel.service.Order-Service.a75279f84c2c + observed_from: node.otel.service.Order-Service.a75279f84c2c + to: node.otel.service.Audit-Service.8b3b698a106c + observed_to: node.otel.service.Audit-Service.8b3b698a106c + via_channel: channel.otel.messaging.orders.v1.891b2277822e + observed_via_channel: channel.otel.messaging.orders.v1.891b2277822e +- id: edge.topology.otel.rpc.68b29be9b90d97664917 + domain: rpc + kind: direct-call + count: 1 + first_seen: '2026-09-09T07:00:00Z' + last_seen: '2026-09-09T07:00:00.010000Z' + correlation: trace-parent + from: node.otel.service.Telemetry-Client.78936dd205bd + observed_from: node.otel.service.Telemetry-Client.78936dd205bd + to: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + observed_to: node.otel.service.Telemetry-Aggregator.ff6cc4a76891 + binding: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + observed_binding: binding.otel.rpc.Telemetry-Client-grpc-telemetry.internal:4317-client.523a92c58051 + operation: operation.otel.rpc.StreamTelemetry.552f69398b3d + observed_operation: operation.otel.rpc.StreamTelemetry.552f69398b3d +unresolved: [] +working_set: + enabled: true + ambiguous: [] diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/otlp-format-smoke.fiam.yaml b/history/FIAM_v0.2_Draft6/real-world/otel/otlp-format-smoke.fiam.yaml new file mode 100644 index 0000000..ed05298 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/otlp-format-smoke.fiam.yaml @@ -0,0 +1,79 @@ +fiam_version: '0.2' +instance: + id: model.otel.otlp-format-smoke + kind: model + title: OpenTelemetry ingest — otlp-format-smoke.json + status: provisional + intent: Runtime-observed FIAM model generated from OTLP/JSON traces. +artifacts: +- id: artifact.otel.otlp-format-smoke + kind: artifact + name: otlp-format-smoke.json + artifact_type: fiam.artifact.telemetry-trace-export + locator: real-world/otel/otlp-format-smoke.json + facets: + format: OTLP/JSON + source_file: otlp-format-smoke.json + observer_profile: OpenTelemetry Semantic Conventions 1.44.0 + describes: + - interaction.otel.11111111111111111111111111111111.2222222222222222 +nodes: +- id: node.otel.fiam-smoke-service + kind: system-node + name: fiam-smoke-service + node_type: fiam.node-type.service + facets: {} +interactions: +- id: interaction.otel.11111111111111111111111111111111.2222222222222222 + kind: interaction + realization_status: fiam.interaction-status.completed + participants: + local: node.otel.fiam-smoke-service + facets: + otel_trace_id: '11111111111111111111111111111111' + otel_span_id: '2222222222222222' + otel_span_kind: server + otel_span_name: generic observed server activity + instrumentation_scope: example.otlp.smoke + observed_service: node.otel.fiam-smoke-service +assertions: +- id: assertion.otel.0001 + assertion_kind: property + subject: node.otel.fiam-smoke-service + predicate: fiam.property.service-name + polarity: asserted + value: fiam-smoke-service + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-export + ref: artifact.otel.otlp-format-smoke + locator: trace:11111111111111111111111111111111/span:2222222222222222 + metadata: + source: real-world/otel/otlp-format-smoke.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + observer: otel-ingest/v0.2-draft.3 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T00:50:00Z' +- id: assertion.otel.0002 + assertion_kind: property + subject: interaction.otel.11111111111111111111111111111111.2222222222222222 + predicate: fiam.property.otel-span-kind + polarity: asserted + value: server + evidence: + mode: fiam.evidence.runtime-observed + source: + type: otlp-trace-export + ref: artifact.otel.otlp-format-smoke + locator: trace:11111111111111111111111111111111/span:2222222222222222 + metadata: + source: real-world/otel/otlp-format-smoke.json + semconv_basis: OpenTelemetry Semantic Conventions 1.44.0 + otlp_basis: OTLP 1.11.0 + observer: otel-ingest/v0.2-draft.3 + confidence: 1.0 + stance: supports + observed_at: '2026-09-09T00:50:00Z' diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/otlp-format-smoke.json b/history/FIAM_v0.2_Draft6/real-world/otel/otlp-format-smoke.json new file mode 100644 index 0000000..cd33c00 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/otlp-format-smoke.json @@ -0,0 +1,17 @@ +{ + "resourceSpans": [{ + "resource": {"attributes": [{"key":"service.name","value":{"stringValue":"fiam-smoke-service"}}]}, + "scopeSpans": [{ + "scope": {"name":"example.otlp.smoke","version":"0.2"}, + "spans": [{ + "traceId":"11111111111111111111111111111111", + "spanId":"2222222222222222", + "name":"generic observed server activity", + "kind":2, + "startTimeUnixNano":"1788915000000000000", + "endTimeUnixNano":"1788915000010000000", + "attributes":[{"key":"fixture.kind","value":{"stringValue":"otlp-json-format-smoke"}}] + }] + }] + }] +} diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/petstore-get-pet-http2.otlp.json b/history/FIAM_v0.2_Draft6/real-world/otel/petstore-get-pet-http2.otlp.json new file mode 100644 index 0000000..c260122 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/petstore-get-pet-http2.otlp.json @@ -0,0 +1,40 @@ +{ + "resourceSpans": [ + { + "resource": { + "attributes": [ + {"key": "service.name", "value": {"stringValue": "swagger-petstore"}}, + {"key": "service.namespace", "value": {"stringValue": "petstore3.swagger.io"}}, + {"key": "service.version", "value": {"stringValue": "1.0.27"}} + ] + }, + "scopeSpans": [ + { + "scope": {"name": "example.http.instrumentation", "version": "1.0.0"}, + "spans": [ + { + "traceId": "7E3A2A4E36B64569BBA44A91A03C3120", + "spanId": "0F1E2D3C4B5A6978", + "name": "GET /api/v3/pet/{petId}", + "kind": 2, + "startTimeUnixNano": "1788915600000000000", + "endTimeUnixNano": "1788915600035000000", + "attributes": [ + {"key": "http.request.method", "value": {"stringValue": "GET"}}, + {"key": "http.route", "value": {"stringValue": "/api/v3/pet/{petId}"}}, + {"key": "url.path", "value": {"stringValue": "/api/v3/pet/12"}}, + {"key": "url.scheme", "value": {"stringValue": "https"}}, + {"key": "server.address", "value": {"stringValue": "petstore3.swagger.io"}}, + {"key": "server.port", "value": {"intValue": "443"}}, + {"key": "network.protocol.version", "value": {"stringValue": "2"}}, + {"key": "http.response.status_code", "value": {"intValue": "200"}}, + {"key": "client.address", "value": {"stringValue": "192.0.2.42"}} + ], + "status": {"code": 1} + } + ] + } + ] + } + ] +} diff --git a/history/FIAM_v0.2_Draft6/real-world/otel/postgres-runtime.otlp.json b/history/FIAM_v0.2_Draft6/real-world/otel/postgres-runtime.otlp.json new file mode 100644 index 0000000..6e2fbaa --- /dev/null +++ b/history/FIAM_v0.2_Draft6/real-world/otel/postgres-runtime.otlp.json @@ -0,0 +1,146 @@ +{ + "resourceSpans": [ + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Application A" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "runtime-fixture", + "version": "0.2-draft.3" + }, + "spans": [ + { + "traceId": "44444444444444444444444444444444", + "spanId": "eeeeeeeeeeeeeeee", + "kind": 3, + "name": "INSERT public.integration_exchange", + "startTimeUnixNano": "1788937203000000000", + "endTimeUnixNano": "1788937203050000000", + "attributes": [ + { + "key": "db.system.name", + "value": { + "stringValue": "postgresql" + } + }, + { + "key": "db.namespace", + "value": { + "stringValue": "integration" + } + }, + { + "key": "db.collection.name", + "value": { + "stringValue": "public.integration_exchange" + } + }, + { + "key": "db.operation.name", + "value": { + "stringValue": "INSERT" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "db.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "5432" + } + } + ] + } + ] + } + ] + }, + { + "resource": { + "attributes": [ + { + "key": "service.name", + "value": { + "stringValue": "Application B" + } + } + ] + }, + "scopeSpans": [ + { + "scope": { + "name": "runtime-fixture", + "version": "0.2-draft.3" + }, + "spans": [ + { + "traceId": "55555555555555555555555555555555", + "spanId": "ffffffffffffffff", + "kind": 3, + "name": "SELECT public.integration_exchange", + "startTimeUnixNano": "1788937204000000000", + "endTimeUnixNano": "1788937204050000000", + "attributes": [ + { + "key": "db.system.name", + "value": { + "stringValue": "postgresql" + } + }, + { + "key": "db.namespace", + "value": { + "stringValue": "integration" + } + }, + { + "key": "db.collection.name", + "value": { + "stringValue": "public.integration_exchange" + } + }, + { + "key": "db.operation.name", + "value": { + "stringValue": "SELECT" + } + }, + { + "key": "server.address", + "value": { + "stringValue": "db.internal" + } + }, + { + "key": "server.port", + "value": { + "intValue": "5432" + } + }, + { + "key": "db.query.text", + "value": { + "stringValue": "SELECT * FROM public.integration_exchange WHERE secret='do-not-copy'" + } + } + ] + } + ] + } + ] + } + ] +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-ArchitectureChangesLens-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-ArchitectureChangesLens-v0.2.schema.json new file mode 100644 index 0000000..89fa5d2 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-ArchitectureChangesLens-v0.2.schema.json @@ -0,0 +1,10 @@ +{ + "$schema":"https://json-schema.org/draft/2020-12/schema", + "$id":"urn:fiam:schema:architecture-changes-lens:0.2", + "title":"FIAM Architecture Changes Lens Definition v0.2", + "type":"object", + "required":["id","version","title","intent","source","requires_authoritative_closure_for_disappearance","classifications"], + "properties":{ + "id":{"const":"fiam.lens.architecture-changes"},"version":{"type":"string"},"title":{"type":"string"},"intent":{"type":"string"},"source":{"const":"persistent-index"},"requires_authoritative_closure_for_disappearance":{"type":"boolean"},"classifications":{"type":"array","items":{"enum":["appeared","disappeared","newly-undeclared"]},"uniqueItems":true,"minItems":3} + },"additionalProperties":false +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-ArchitectureChangesResult-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-ArchitectureChangesResult-v0.2.schema.json new file mode 100644 index 0000000..38c7cb8 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-ArchitectureChangesResult-v0.2.schema.json @@ -0,0 +1,166 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:architecture-changes-result:0.2", + "type": "object", + "required": [ + "lens_id", + "window", + "summary", + "appeared", + "disappeared", + "newly_undeclared" + ], + "properties": { + "lens_id": { + "const": "fiam.lens.architecture-changes" + }, + "window": { + "type": "object", + "required": [ + "since", + "until", + "population_id" + ], + "properties": { + "since": { + "type": "string" + }, + "until": { + "type": "string" + }, + "population_id": { + "type": "string" + } + }, + "additionalProperties": false + }, + "summary": { + "type": "object", + "required": [ + "appeared", + "disappeared", + "newly_undeclared" + ], + "properties": { + "appeared": { + "type": "integer", + "minimum": 0 + }, + "disappeared": { + "type": "integer", + "minimum": 0 + }, + "newly_undeclared": { + "type": "integer", + "minimum": 0 + } + }, + "additionalProperties": false + }, + "appeared": { + "type": "array", + "items": { + "$ref": "#/$defs/edge" + } + }, + "disappeared": { + "type": "array", + "items": { + "$ref": "#/$defs/edge" + } + }, + "newly_undeclared": { + "type": "array", + "items": { + "$ref": "#/$defs/edge" + } + } + }, + "$defs": { + "edge": { + "type": "object", + "required": [ + "edge_key", + "kind", + "from", + "target", + "target_kind", + "declared" + ], + "properties": { + "edge_key": { + "type": "string" + }, + "domain": { + "type": [ + "string", + "null" + ] + }, + "kind": { + "type": "string" + }, + "from": { + "type": "string" + }, + "target": { + "type": "string" + }, + "target_kind": { + "type": "string" + }, + "channel": { + "type": [ + "string", + "null" + ] + }, + "first_seen": { + "type": [ + "string", + "null" + ] + }, + "last_seen": { + "type": [ + "string", + "null" + ] + }, + "valid_from": { + "type": "string" + }, + "closed_at": { + "type": [ + "string", + "null" + ] + }, + "observation_count": { + "type": "integer", + "minimum": 0 + }, + "declared": { + "type": "boolean" + }, + "declaration_matches": { + "type": "array", + "items": { + "type": "object" + } + }, + "declaration_reason": { + "type": "string" + }, + "close_reason": { + "type": [ + "string", + "null" + ] + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-ArchitecturePolicyResult-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-ArchitecturePolicyResult-v0.2.schema.json new file mode 100644 index 0000000..ff74922 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-ArchitecturePolicyResult-v0.2.schema.json @@ -0,0 +1,38 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:fiam-architecturepolicyresult-v0.2", + "type": "object", + "required": [ + "lens_id", + "policy", + "window", + "summary", + "dependencies", + "material_dependencies", + "policy_violations" + ], + "properties": { + "lens_id": { + "const": "fiam.lens.architecture-policy" + }, + "policy": { + "type": "object" + }, + "window": { + "type": "object" + }, + "summary": { + "type": "object" + }, + "dependencies": { + "type": "array" + }, + "material_dependencies": { + "type": "array" + }, + "policy_violations": { + "type": "array" + } + }, + "additionalProperties": true +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-Assertion-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-Assertion-v0.2.schema.json new file mode 100644 index 0000000..83914f5 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-Assertion-v0.2.schema.json @@ -0,0 +1,297 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:assertion:0.2", + "title": "FIAM Assertion v0.2 Schema", + "$ref": "#/$defs/assertion", + "$defs": { + "identifier": { + "type": "string", + "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]*$" + }, + "entityRef": { + "$ref": "#/$defs/identifier" + }, + "termRef": { + "type": "string", + "pattern": "^[A-Za-z][A-Za-z0-9_-]*(?:\\.[A-Za-z0-9_-]+)+$", + "description": "Reference to a FIAM Canon term or local namespaced extension term." + }, + "scalar": { + "type": [ + "string", + "number", + "integer", + "boolean", + "null" + ] + }, + "facetValue": { + "oneOf": [ + { + "$ref": "#/$defs/scalar" + }, + { + "type": "array", + "items": { + "$ref": "#/$defs/scalar" + } + }, + { + "type": "object", + "additionalProperties": true + } + ] + }, + "facets": { + "type": "object", + "additionalProperties": { + "$ref": "#/$defs/facetValue" + } + }, + "evidenceSource": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "object", + "properties": { + "type": { + "type": "string" + }, + "ref": { + "type": "string" + }, + "locator": { + "type": "string" + }, + "metadata": { + "type": "object", + "additionalProperties": true + } + }, + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + } + ] + }, + "evidenceRecord": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "mode": { + "$ref": "#/$defs/termRef" + }, + "source": { + "$ref": "#/$defs/evidenceSource" + }, + "observer": { + "type": "string" + }, + "observed_at": { + "type": "string", + "format": "date-time" + }, + "confidence": { + "type": "number", + "minimum": 0.0, + "maximum": 1.0 + }, + "stance": { + "enum": [ + "supports", + "challenges", + "neutral" + ] + }, + "notes": { + "type": "string" + } + }, + "required": [ + "mode", + "source" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "evidence": { + "oneOf": [ + { + "$ref": "#/$defs/evidenceRecord" + }, + { + "type": "array", + "minItems": 1, + "items": { + "oneOf": [ + { + "$ref": "#/$defs/evidenceRecord" + }, + { + "$ref": "#/$defs/entityRef" + } + ] + } + } + ] + }, + "assertion": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "subject": { + "$ref": "#/$defs/entityRef" + }, + "predicate": { + "$ref": "#/$defs/termRef" + }, + "value": {}, + "valid_time": { + "type": "object", + "properties": { + "observed_at": { + "type": "string", + "format": "date-time" + }, + "valid_from": { + "type": "string", + "format": "date-time" + }, + "valid_until": { + "type": "string", + "format": "date-time" + } + }, + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "evidence": { + "$ref": "#/$defs/evidence" + }, + "facets": { + "$ref": "#/$defs/facets" + }, + "assertion_kind": { + "enum": [ + "property", + "relation" + ] + }, + "polarity": { + "enum": [ + "asserted", + "absent", + "not-applicable", + "unknown" + ], + "description": "Epistemic polarity. Missing information in the graph remains open-world unknown; explicit unknown is used only when an observer/source states uncertainty." + }, + "object_ref": { + "$ref": "#/$defs/entityRef", + "description": "Object of a relation assertion." + }, + "supersedes": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/entityRef" + } + }, + "conflicts_with": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/entityRef" + } + } + }, + "required": [ + "id", + "assertion_kind", + "subject", + "predicate", + "polarity", + "evidence" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false, + "description": "Evidence-backed property or relationship assertion. Relation assertions use object_ref; property assertions use value when polarity is asserted.", + "allOf": [ + { + "if": { + "properties": { + "assertion_kind": { + "const": "property" + }, + "polarity": { + "const": "asserted" + } + }, + "required": [ + "assertion_kind", + "polarity" + ] + }, + "then": { + "required": [ + "value" + ] + } + }, + { + "if": { + "properties": { + "assertion_kind": { + "const": "relation" + }, + "polarity": { + "const": "asserted" + } + }, + "required": [ + "assertion_kind", + "polarity" + ] + }, + "then": { + "required": [ + "object_ref" + ] + } + }, + { + "if": { + "properties": { + "assertion_kind": { + "const": "relation" + } + }, + "required": [ + "assertion_kind" + ] + }, + "then": { + "not": { + "required": [ + "value" + ] + } + } + } + ] + } + } +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-BoundaryDriftLens-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-BoundaryDriftLens-v0.2.schema.json new file mode 100644 index 0000000..7a1e051 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-BoundaryDriftLens-v0.2.schema.json @@ -0,0 +1,10 @@ +{ + "$schema":"https://json-schema.org/draft/2020-12/schema", + "$id":"urn:fiam:schema:boundary-drift-lens:0.2", + "title":"FIAM Boundary Drift Lens Definition v0.2", + "type":"object", + "required":["id","version","title","intent","source","monitored_zone_types"], + "properties":{ + "id":{"const":"fiam.lens.boundary-drift"},"version":{"type":"string"},"title":{"type":"string"},"intent":{"type":"string"},"source":{"const":"persistent-index"},"monitored_zone_types":{"type":"array","items":{"type":"string","pattern":"^fiam\\.zone-type\\."},"minItems":1,"uniqueItems":true} + },"additionalProperties":false +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-BoundaryDriftResult-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-BoundaryDriftResult-v0.2.schema.json new file mode 100644 index 0000000..cfccc5d --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-BoundaryDriftResult-v0.2.schema.json @@ -0,0 +1,131 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:boundary-drift-result:0.2", + "title": "FIAM Boundary Drift Result v0.2", + "type": "object", + "required": [ + "lens_id", + "window", + "summary", + "crossings" + ], + "properties": { + "lens_id": { + "const": "fiam.lens.boundary-drift" + }, + "window": { + "type": "object", + "required": [ + "since", + "until", + "population_id" + ], + "properties": { + "since": { + "type": "string" + }, + "until": { + "type": "string" + }, + "population_id": { + "type": "string" + } + }, + "additionalProperties": false + }, + "summary": { + "type": "object", + "required": [ + "new_cross_zone", + "new_trust_boundary", + "new_organization_boundary" + ], + "properties": { + "new_cross_zone": { + "type": "integer", + "minimum": 0 + }, + "new_trust_boundary": { + "type": "integer", + "minimum": 0 + }, + "new_organization_boundary": { + "type": "integer", + "minimum": 0 + } + }, + "additionalProperties": false + }, + "crossings": { + "type": "array", + "items": { + "type": "object", + "required": [ + "edge_key", + "from", + "target", + "zone_crossings", + "trust_boundary", + "organization_boundary" + ], + "properties": { + "edge_key": { + "type": "string" + }, + "kind": { + "type": "string" + }, + "from": { + "type": "string" + }, + "target": { + "type": "string" + }, + "first_seen": { + "type": [ + "string", + "null" + ] + }, + "zone_crossings": { + "type": "array", + "items": { + "type": "object", + "required": [ + "zone_type", + "from_zones", + "target_zones" + ], + "properties": { + "zone_type": { + "type": "string" + }, + "from_zones": { + "type": "array", + "items": { + "type": "string" + } + }, + "target_zones": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "additionalProperties": false + } + }, + "trust_boundary": { + "type": "boolean" + }, + "organization_boundary": { + "type": "boolean" + } + }, + "additionalProperties": false + } + } + }, + "additionalProperties": false +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-Canon-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-Canon-v0.2.schema.json new file mode 100644 index 0000000..53d5381 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-Canon-v0.2.schema.json @@ -0,0 +1,254 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:canon:0.2", + "title": "FIAM Canon v0.2 Schema", + "type": "object", + "properties": { + "fiam_canon_version": { + "const": "0.2" + }, + "id": { + "type": "string" + }, + "title": { + "type": "string" + }, + "status": { + "type": "string" + }, + "compatible_core_versions": { + "type": "array", + "items": { + "type": "string" + } + }, + "intent": { + "type": "string" + }, + "principles": { + "type": "array", + "items": { + "type": "string" + } + }, + "term_lifecycle": { + "type": "array", + "items": { + "type": "string" + } + }, + "schemes": { + "type": "array", + "items": { + "type": "object", + "required": [ + "id", + "name", + "definition", + "allowed_scopes", + "resolution" + ], + "properties": { + "id": { + "type": "string" + }, + "name": { + "type": "string" + }, + "definition": { + "type": "string" + }, + "allowed_scopes": { + "type": "array", + "items": { + "type": "string" + } + }, + "resolution": { + "type": "object", + "required": [ + "mode" + ], + "properties": { + "mode": { + "enum": [ + "none", + "inherit", + "override", + "refine", + "accumulate", + "contextual", + "derived" + ] + }, + "precedence": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "additionalProperties": false + } + }, + "additionalProperties": true + } + }, + "terms": { + "type": "array", + "items": { + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:term:0.2", + "title": "FIAM Canon Term v0.2 Schema", + "type": "object", + "properties": { + "id": { + "type": "string", + "pattern": "^fiam\\." + }, + "scheme": { + "type": "string", + "pattern": "^fiam\\.scheme\\." + }, + "preferred_label": { + "type": "string", + "minLength": 1 + }, + "definition": { + "type": "string", + "minLength": 1 + }, + "status": { + "enum": [ + "candidate", + "provisional", + "canonical", + "deprecated" + ] + }, + "introduced_in": { + "type": "string" + }, + "alternative_labels": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + }, + "broader": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + }, + "narrower": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + }, + "related": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + }, + "replaced_by": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + }, + "deprecated_reason": { + "type": "string" + }, + "relation_family": { + "type": "string" + }, + "inverse_of": { + "type": "string" + }, + "symmetric": { + "type": "boolean" + }, + "transitive": { + "type": "boolean" + }, + "domain_kinds": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + }, + "range_kinds": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + }, + "sources": { + "type": "array" + }, + "examples": { + "type": "array" + }, + "constraints": { + "type": "array" + } + }, + "required": [ + "id", + "scheme", + "preferred_label", + "definition", + "status", + "introduced_in" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": true + } + }, + "term_usage_constraints": { + "type": "array" + }, + "assertion_predicate_constraints": { + "type": "array" + }, + "relation_facet_constraints": { + "type": "array" + }, + "semantic_policies": { + "type": "object" + }, + "migration_notes": { + "type": "array", + "items": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "object" + } + ] + } + } + }, + "required": [ + "fiam_canon_version", + "id", + "schemes", + "terms", + "semantic_policies" + ], + "additionalProperties": true +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-CatalogExchange-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-CatalogExchange-v0.2.schema.json new file mode 100644 index 0000000..9d56a29 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-CatalogExchange-v0.2.schema.json @@ -0,0 +1,277 @@ +{ + "type": "object", + "required": [ + "catalog_exchange_version", + "profile_id", + "exchange_id", + "created_at", + "source", + "observation", + "records" + ], + "properties": { + "catalog_exchange_version": { + "const": "0.2" + }, + "profile_id": { + "const": "fiam.catalog-exchange.v0.2" + }, + "exchange_id": { + "type": "string", + "minLength": 1 + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "source": { + "type": "object", + "required": [ + "source_id", + "source_kind" + ], + "properties": { + "source_id": { + "type": "string", + "minLength": 1 + }, + "source_kind": { + "type": "string" + }, + "source_ref": { + "type": [ + "string", + "null" + ] + }, + "content_hash": { + "type": [ + "string", + "null" + ] + } + }, + "additionalProperties": false + }, + "observation": { + "type": "object", + "required": [ + "mode", + "snapshot_time" + ], + "properties": { + "mode": { + "enum": [ + "incremental", + "complete-snapshot", + "declared-snapshot" + ] + }, + "observation_scope": { + "type": [ + "string", + "null" + ] + }, + "population_id": { + "type": [ + "string", + "null" + ] + }, + "population": { + "type": "object" + }, + "domains": { + "type": "array", + "uniqueItems": true, + "items": { + "enum": [ + "http", + "rpc", + "messaging", + "database" + ] + } + }, + "snapshot_time": { + "type": "string", + "format": "date-time" + }, + "authority_policy_id": { + "type": [ + "string", + "null" + ] + }, + "aggregate_semantics": { + "enum": [ + "cumulative", + "delta" + ] + } + }, + "additionalProperties": false, + "allOf": [ + { + "if": { + "properties": { + "mode": { + "enum": [ + "incremental", + "complete-snapshot" + ] + } + } + }, + "then": { + "required": [ + "observation_scope", + "population_id", + "domains" + ] + } + } + ] + }, + "records": { + "type": "object", + "required": [ + "entities", + "assertions", + "zone_memberships", + "runtime_aggregates", + "topology_observations", + "unresolved", + "reconciliation_candidates", + "declared_entity_ids" + ], + "properties": { + "entities": { + "type": "array", + "items": { + "type": "object", + "required": [ + "section", + "entity" + ], + "properties": { + "section": { + "type": "string" + }, + "entity": { + "type": "object", + "required": [ + "id" + ] + } + }, + "additionalProperties": false + } + }, + "assertions": { + "type": "array", + "items": { + "type": "object", + "required": [ + "id", + "assertion_kind", + "subject", + "predicate", + "polarity", + "evidence" + ] + } + }, + "zone_memberships": { + "type": "array", + "items": { + "type": "object", + "required": [ + "zone_id", + "member_id" + ], + "properties": { + "zone_id": { + "type": "string" + }, + "member_id": { + "type": "string" + }, + "zone_type": { + "type": [ + "string", + "null" + ] + }, + "derived": { + "type": "boolean" + } + }, + "additionalProperties": false + } + }, + "runtime_aggregates": { + "type": "array", + "items": { + "type": "object", + "required": [ + "id", + "domain", + "operation", + "binding", + "local_node", + "count", + "first_seen", + "last_seen" + ] + } + }, + "topology_observations": { + "type": "array", + "items": { + "type": "object", + "required": [ + "id", + "domain", + "kind", + "count" + ] + } + }, + "unresolved": { + "type": "array", + "items": { + "type": "object", + "required": [ + "id", + "domain", + "reason" + ] + } + }, + "reconciliation_candidates": { + "type": "array", + "items": { + "type": "object", + "required": [ + "observed_ref", + "entity_kind", + "status", + "candidates" + ] + } + }, + "declared_entity_ids": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-Core-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-Core-v0.2.schema.json new file mode 100644 index 0000000..b322f4f --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-Core-v0.2.schema.json @@ -0,0 +1,1430 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:core:0.2", + "title": "FIAM Core v0.2 Draft Baseline", + "description": "Provisional FIAM v0.2 Core baseline. Stabilizes v0.1.1 graph semantics and promotes InformationResource and InformationShape after semantic regression.", + "type": "object", + "required": [ + "fiam_version", + "instance" + ], + "properties": { + "fiam_version": { + "const": "0.2" + }, + "instance": { + "$ref": "#/$defs/instanceDescriptor" + }, + "participants": { + "type": "array", + "items": { + "$ref": "#/$defs/participant" + } + }, + "nodes": { + "type": "array", + "items": { + "$ref": "#/$defs/systemNode" + } + }, + "ports": { + "type": "array", + "items": { + "$ref": "#/$defs/port" + } + }, + "contracts": { + "type": "array", + "items": { + "$ref": "#/$defs/interfaceContract" + } + }, + "endpoints": { + "type": "array", + "items": { + "$ref": "#/$defs/endpoint" + } + }, + "bindings": { + "type": "array", + "items": { + "$ref": "#/$defs/binding" + } + }, + "channels": { + "type": "array", + "items": { + "$ref": "#/$defs/channel" + } + }, + "interactions": { + "type": "array", + "items": { + "$ref": "#/$defs/interaction" + } + }, + "interaction_flows": { + "type": "array", + "items": { + "$ref": "#/$defs/interactionFlow" + } + }, + "artifacts": { + "type": "array", + "items": { + "$ref": "#/$defs/artifact" + } + }, + "zones": { + "type": "array", + "items": { + "$ref": "#/$defs/zone" + } + }, + "security": { + "type": "array", + "items": { + "$ref": "#/$defs/securityProfile" + } + }, + "assertions": { + "type": "array", + "items": { + "$ref": "#/$defs/assertion" + } + }, + "tests": { + "$ref": "#/$defs/specimenTests" + }, + "extensions": { + "type": "object", + "additionalProperties": true + }, + "information_resources": { + "type": "array", + "items": { + "$ref": "#/$defs/informationResource" + } + }, + "information_shapes": { + "type": "array", + "items": { + "$ref": "#/$defs/informationShape" + } + } + }, + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false, + "$defs": { + "identifier": { + "type": "string", + "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]*$" + }, + "entityRef": { + "$ref": "#/$defs/identifier" + }, + "termRef": { + "type": "string", + "pattern": "^[A-Za-z][A-Za-z0-9_-]*(?:\\.[A-Za-z0-9_-]+)+$", + "description": "Reference to a FIAM Canon term or local namespaced extension term." + }, + "termOrTerms": { + "oneOf": [ + { + "$ref": "#/$defs/termRef" + }, + { + "type": "array", + "minItems": 1, + "uniqueItems": true, + "items": { + "$ref": "#/$defs/termRef" + } + } + ] + }, + "scalar": { + "type": [ + "string", + "number", + "integer", + "boolean", + "null" + ] + }, + "facetValue": { + "oneOf": [ + { + "$ref": "#/$defs/scalar" + }, + { + "type": "array", + "items": { + "$ref": "#/$defs/scalar" + } + }, + { + "type": "object", + "additionalProperties": true + } + ] + }, + "facets": { + "type": "object", + "additionalProperties": { + "$ref": "#/$defs/facetValue" + } + }, + "instanceDescriptor": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "type": "string" + }, + "title": { + "type": "string" + }, + "status": { + "enum": [ + "candidate", + "provisional", + "canonical", + "deprecated" + ] + }, + "intent": { + "type": "string" + }, + "description": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id", + "kind" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "participant": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "participant" + }, + "name": { + "type": "string" + }, + "participant_type": { + "$ref": "#/$defs/termRef" + }, + "represented_by": { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "systemNode": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "system-node" + }, + "name": { + "type": "string" + }, + "node_type": { + "$ref": "#/$defs/termRef" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "port": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "port" + }, + "owner": { + "$ref": "#/$defs/entityRef" + }, + "direction": { + "enum": [ + "offers", + "requires", + "bidirectional", + "unspecified" + ], + "deprecated": true, + "description": "Deprecated in v0.1.1. offers/requires are contract participation modes, not directionality. Use participations." + }, + "roles": { + "type": "array", + "minItems": 1, + "uniqueItems": true, + "items": { + "$ref": "#/$defs/termRef" + }, + "deprecated": true, + "description": "Deprecated as a port-global role list. Put contextual roles on participations where possible." + }, + "contracts": { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + }, + "deprecated": true, + "description": "Deprecated as an unqualified contract list. Use participations." + }, + "facets": { + "$ref": "#/$defs/facets" + }, + "participations": { + "type": "array", + "minItems": 1, + "items": { + "$ref": "#/$defs/contractParticipation" + }, + "description": "Contract-specific offered/required participations. Preferred over v0.1 direction/contracts/roles fields." + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "operation": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "operation" + }, + "name": { + "type": "string" + }, + "description": { + "type": "string" + }, + "interaction_style": { + "$ref": "#/$defs/termOrTerms" + }, + "temporal_semantics": { + "$ref": "#/$defs/termOrTerms" + }, + "effect": { + "$ref": "#/$defs/termOrTerms" + }, + "purpose": { + "type": "array", + "items": { + "$ref": "#/$defs/termRef" + } + }, + "representations": { + "type": "array", + "items": { + "$ref": "#/$defs/termRef" + }, + "deprecated": true, + "description": "Deprecated in FIAM v0.2. Representation belongs to a Binding/Interaction or, preferably, the relevant shape-participation relation assertion." + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "interfaceContract": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "interface-contract" + }, + "name": { + "type": "string" + }, + "description": { + "type": "string" + }, + "family_labels": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/termRef" + }, + "description": "Optional denormalized cache of Lens-derived family labels. Normative derived provenance should be retained as inferred assertions (for example with fiam.property.family-label); family labels are not primitive interface types." + }, + "purpose": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/termRef" + } + }, + "contract_forms": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/termRef" + } + }, + "representations": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/termRef" + }, + "deprecated": true, + "description": "Deprecated in FIAM v0.2. Representation belongs to a Binding/Interaction or, preferably, the relevant shape-participation relation assertion." + }, + "operations": { + "type": "array", + "items": { + "$ref": "#/$defs/operation" + } + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "endpoint": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "endpoint" + }, + "binding": { + "$ref": "#/$defs/entityRef", + "deprecated": true, + "description": "Deprecated v0.1 ownership shortcut. v0.1.1 Bindings reference zero or more Endpoints; an Endpoint may be reused by multiple Bindings." + }, + "address": { + "type": "string" + }, + "address_scheme": { + "$ref": "#/$defs/termRef" + }, + "name": { + "type": "string" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "stackItem": { + "type": "object", + "properties": { + "role": { + "$ref": "#/$defs/termRef" + }, + "term": { + "$ref": "#/$defs/termRef" + }, + "version": { + "type": "string" + }, + "profile": { + "type": "string" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "role", + "term" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "addressing": { + "type": "object", + "properties": { + "kind": { + "$ref": "#/$defs/termRef" + }, + "value": {}, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "discovery": { + "type": "object", + "properties": { + "kind": { + "$ref": "#/$defs/termRef" + }, + "source": { + "type": "string" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "binding": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "binding" + }, + "contract": { + "$ref": "#/$defs/entityRef" + }, + "provider_port": { + "$ref": "#/$defs/entityRef" + }, + "consumer_ports": { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + }, + "operations": { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + }, + "binding_profile": { + "$ref": "#/$defs/termRef" + }, + "communication_stack": { + "type": "array", + "items": { + "$ref": "#/$defs/stackItem" + } + }, + "addressing": { + "$ref": "#/$defs/addressing" + }, + "session_model": { + "$ref": "#/$defs/termRef" + }, + "channel": { + "$ref": "#/$defs/entityRef" + }, + "discovery": { + "$ref": "#/$defs/discovery" + }, + "facets": { + "$ref": "#/$defs/facets" + }, + "endpoints": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/entityRef" + }, + "description": "Concrete locators/selectors through which this Binding is available. The same Endpoint may be referenced by multiple Bindings." + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "channel": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "channel" + }, + "owner": { + "$ref": "#/$defs/entityRef" + }, + "channel_type": { + "$ref": "#/$defs/termRef" + }, + "name": { + "type": "string" + }, + "mediation": { + "$ref": "#/$defs/termRef" + }, + "delivery_semantics": { + "$ref": "#/$defs/termRef" + }, + "ordering_scope": { + "$ref": "#/$defs/termRef" + }, + "replay": { + "type": "boolean" + }, + "retention": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "participantMap": { + "type": "object", + "minProperties": 1, + "additionalProperties": { + "oneOf": [ + { + "$ref": "#/$defs/entityRef" + }, + { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + } + ] + } + }, + "interaction": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "interaction" + }, + "operation": { + "$ref": "#/$defs/entityRef" + }, + "contract": { + "$ref": "#/$defs/entityRef" + }, + "binding": { + "$ref": "#/$defs/entityRef" + }, + "channel": { + "$ref": "#/$defs/entityRef" + }, + "interaction_style": { + "$ref": "#/$defs/termOrTerms" + }, + "temporal_semantics": { + "$ref": "#/$defs/termOrTerms" + }, + "execution_boundary": { + "$ref": "#/$defs/termRef" + }, + "participants": { + "$ref": "#/$defs/participantMap" + }, + "facets": { + "$ref": "#/$defs/facets" + }, + "realization_status": { + "$ref": "#/$defs/termRef", + "description": "Optional interaction realization/lifecycle status such as proposed, authorized, executed, or rejected." + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "flowStep": { + "type": "object", + "properties": { + "sequence": { + "type": "integer", + "minimum": 1 + }, + "id": { + "$ref": "#/$defs/identifier" + }, + "operation": { + "$ref": "#/$defs/entityRef" + }, + "interaction": { + "$ref": "#/$defs/entityRef" + }, + "binding": { + "$ref": "#/$defs/entityRef" + }, + "from": { + "$ref": "#/$defs/entityRef" + }, + "via": { + "$ref": "#/$defs/entityRef" + }, + "to": { + "$ref": "#/$defs/entityRef" + }, + "participants": { + "$ref": "#/$defs/participantMap" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "sequence" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "interactionFlow": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "interaction-flow" + }, + "name": { + "type": "string" + }, + "flow_type": { + "$ref": "#/$defs/termRef" + }, + "participants": { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + }, + "steps": { + "type": "array", + "minItems": 1, + "items": { + "$ref": "#/$defs/flowStep" + } + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "artifact": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "artifact" + }, + "name": { + "type": "string" + }, + "artifact_type": { + "$ref": "#/$defs/termRef" + }, + "describes": { + "oneOf": [ + { + "$ref": "#/$defs/entityRef" + }, + { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + } + ] + }, + "implements": { + "oneOf": [ + { + "$ref": "#/$defs/entityRef" + }, + { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + } + ] + }, + "locator": { + "type": "string" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "zone": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "zone" + }, + "name": { + "type": "string" + }, + "zone_type": { + "$ref": "#/$defs/termRef" + }, + "members": { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + }, + "parent": { + "$ref": "#/$defs/entityRef" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "securityProfile": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "applies_to": { + "$ref": "#/$defs/entityRef" + }, + "transport_security": { + "$ref": "#/$defs/termRef" + }, + "authentication": { + "$ref": "#/$defs/termRef" + }, + "credential_artifacts": { + "type": "array", + "items": { + "$ref": "#/$defs/termRef" + } + }, + "identity_propagation": { + "$ref": "#/$defs/termRef" + }, + "authorization": { + "$ref": "#/$defs/termRef" + }, + "policy_enforcement": { + "$ref": "#/$defs/termRef" + }, + "tenant_context": { + "$ref": "#/$defs/termRef" + }, + "trust_boundary_crossing": { + "oneOf": [ + { + "type": "boolean" + }, + { + "$ref": "#/$defs/termRef" + } + ] + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id", + "applies_to" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "evidenceSource": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "object", + "properties": { + "type": { + "type": "string" + }, + "ref": { + "type": "string" + }, + "locator": { + "type": "string" + }, + "metadata": { + "type": "object", + "additionalProperties": true + } + }, + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + } + ] + }, + "evidenceRecord": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "mode": { + "$ref": "#/$defs/termRef" + }, + "source": { + "$ref": "#/$defs/evidenceSource" + }, + "observer": { + "type": "string" + }, + "observed_at": { + "type": "string", + "format": "date-time" + }, + "confidence": { + "type": "number", + "minimum": 0.0, + "maximum": 1.0 + }, + "stance": { + "enum": [ + "supports", + "challenges", + "neutral" + ] + }, + "notes": { + "type": "string" + } + }, + "required": [ + "mode", + "source" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "evidence": { + "oneOf": [ + { + "$ref": "#/$defs/evidenceRecord" + }, + { + "type": "array", + "minItems": 1, + "items": { + "oneOf": [ + { + "$ref": "#/$defs/evidenceRecord" + }, + { + "$ref": "#/$defs/entityRef" + } + ] + } + } + ] + }, + "assertion": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "subject": { + "$ref": "#/$defs/entityRef" + }, + "predicate": { + "$ref": "#/$defs/termRef" + }, + "value": {}, + "valid_time": { + "type": "object", + "properties": { + "observed_at": { + "type": "string", + "format": "date-time" + }, + "valid_from": { + "type": "string", + "format": "date-time" + }, + "valid_until": { + "type": "string", + "format": "date-time" + } + }, + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "evidence": { + "$ref": "#/$defs/evidence" + }, + "facets": { + "$ref": "#/$defs/facets" + }, + "assertion_kind": { + "enum": [ + "property", + "relation" + ] + }, + "polarity": { + "enum": [ + "asserted", + "absent", + "not-applicable", + "unknown" + ], + "description": "Epistemic polarity. Missing information in the graph remains open-world unknown; explicit unknown is used only when an observer/source states uncertainty." + }, + "object_ref": { + "$ref": "#/$defs/entityRef", + "description": "Object of a relation assertion." + }, + "supersedes": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/entityRef" + } + }, + "conflicts_with": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/entityRef" + } + } + }, + "required": [ + "id", + "assertion_kind", + "subject", + "predicate", + "polarity", + "evidence" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false, + "description": "Evidence-backed property or relationship assertion. Relation assertions use object_ref; property assertions use value when polarity is asserted.", + "allOf": [ + { + "if": { + "properties": { + "assertion_kind": { + "const": "property" + }, + "polarity": { + "const": "asserted" + } + }, + "required": [ + "assertion_kind", + "polarity" + ] + }, + "then": { + "required": [ + "value" + ] + } + }, + { + "if": { + "properties": { + "assertion_kind": { + "const": "relation" + }, + "polarity": { + "const": "asserted" + } + }, + "required": [ + "assertion_kind", + "polarity" + ] + }, + "then": { + "required": [ + "object_ref" + ] + } + }, + { + "if": { + "properties": { + "assertion_kind": { + "const": "relation" + } + }, + "required": [ + "assertion_kind" + ] + }, + "then": { + "not": { + "required": [ + "value" + ] + } + } + } + ] + }, + "specimenTests": { + "type": "object", + "properties": { + "stresses": { + "type": "array", + "items": { + "type": "string" + } + }, + "notes": { + "type": "array", + "items": { + "type": "string" + } + }, + "expected_properties": { + "type": "array", + "minItems": 1, + "items": { + "$ref": "#/$defs/semanticCheck" + } + } + }, + "required": [ + "expected_properties" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "contractParticipation": { + "type": "object", + "description": "A port participation in a specific contract. offers/requires describes architectural contract participation, not message-flow direction.", + "properties": { + "contract": { + "$ref": "#/$defs/entityRef" + }, + "mode": { + "enum": [ + "offers", + "requires" + ] + }, + "roles": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/termRef" + } + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "contract", + "mode" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "resourceSelector": { + "type": "object", + "properties": { + "kind": { + "$ref": "#/$defs/termRef" + }, + "value": {}, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "kind", + "value" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false, + "description": "Selector identifying an InformationResource within a provider, namespace, collection, or logical address space. It is deliberately distinct from an Endpoint, which locates a Binding." + }, + "informationResource": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "information-resource" + }, + "owner": { + "$ref": "#/$defs/entityRef" + }, + "name": { + "type": "string" + }, + "resource_kind": { + "$ref": "#/$defs/termRef" + }, + "resource_scope": { + "$ref": "#/$defs/termRef" + }, + "selectors": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/resourceSelector" + } + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id", + "kind" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false, + "description": "An identifiable information-bearing locus, state, object, collection, or logical selection that exists independently of any one Interaction and can be targeted, read, mutated, appended to, observed, or projected. May be provider-native or a modeling-level logical selection." + }, + "informationShape": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "information-shape" + }, + "owner": { + "$ref": "#/$defs/entityRef" + }, + "name": { + "type": "string" + }, + "shape_kind": { + "$ref": "#/$defs/termRef" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id", + "kind", + "shape_kind" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false, + "description": "An identifiable semantic/structural type or constraint set describing the admissible form of information, independent of any particular InformationResource instance, description Artifact, or concrete representation/encoding." + }, + "semanticCheck": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "enum": [ + "all-assertions-have-evidence", + "no-deprecated-terms", + "no-legacy-representations", + "entity-exists", + "relation-exists", + "relation-absent", + "field-equals", + "field-absent", + "field-contains" + ] + }, + "ref": { + "$ref": "#/$defs/entityRef" + }, + "entity_kind": { + "type": "string" + }, + "subject": { + "$ref": "#/$defs/entityRef" + }, + "predicate": { + "$ref": "#/$defs/termRef" + }, + "object_ref": { + "$ref": "#/$defs/entityRef" + }, + "facets": { + "type": "object", + "additionalProperties": true + }, + "field": { + "type": "string" + }, + "value": {} + }, + "required": [ + "id", + "kind" + ], + "additionalProperties": false + } + } +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-DeclaredObservedResult-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-DeclaredObservedResult-v0.2.schema.json new file mode 100644 index 0000000..db34cdb --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-DeclaredObservedResult-v0.2.schema.json @@ -0,0 +1,4 @@ +{ + "$schema":"https://json-schema.org/draft/2020-12/schema","$id":"urn:fiam:schema:lens-result:declared-observed:0.2","type":"object","required":["lens","model","summary","findings","coverage_findings","reconciliation_candidates"], + "properties":{"lens":{"const":"fiam.lens.declared-vs-observed"},"lens_version":{"type":["string","null"]},"model":{"type":["string","null"]},"summary":{"type":"object"},"findings":{"type":"array"},"coverage_findings":{"type":"array"},"reconciliation_candidates":{"type":"array"}},"additionalProperties":false +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-EvidenceHealthResult-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-EvidenceHealthResult-v0.2.schema.json new file mode 100644 index 0000000..8e5f1e6 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-EvidenceHealthResult-v0.2.schema.json @@ -0,0 +1,42 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:fiam-evidencehealthresult-v0.2", + "type": "object", + "required": [ + "lens_id", + "evaluated_at", + "policy", + "summary", + "conflicts", + "challenged", + "stale_runtime_only", + "low_support" + ], + "properties": { + "lens_id": { + "const": "fiam.lens.evidence-health" + }, + "evaluated_at": { + "type": "string" + }, + "policy": { + "type": "object" + }, + "summary": { + "type": "object" + }, + "conflicts": { + "type": "array" + }, + "challenged": { + "type": "array" + }, + "stale_runtime_only": { + "type": "array" + }, + "low_support": { + "type": "array" + } + }, + "additionalProperties": true +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-EvidenceScoringPolicy-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-EvidenceScoringPolicy-v0.2.schema.json new file mode 100644 index 0000000..56d3ee2 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-EvidenceScoringPolicy-v0.2.schema.json @@ -0,0 +1,22 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:evidence-scoring-policy:0.2", + "title": "FIAM Evidence Scoring Policy v0.2", + "type": "object", + "required": ["policy_version","id","combination","mode_weights","source_type_weights","default_source_type_weight","default_confidence","freshness","interpretation"], + "properties": { + "policy_version":{"type":"string"}, + "id":{"type":"string","pattern":"^fiam\\.policy\\."}, + "intent":{"type":"string"}, + "combination":{"const":"independent-noisy-or"}, + "independence_key":{"type":"array","items":{"type":"string"},"minItems":1,"uniqueItems":true}, + "mode_weights":{"type":"object","additionalProperties":{"type":"number","minimum":0,"maximum":1}}, + "source_type_weights":{"type":"object","additionalProperties":{"type":"number","minimum":0,"maximum":1}}, + "default_source_type_weight":{"type":"number","minimum":0,"maximum":1}, + "default_confidence":{"type":"number","minimum":0,"maximum":1}, + "freshness":{"type":"object","additionalProperties":{"type":"object","required":["half_life_days","floor"],"properties":{"half_life_days":{"type":["number","null"],"exclusiveMinimum":0},"floor":{"type":"number","minimum":0,"maximum":1}},"additionalProperties":false}}, + "interpretation":{"type":"object","required":["strong","moderate","weak"],"properties":{"strong":{"type":"number","minimum":0,"maximum":1},"moderate":{"type":"number","minimum":0,"maximum":1},"weak":{"type":"number","minimum":0,"maximum":1}},"additionalProperties":false}, + "notes":{"type":"array","items":{"type":"string"}} + }, + "additionalProperties": false +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-Lens-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-Lens-v0.2.schema.json new file mode 100644 index 0000000..8fd8275 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-Lens-v0.2.schema.json @@ -0,0 +1,31 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:lens:0.2", + "title": "FIAM Lens Definition v0.2", + "type": "object", + "required": ["id", "title", "pair_relation", "comparisons"], + "properties": { + "id": {"type": "string", "pattern": "^fiam\\.lens\\."}, + "version": {"type": "string"}, + "title": {"type": "string", "minLength": 1}, + "description": {"type": "string"}, + "pair_relation": {"type": "string", "pattern": "^fiam\\.relation\\."}, + "declared_evidence_modes": {"type": "array", "items": {"type": "string"}, "uniqueItems": true}, + "observed_evidence_modes": {"type": "array", "items": {"type": "string"}, "uniqueItems": true}, + "comparisons": { + "type": "array", "minItems": 1, + "items": { + "type": "object", "required": ["predicate", "strategy"], + "properties": { + "predicate": {"type": "string", "pattern": "^fiam\\.property\\."}, + "subject_kinds": {"type": "array", "items": {"type": "string"}, "uniqueItems": true}, + "strategy": {"enum": ["exact", "canon-hierarchy"]}, + "include_missing": {"type": "boolean"} + }, + "additionalProperties": false + } + }, + "owner_resolution": {"enum": ["provider-port-owner", "none"]} + }, + "additionalProperties": false +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-OperationCoverageResult-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-OperationCoverageResult-v0.2.schema.json new file mode 100644 index 0000000..66955ca --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-OperationCoverageResult-v0.2.schema.json @@ -0,0 +1,30 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:fiam-operationcoverageresult-v0.2", + "type": "object", + "required": [ + "lens_id", + "population_id", + "window", + "summary", + "operations" + ], + "properties": { + "lens_id": { + "const": "fiam.lens.operation-coverage" + }, + "population_id": { + "type": "string" + }, + "window": { + "type": "object" + }, + "summary": { + "type": "object" + }, + "operations": { + "type": "array" + } + }, + "additionalProperties": true +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-RuntimeCatalogExtension-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-RuntimeCatalogExtension-v0.2.schema.json new file mode 100644 index 0000000..31e7e2b --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-RuntimeCatalogExtension-v0.2.schema.json @@ -0,0 +1,55 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:runtime-catalog-extension:0.2", + "title": "FIAM Runtime Catalog Extensions v0.2", + "type": "object", + "required": ["org.fiam.catalog", "org.fiam.runtime_aggregates", "org.fiam.runtime_topology_observations", "org.fiam.runtime_unresolved", "org.fiam.reconciliation_candidates"], + "properties": { + "org.fiam.catalog": { + "type": "object", + "required": ["version", "processed_batches", "runtime_policy", "occurrence_retention", "sample_size"], + "properties": { + "version": {"type": "string"}, + "processed_batches": {"type": "array", "uniqueItems": true, "items": {"type": "string", "pattern": "^[0-9a-f]{64}$"}}, + "declared_entity_ids": {"type": "array", "uniqueItems": true, "items": {"type": "string"}}, + "last_ingest_at": {"type": ["string", "null"]}, + "runtime_policy": {"const": "aggregate-by-architectural-tuple"}, + "occurrence_retention": {"enum": ["none", "sample", "all"]}, + "sample_size": {"type": "integer", "minimum": 0} + }, + "additionalProperties": true + }, + "org.fiam.runtime_aggregates": { + "type": "array", + "items": { + "type": "object", + "required": ["id", "domain", "role", "operation", "binding", "local_node", "count", "error_count", "first_seen", "last_seen", "sample_spans"], + "properties": { + "id": {"type": "string"}, "domain": {"enum": ["http", "rpc", "messaging", "database"]}, "role": {"type": "string"}, + "operation": {"type": "string"}, "binding": {"type": "string"}, "local_node": {"type": "string"}, "remote_node": {"type": ["string", "null"]}, + "channel": {"type": ["string", "null"]}, "resource": {"type": ["string", "null"]}, "count": {"type": "integer", "minimum": 0}, "error_count": {"type": "integer", "minimum": 0}, + "first_seen": {"type": ["string", "null"]}, "last_seen": {"type": ["string", "null"]}, "sample_spans": {"type": "array", "items": {"type": "string"}} + }, + "additionalProperties": true + } + }, + "org.fiam.runtime_topology_observations": { + "type": "array", + "items": { + "type": "object", + "required": ["id", "domain", "kind", "count"], + "properties": {"id": {"type": "string"}, "domain": {"enum": ["rpc", "messaging", "database"]}, "kind": {"type": "string"}, "count": {"type": "integer", "minimum": 0}, "first_seen": {"type": ["string", "null"]}, "last_seen": {"type": ["string", "null"]}}, + "additionalProperties": true + } + }, + "org.fiam.runtime_unresolved": { + "type": "array", + "items": {"type": "object", "required": ["id", "domain", "reason"], "properties": {"id": {"type": "string"}, "domain": {"enum": ["http", "rpc", "messaging", "database"]}, "reason": {"type": "string"}}, "additionalProperties": true} + }, + "org.fiam.reconciliation_candidates": { + "type": "array", + "items": {"type": "object", "required": ["observed_ref", "entity_kind", "status", "candidates"], "properties": {"observed_ref": {"type": "string"}, "entity_kind": {"type": "string"}, "status": {"enum": ["matched", "ambiguous", "near-match", "unmatched"]}, "candidates": {"type": "array", "items": {"type": "object", "required": ["declared_ref", "score", "signals"], "properties": {"declared_ref": {"type": "string"}, "score": {"type": "number", "minimum": 0, "maximum": 1}, "signals": {"type": "array", "items": {"type": "string"}}, "binding_ref": {"type": ["string", "null"]}, "endpoint_ref": {"type": ["string", "null"]}, "node_ref": {"type": ["string", "null"]}}, "additionalProperties": false}}}, "additionalProperties": false} + } + }, + "additionalProperties": true +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-RuntimeTopologyLens-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-RuntimeTopologyLens-v0.2.schema.json new file mode 100644 index 0000000..5f350eb --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-RuntimeTopologyLens-v0.2.schema.json @@ -0,0 +1,69 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:lens:runtime-topology:0.2", + "title": "FIAM Runtime Topology Lens Definition v0.2", + "type": "object", + "required": [ + "id", + "title", + "domains" + ], + "properties": { + "id": { + "const": "fiam.lens.runtime-topology" + }, + "version": { + "type": "string" + }, + "title": { + "type": "string", + "minLength": 1 + }, + "description": { + "type": "string" + }, + "evidence_modes": { + "type": "array", + "items": { + "type": "string" + }, + "uniqueItems": true + }, + "domains": { + "type": "array", + "minItems": 1, + "uniqueItems": true, + "items": { + "enum": [ + "rpc", + "messaging", + "database" + ] + } + }, + "preserve_mediation": { + "type": "boolean" + }, + "rpc_correlation": { + "enum": [ + "trace-parent", + "trace-parent-when-available" + ] + }, + "messaging_correlation": { + "enum": [ + "interaction-flow", + "span-link-when-available" + ] + }, + "database_target_relations": { + "type": "array", + "items": { + "type": "string", + "pattern": "^fiam\\.relation\\." + }, + "uniqueItems": true + } + }, + "additionalProperties": false +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-RuntimeTopologyResult-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-RuntimeTopologyResult-v0.2.schema.json new file mode 100644 index 0000000..d00a586 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-RuntimeTopologyResult-v0.2.schema.json @@ -0,0 +1,4 @@ +{ + "$schema":"https://json-schema.org/draft/2020-12/schema","$id":"urn:fiam:schema:lens-result:runtime-topology:0.2","type":"object","required":["lens","model","summary","edges","unresolved","working_set"], + "properties":{"lens":{"const":"fiam.lens.runtime-topology"},"lens_version":{"type":["string","null"]},"model":{"type":["string","null"]},"summary":{"type":"object","required":["edges","domains","architectural_nodes","unresolved","working_set_attachments"],"properties":{"edges":{"type":"integer","minimum":0},"domains":{"type":"object","additionalProperties":{"type":"integer","minimum":0}},"architectural_nodes":{"type":"integer","minimum":0},"unresolved":{"type":"integer","minimum":0},"working_set_attachments":{"type":"integer","minimum":0}},"additionalProperties":false},"edges":{"type":"array","items":{"type":"object","required":["id","domain","kind","count"],"properties":{"id":{"type":"string"},"domain":{"enum":["rpc","messaging","database"]},"kind":{"type":"string"},"count":{"type":"integer","minimum":0},"first_seen":{"type":["string","null"]},"last_seen":{"type":["string","null"]},"correlation":{"type":["string","null"]},"from":{"type":["string","null"]},"to":{"type":["string","null"]},"observed_from":{"type":["string","null"]},"observed_to":{"type":["string","null"]},"via_channel":{"type":["string","null"]},"observed_via_channel":{"type":["string","null"]},"to_resource":{"type":["string","null"]},"observed_to_resource":{"type":["string","null"]},"binding":{"type":["string","null"]},"observed_binding":{"type":["string","null"]},"operation":{"type":["string","null"]},"observed_operation":{"type":["string","null"]},"via_gateway":{"type":"boolean"},"gateway":{"type":["string","null"]},"observed_gateway":{"type":["string","null"]},"intended_target":{"type":["string","null"]}},"additionalProperties":false}},"unresolved":{"type":"array"},"working_set":{"type":"object"}},"additionalProperties":false +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-SecurityCoverageLens-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-SecurityCoverageLens-v0.2.schema.json new file mode 100644 index 0000000..10f68c0 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-SecurityCoverageLens-v0.2.schema.json @@ -0,0 +1,35 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:lens:security-coverage:0.2", + "title": "FIAM Security Coverage Lens Definition v0.2", + "type": "object", + "required": [ + "id", + "version", + "title", + "description", + "source", + "runtime_absence_semantics" + ], + "properties": { + "id": { + "const": "fiam.lens.security-coverage" + }, + "version": { + "type": "string" + }, + "title": { + "type": "string" + }, + "description": { + "type": "string" + }, + "source": { + "const": "declared-security-profiles" + }, + "runtime_absence_semantics": { + "const": "unknown" + } + }, + "additionalProperties": false +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-SecurityCoverageResult-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-SecurityCoverageResult-v0.2.schema.json new file mode 100644 index 0000000..c25b2b7 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-SecurityCoverageResult-v0.2.schema.json @@ -0,0 +1,4 @@ +{ + "$schema":"https://json-schema.org/draft/2020-12/schema","$id":"urn:fiam:schema:lens-result:security-coverage:0.2","type":"object","required":["lens","model","summary","operations","note"], + "properties":{"lens":{"const":"fiam.lens.security-coverage"},"model":{"type":["string","null"]},"summary":{"type":"object","additionalProperties":{"type":"integer","minimum":0}},"operations":{"type":"array","items":{"type":"object","required":["operation_ref","classification","alternatives","runtime_observability"],"properties":{"operation_ref":{"type":"string"},"contract_ref":{"type":["string","null"]},"classification":{"enum":["explicitly-unprotected","anonymous-access-allowed","operation-specific","inherited-contract-security","no-declared-security"]},"alternatives":{"type":"array"},"runtime_observability":{"type":"string"}},"additionalProperties":false}},"note":{"type":"string"}},"additionalProperties":false +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-SecurityEvidenceCoverageResult-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-SecurityEvidenceCoverageResult-v0.2.schema.json new file mode 100644 index 0000000..a0c752c --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-SecurityEvidenceCoverageResult-v0.2.schema.json @@ -0,0 +1,30 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:fiam-securityevidencecoverageresult-v0.2", + "type": "object", + "required": [ + "lens_id", + "population_id", + "window", + "summary", + "profiles" + ], + "properties": { + "lens_id": { + "const": "fiam.lens.security-evidence-coverage" + }, + "population_id": { + "type": "string" + }, + "window": { + "type": "object" + }, + "summary": { + "type": "object" + }, + "profiles": { + "type": "array" + } + }, + "additionalProperties": true +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-SnapshotAuthorityPolicy-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-SnapshotAuthorityPolicy-v0.2.schema.json new file mode 100644 index 0000000..45b9c3a --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-SnapshotAuthorityPolicy-v0.2.schema.json @@ -0,0 +1,131 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:snapshot-authority-policy:0.2", + "title": "FIAM Snapshot Authority Policy v0.2", + "type": "object", + "required": [ + "id", + "version", + "sources" + ], + "properties": { + "id": { + "type": "string" + }, + "version": { + "const": "0.2" + }, + "status": { + "type": "string" + }, + "principles": { + "type": "array", + "items": { + "type": "string" + } + }, + "defaults": { + "type": "object", + "properties": { + "grace_hours": { + "type": "number", + "minimum": 0 + }, + "absence_snapshots": { + "type": "integer", + "minimum": 1 + } + }, + "additionalProperties": false + }, + "sources": { + "type": "object", + "minProperties": 1, + "additionalProperties": { + "type": "object", + "required": [ + "authoritative", + "observation_scope", + "population_id", + "domains" + ], + "properties": { + "authoritative": { + "type": "boolean" + }, + "observation_scope": { + "type": "string", + "minLength": 1 + }, + "population_id": { + "type": "string", + "minLength": 1 + }, + "population": { + "type": "object", + "additionalProperties": { + "type": [ + "string", + "number", + "boolean", + "null" + ] + } + }, + "domains": { + "type": "array", + "minItems": 1, + "uniqueItems": true, + "items": { + "enum": [ + "http", + "rpc", + "messaging", + "database" + ] + } + }, + "grace_hours": { + "type": "number", + "minimum": 0 + }, + "absence_snapshots": { + "type": "integer", + "minimum": 1 + }, + "layer": { + "type": [ + "integer", + "null" + ] + } + }, + "additionalProperties": false + } + }, + "layered_scopes": { + "type": "array", + "items": { + "type": "object", + "required": [ + "observation_scope", + "precedence" + ], + "properties": { + "observation_scope": { + "type": "string" + }, + "precedence": { + "type": "array", + "minItems": 2, + "items": { + "type": "string" + } + } + }, + "additionalProperties": false + } + } + }, + "additionalProperties": false +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-Specimen-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-Specimen-v0.2.schema.json new file mode 100644 index 0000000..4956b55 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-Specimen-v0.2.schema.json @@ -0,0 +1,1441 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:specimen:0.2", + "title": "FIAM Specimen v0.2 Schema", + "description": "Provisional FIAM v0.2 Core baseline. Stabilizes v0.1.1 graph semantics and promotes InformationResource and InformationShape after semantic regression.", + "type": "object", + "required": [ + "fiam_version", + "instance" + ], + "properties": { + "fiam_version": { + "const": "0.2" + }, + "instance": { + "allOf": [ + { + "$ref": "#/$defs/instanceDescriptor" + }, + { + "properties": { + "kind": { + "const": "specimen" + } + } + } + ] + }, + "participants": { + "type": "array", + "items": { + "$ref": "#/$defs/participant" + } + }, + "nodes": { + "type": "array", + "items": { + "$ref": "#/$defs/systemNode" + } + }, + "ports": { + "type": "array", + "items": { + "$ref": "#/$defs/port" + } + }, + "contracts": { + "type": "array", + "items": { + "$ref": "#/$defs/interfaceContract" + } + }, + "endpoints": { + "type": "array", + "items": { + "$ref": "#/$defs/endpoint" + } + }, + "bindings": { + "type": "array", + "items": { + "$ref": "#/$defs/binding" + } + }, + "channels": { + "type": "array", + "items": { + "$ref": "#/$defs/channel" + } + }, + "interactions": { + "type": "array", + "items": { + "$ref": "#/$defs/interaction" + } + }, + "interaction_flows": { + "type": "array", + "items": { + "$ref": "#/$defs/interactionFlow" + } + }, + "artifacts": { + "type": "array", + "items": { + "$ref": "#/$defs/artifact" + } + }, + "zones": { + "type": "array", + "items": { + "$ref": "#/$defs/zone" + } + }, + "security": { + "type": "array", + "items": { + "$ref": "#/$defs/securityProfile" + } + }, + "assertions": { + "type": "array", + "items": { + "$ref": "#/$defs/assertion" + } + }, + "tests": { + "$ref": "#/$defs/specimenTests" + }, + "extensions": { + "type": "object", + "additionalProperties": true + }, + "information_resources": { + "type": "array", + "items": { + "$ref": "#/$defs/informationResource" + } + }, + "information_shapes": { + "type": "array", + "items": { + "$ref": "#/$defs/informationShape" + } + } + }, + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false, + "$defs": { + "identifier": { + "type": "string", + "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]*$" + }, + "entityRef": { + "$ref": "#/$defs/identifier" + }, + "termRef": { + "type": "string", + "pattern": "^[A-Za-z][A-Za-z0-9_-]*(?:\\.[A-Za-z0-9_-]+)+$", + "description": "Reference to a FIAM Canon term or local namespaced extension term." + }, + "termOrTerms": { + "oneOf": [ + { + "$ref": "#/$defs/termRef" + }, + { + "type": "array", + "minItems": 1, + "uniqueItems": true, + "items": { + "$ref": "#/$defs/termRef" + } + } + ] + }, + "scalar": { + "type": [ + "string", + "number", + "integer", + "boolean", + "null" + ] + }, + "facetValue": { + "oneOf": [ + { + "$ref": "#/$defs/scalar" + }, + { + "type": "array", + "items": { + "$ref": "#/$defs/scalar" + } + }, + { + "type": "object", + "additionalProperties": true + } + ] + }, + "facets": { + "type": "object", + "additionalProperties": { + "$ref": "#/$defs/facetValue" + } + }, + "instanceDescriptor": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "type": "string" + }, + "title": { + "type": "string" + }, + "status": { + "enum": [ + "candidate", + "provisional", + "canonical", + "deprecated" + ] + }, + "intent": { + "type": "string" + }, + "description": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id", + "kind" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "participant": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "participant" + }, + "name": { + "type": "string" + }, + "participant_type": { + "$ref": "#/$defs/termRef" + }, + "represented_by": { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "systemNode": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "system-node" + }, + "name": { + "type": "string" + }, + "node_type": { + "$ref": "#/$defs/termRef" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "port": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "port" + }, + "owner": { + "$ref": "#/$defs/entityRef" + }, + "direction": { + "enum": [ + "offers", + "requires", + "bidirectional", + "unspecified" + ], + "deprecated": true, + "description": "Deprecated in v0.1.1. offers/requires are contract participation modes, not directionality. Use participations." + }, + "roles": { + "type": "array", + "minItems": 1, + "uniqueItems": true, + "items": { + "$ref": "#/$defs/termRef" + }, + "deprecated": true, + "description": "Deprecated as a port-global role list. Put contextual roles on participations where possible." + }, + "contracts": { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + }, + "deprecated": true, + "description": "Deprecated as an unqualified contract list. Use participations." + }, + "facets": { + "$ref": "#/$defs/facets" + }, + "participations": { + "type": "array", + "minItems": 1, + "items": { + "$ref": "#/$defs/contractParticipation" + }, + "description": "Contract-specific offered/required participations. Preferred over v0.1 direction/contracts/roles fields." + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "operation": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "operation" + }, + "name": { + "type": "string" + }, + "description": { + "type": "string" + }, + "interaction_style": { + "$ref": "#/$defs/termOrTerms" + }, + "temporal_semantics": { + "$ref": "#/$defs/termOrTerms" + }, + "effect": { + "$ref": "#/$defs/termOrTerms" + }, + "purpose": { + "type": "array", + "items": { + "$ref": "#/$defs/termRef" + } + }, + "representations": { + "type": "array", + "items": { + "$ref": "#/$defs/termRef" + }, + "deprecated": true, + "description": "Deprecated in FIAM v0.2. Representation belongs to a Binding/Interaction or, preferably, the relevant shape-participation relation assertion." + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "interfaceContract": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "interface-contract" + }, + "name": { + "type": "string" + }, + "description": { + "type": "string" + }, + "family_labels": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/termRef" + }, + "description": "Optional denormalized cache of Lens-derived family labels. Normative derived provenance should be retained as inferred assertions (for example with fiam.property.family-label); family labels are not primitive interface types." + }, + "purpose": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/termRef" + } + }, + "contract_forms": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/termRef" + } + }, + "representations": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/termRef" + }, + "deprecated": true, + "description": "Deprecated in FIAM v0.2. Representation belongs to a Binding/Interaction or, preferably, the relevant shape-participation relation assertion." + }, + "operations": { + "type": "array", + "items": { + "$ref": "#/$defs/operation" + } + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "endpoint": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "endpoint" + }, + "binding": { + "$ref": "#/$defs/entityRef", + "deprecated": true, + "description": "Deprecated v0.1 ownership shortcut. v0.1.1 Bindings reference zero or more Endpoints; an Endpoint may be reused by multiple Bindings." + }, + "address": { + "type": "string" + }, + "address_scheme": { + "$ref": "#/$defs/termRef" + }, + "name": { + "type": "string" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "stackItem": { + "type": "object", + "properties": { + "role": { + "$ref": "#/$defs/termRef" + }, + "term": { + "$ref": "#/$defs/termRef" + }, + "version": { + "type": "string" + }, + "profile": { + "type": "string" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "role", + "term" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "addressing": { + "type": "object", + "properties": { + "kind": { + "$ref": "#/$defs/termRef" + }, + "value": {}, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "discovery": { + "type": "object", + "properties": { + "kind": { + "$ref": "#/$defs/termRef" + }, + "source": { + "type": "string" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "binding": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "binding" + }, + "contract": { + "$ref": "#/$defs/entityRef" + }, + "provider_port": { + "$ref": "#/$defs/entityRef" + }, + "consumer_ports": { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + }, + "operations": { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + }, + "binding_profile": { + "$ref": "#/$defs/termRef" + }, + "communication_stack": { + "type": "array", + "items": { + "$ref": "#/$defs/stackItem" + } + }, + "addressing": { + "$ref": "#/$defs/addressing" + }, + "session_model": { + "$ref": "#/$defs/termRef" + }, + "channel": { + "$ref": "#/$defs/entityRef" + }, + "discovery": { + "$ref": "#/$defs/discovery" + }, + "facets": { + "$ref": "#/$defs/facets" + }, + "endpoints": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/entityRef" + }, + "description": "Concrete locators/selectors through which this Binding is available. The same Endpoint may be referenced by multiple Bindings." + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "channel": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "channel" + }, + "owner": { + "$ref": "#/$defs/entityRef" + }, + "channel_type": { + "$ref": "#/$defs/termRef" + }, + "name": { + "type": "string" + }, + "mediation": { + "$ref": "#/$defs/termRef" + }, + "delivery_semantics": { + "$ref": "#/$defs/termRef" + }, + "ordering_scope": { + "$ref": "#/$defs/termRef" + }, + "replay": { + "type": "boolean" + }, + "retention": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "participantMap": { + "type": "object", + "minProperties": 1, + "additionalProperties": { + "oneOf": [ + { + "$ref": "#/$defs/entityRef" + }, + { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + } + ] + } + }, + "interaction": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "interaction" + }, + "operation": { + "$ref": "#/$defs/entityRef" + }, + "contract": { + "$ref": "#/$defs/entityRef" + }, + "binding": { + "$ref": "#/$defs/entityRef" + }, + "channel": { + "$ref": "#/$defs/entityRef" + }, + "interaction_style": { + "$ref": "#/$defs/termOrTerms" + }, + "temporal_semantics": { + "$ref": "#/$defs/termOrTerms" + }, + "execution_boundary": { + "$ref": "#/$defs/termRef" + }, + "participants": { + "$ref": "#/$defs/participantMap" + }, + "facets": { + "$ref": "#/$defs/facets" + }, + "realization_status": { + "$ref": "#/$defs/termRef", + "description": "Optional interaction realization/lifecycle status such as proposed, authorized, executed, or rejected." + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "flowStep": { + "type": "object", + "properties": { + "sequence": { + "type": "integer", + "minimum": 1 + }, + "id": { + "$ref": "#/$defs/identifier" + }, + "operation": { + "$ref": "#/$defs/entityRef" + }, + "interaction": { + "$ref": "#/$defs/entityRef" + }, + "binding": { + "$ref": "#/$defs/entityRef" + }, + "from": { + "$ref": "#/$defs/entityRef" + }, + "via": { + "$ref": "#/$defs/entityRef" + }, + "to": { + "$ref": "#/$defs/entityRef" + }, + "participants": { + "$ref": "#/$defs/participantMap" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "sequence" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "interactionFlow": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "interaction-flow" + }, + "name": { + "type": "string" + }, + "flow_type": { + "$ref": "#/$defs/termRef" + }, + "participants": { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + }, + "steps": { + "type": "array", + "minItems": 1, + "items": { + "$ref": "#/$defs/flowStep" + } + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "artifact": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "artifact" + }, + "name": { + "type": "string" + }, + "artifact_type": { + "$ref": "#/$defs/termRef" + }, + "describes": { + "oneOf": [ + { + "$ref": "#/$defs/entityRef" + }, + { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + } + ] + }, + "implements": { + "oneOf": [ + { + "$ref": "#/$defs/entityRef" + }, + { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + } + ] + }, + "locator": { + "type": "string" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "zone": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "zone" + }, + "name": { + "type": "string" + }, + "zone_type": { + "$ref": "#/$defs/termRef" + }, + "members": { + "type": "array", + "items": { + "$ref": "#/$defs/entityRef" + } + }, + "parent": { + "$ref": "#/$defs/entityRef" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "securityProfile": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "applies_to": { + "$ref": "#/$defs/entityRef" + }, + "transport_security": { + "$ref": "#/$defs/termRef" + }, + "authentication": { + "$ref": "#/$defs/termRef" + }, + "credential_artifacts": { + "type": "array", + "items": { + "$ref": "#/$defs/termRef" + } + }, + "identity_propagation": { + "$ref": "#/$defs/termRef" + }, + "authorization": { + "$ref": "#/$defs/termRef" + }, + "policy_enforcement": { + "$ref": "#/$defs/termRef" + }, + "tenant_context": { + "$ref": "#/$defs/termRef" + }, + "trust_boundary_crossing": { + "oneOf": [ + { + "type": "boolean" + }, + { + "$ref": "#/$defs/termRef" + } + ] + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id", + "applies_to" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "evidenceSource": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "object", + "properties": { + "type": { + "type": "string" + }, + "ref": { + "type": "string" + }, + "locator": { + "type": "string" + }, + "metadata": { + "type": "object", + "additionalProperties": true + } + }, + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + } + ] + }, + "evidenceRecord": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "mode": { + "$ref": "#/$defs/termRef" + }, + "source": { + "$ref": "#/$defs/evidenceSource" + }, + "observer": { + "type": "string" + }, + "observed_at": { + "type": "string", + "format": "date-time" + }, + "confidence": { + "type": "number", + "minimum": 0.0, + "maximum": 1.0 + }, + "stance": { + "enum": [ + "supports", + "challenges", + "neutral" + ] + }, + "notes": { + "type": "string" + } + }, + "required": [ + "mode", + "source" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "evidence": { + "oneOf": [ + { + "$ref": "#/$defs/evidenceRecord" + }, + { + "type": "array", + "minItems": 1, + "items": { + "oneOf": [ + { + "$ref": "#/$defs/evidenceRecord" + }, + { + "$ref": "#/$defs/entityRef" + } + ] + } + } + ] + }, + "assertion": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "subject": { + "$ref": "#/$defs/entityRef" + }, + "predicate": { + "$ref": "#/$defs/termRef" + }, + "value": {}, + "valid_time": { + "type": "object", + "properties": { + "observed_at": { + "type": "string", + "format": "date-time" + }, + "valid_from": { + "type": "string", + "format": "date-time" + }, + "valid_until": { + "type": "string", + "format": "date-time" + } + }, + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "evidence": { + "$ref": "#/$defs/evidence" + }, + "facets": { + "$ref": "#/$defs/facets" + }, + "assertion_kind": { + "enum": [ + "property", + "relation" + ] + }, + "polarity": { + "enum": [ + "asserted", + "absent", + "not-applicable", + "unknown" + ], + "description": "Epistemic polarity. Missing information in the graph remains open-world unknown; explicit unknown is used only when an observer/source states uncertainty." + }, + "object_ref": { + "$ref": "#/$defs/entityRef", + "description": "Object of a relation assertion." + }, + "supersedes": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/entityRef" + } + }, + "conflicts_with": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/entityRef" + } + } + }, + "required": [ + "id", + "assertion_kind", + "subject", + "predicate", + "polarity", + "evidence" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false, + "description": "Evidence-backed property or relationship assertion. Relation assertions use object_ref; property assertions use value when polarity is asserted.", + "allOf": [ + { + "if": { + "properties": { + "assertion_kind": { + "const": "property" + }, + "polarity": { + "const": "asserted" + } + }, + "required": [ + "assertion_kind", + "polarity" + ] + }, + "then": { + "required": [ + "value" + ] + } + }, + { + "if": { + "properties": { + "assertion_kind": { + "const": "relation" + }, + "polarity": { + "const": "asserted" + } + }, + "required": [ + "assertion_kind", + "polarity" + ] + }, + "then": { + "required": [ + "object_ref" + ] + } + }, + { + "if": { + "properties": { + "assertion_kind": { + "const": "relation" + } + }, + "required": [ + "assertion_kind" + ] + }, + "then": { + "not": { + "required": [ + "value" + ] + } + } + } + ] + }, + "specimenTests": { + "type": "object", + "properties": { + "stresses": { + "type": "array", + "items": { + "type": "string" + } + }, + "notes": { + "type": "array", + "items": { + "type": "string" + } + }, + "expected_properties": { + "type": "array", + "minItems": 1, + "items": { + "$ref": "#/$defs/semanticCheck" + } + } + }, + "required": [ + "expected_properties" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "contractParticipation": { + "type": "object", + "description": "A port participation in a specific contract. offers/requires describes architectural contract participation, not message-flow direction.", + "properties": { + "contract": { + "$ref": "#/$defs/entityRef" + }, + "mode": { + "enum": [ + "offers", + "requires" + ] + }, + "roles": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/termRef" + } + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "contract", + "mode" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false + }, + "resourceSelector": { + "type": "object", + "properties": { + "kind": { + "$ref": "#/$defs/termRef" + }, + "value": {}, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "kind", + "value" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false, + "description": "Selector identifying an InformationResource within a provider, namespace, collection, or logical address space. It is deliberately distinct from an Endpoint, which locates a Binding." + }, + "informationResource": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "information-resource" + }, + "owner": { + "$ref": "#/$defs/entityRef" + }, + "name": { + "type": "string" + }, + "resource_kind": { + "$ref": "#/$defs/termRef" + }, + "resource_scope": { + "$ref": "#/$defs/termRef" + }, + "selectors": { + "type": "array", + "uniqueItems": true, + "items": { + "$ref": "#/$defs/resourceSelector" + } + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id", + "kind" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false, + "description": "An identifiable information-bearing locus, state, object, collection, or logical selection that exists independently of any one Interaction and can be targeted, read, mutated, appended to, observed, or projected. May be provider-native or a modeling-level logical selection." + }, + "informationShape": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "const": "information-shape" + }, + "owner": { + "$ref": "#/$defs/entityRef" + }, + "name": { + "type": "string" + }, + "shape_kind": { + "$ref": "#/$defs/termRef" + }, + "facets": { + "$ref": "#/$defs/facets" + } + }, + "required": [ + "id", + "kind", + "shape_kind" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": false, + "description": "An identifiable semantic/structural type or constraint set describing the admissible form of information, independent of any particular InformationResource instance, description Artifact, or concrete representation/encoding." + }, + "semanticCheck": { + "type": "object", + "properties": { + "id": { + "$ref": "#/$defs/identifier" + }, + "kind": { + "enum": [ + "all-assertions-have-evidence", + "no-deprecated-terms", + "no-legacy-representations", + "entity-exists", + "relation-exists", + "relation-absent", + "field-equals", + "field-absent", + "field-contains" + ] + }, + "ref": { + "$ref": "#/$defs/entityRef" + }, + "entity_kind": { + "type": "string" + }, + "subject": { + "$ref": "#/$defs/entityRef" + }, + "predicate": { + "$ref": "#/$defs/termRef" + }, + "object_ref": { + "$ref": "#/$defs/entityRef" + }, + "facets": { + "type": "object", + "additionalProperties": true + }, + "field": { + "type": "string" + }, + "value": {} + }, + "required": [ + "id", + "kind" + ], + "additionalProperties": false + } + } +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-Term-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-Term-v0.2.schema.json new file mode 100644 index 0000000..5bf6ef9 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-Term-v0.2.schema.json @@ -0,0 +1,120 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:fiam:schema:term:0.2", + "title": "FIAM Canon Term v0.2 Schema", + "type": "object", + "properties": { + "id": { + "type": "string", + "pattern": "^fiam\\." + }, + "scheme": { + "type": "string", + "pattern": "^fiam\\.scheme\\." + }, + "preferred_label": { + "type": "string", + "minLength": 1 + }, + "definition": { + "type": "string", + "minLength": 1 + }, + "status": { + "enum": [ + "candidate", + "provisional", + "canonical", + "deprecated" + ] + }, + "introduced_in": { + "type": "string" + }, + "alternative_labels": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + }, + "broader": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + }, + "narrower": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + }, + "related": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + }, + "replaced_by": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + }, + "deprecated_reason": { + "type": "string" + }, + "relation_family": { + "type": "string" + }, + "inverse_of": { + "type": "string" + }, + "symmetric": { + "type": "boolean" + }, + "transitive": { + "type": "boolean" + }, + "domain_kinds": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + }, + "range_kinds": { + "type": "array", + "uniqueItems": true, + "items": { + "type": "string" + } + }, + "sources": { + "type": "array" + }, + "examples": { + "type": "array" + }, + "constraints": { + "type": "array" + } + }, + "required": [ + "id", + "scheme", + "preferred_label", + "definition", + "status", + "introduced_in" + ], + "patternProperties": { + "^(x-|org\\.)": {} + }, + "additionalProperties": true +} diff --git a/history/FIAM_v0.2_Draft6/schemas/FIAM-WorkingSetResult-v0.2.schema.json b/history/FIAM_v0.2_Draft6/schemas/FIAM-WorkingSetResult-v0.2.schema.json new file mode 100644 index 0000000..a1ce89d --- /dev/null +++ b/history/FIAM_v0.2_Draft6/schemas/FIAM-WorkingSetResult-v0.2.schema.json @@ -0,0 +1,4 @@ +{ + "$schema":"https://json-schema.org/draft/2020-12/schema","$id":"urn:fiam:schema:working-set:0.2","type":"object","required":["model","policy","preferred_ref_by_observed","attachments","ambiguous"], + "properties":{"model":{"type":["string","null"]},"policy":{"type":"object"},"preferred_ref_by_observed":{"type":"object","additionalProperties":{"type":"string"}},"attachments":{"type":"array","items":{"type":"object","required":["observed_ref","preferred_ref","confidence","merged"],"properties":{"observed_ref":{"type":"string"},"preferred_ref":{"type":"string"},"confidence":{"type":"number"},"assertion_id":{"type":["string","null"]},"merged":{"const":false}},"additionalProperties":false}},"ambiguous":{"type":"array"}},"additionalProperties":false +} diff --git a/history/FIAM_v0.2_Draft6/specimens/composition/01-kubectl-cli-uses-api.yaml b/history/FIAM_v0.2_Draft6/specimens/composition/01-kubectl-cli-uses-api.yaml new file mode 100644 index 0000000..ee9c51c --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/composition/01-kubectl-cli-uses-api.yaml @@ -0,0 +1,174 @@ +fiam_version: '0.2' +instance: + id: specimen.composition.kubectl-api + kind: specimen + title: kubectl CLI contract uses Kubernetes API contract + status: provisional + intent: Exercise uses relation between distinct CLI and API contracts and a multi-step apply flow. +nodes: +- id: node.kubectl + kind: system-node + name: kubectl + node_type: fiam.node-type.application +- id: node.apiserver + kind: system-node + name: Kubernetes API Server + node_type: fiam.node-type.service +ports: +- id: port.kubectl.cli + owner: node.kubectl + participations: + - contract: contract.kubectl-cli + mode: offers + roles: + - fiam.role.service-provider +- id: port.kubectl.api + owner: node.kubectl + participations: + - contract: contract.k8s-api + mode: requires + roles: + - fiam.role.client +- id: port.apiserver.api + owner: node.apiserver + participations: + - contract: contract.k8s-api + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.kubectl-cli + kind: interface-contract + name: kubectl CLI + operations: + - id: operation.kubectl.apply + name: apply + interaction_style: fiam.interaction-style.command +- id: contract.k8s-api + kind: interface-contract + name: Kubernetes API + operations: + - id: operation.k8s.patch + name: patch + interaction_style: fiam.interaction-style.request-response +bindings: +- id: binding.kubectl.local + contract: contract.kubectl-cli + provider_port: port.kubectl.cli + communication_stack: + - role: fiam.stack-role.ipc-process-carrier + term: fiam.carrier.stdio +- id: binding.k8s.https + contract: contract.k8s-api + provider_port: port.apiserver.api + consumer_ports: + - port.kubectl.api + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls +information_resources: +- id: resource.manifest + kind: information-resource + owner: node.kubectl + name: deployment.yaml + resource_kind: fiam.information-resource.file + resource_scope: fiam.resource-scope.concrete-instance + selectors: + - kind: fiam.resource-selector.filesystem-path + value: ./deployment.yaml +information_shapes: +- id: shape.k8s-manifest + kind: information-shape + name: Kubernetes resource manifest + shape_kind: fiam.information-shape.object +interactions: +- id: interaction.kubectl.apply + kind: interaction + operation: operation.kubectl.apply + binding: binding.kubectl.local + realization_status: fiam.interaction-status.executed +- id: interaction.k8s.patch + kind: interaction + operation: operation.k8s.patch + binding: binding.k8s.https + realization_status: fiam.interaction-status.executed +interaction_flows: +- id: flow.kubectl.apply + kind: interaction-flow + name: kubectl apply flow + flow_type: fiam.flow.orchestration + steps: + - sequence: 1 + interaction: interaction.kubectl.apply + - sequence: 2 + interaction: interaction.k8s.patch +assertions: +- id: assertion.kubectl-uses-api + assertion_kind: relation + subject: contract.kubectl-cli + predicate: fiam.relation.uses + polarity: asserted + object_ref: contract.k8s-api + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.apply-reads-manifest + assertion_kind: relation + subject: interaction.kubectl.apply + predicate: fiam.relation.reads-from + polarity: asserted + object_ref: resource.manifest + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.manifest-conforms + assertion_kind: relation + subject: resource.manifest + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.k8s-manifest + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.patch-accepts + assertion_kind: relation + subject: interaction.k8s.patch + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.k8s-manifest + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.request + representation: fiam.representation.json +tests: + stresses: + - distinct-cli-and-api-contracts + - uses-relation + - workflow-over-file-and-api + notes: + - kubectl is a separate contract that uses the Kubernetes API rather than being another binding of the same contract. + expected_properties: + - id: check.kubectl-uses + kind: relation-exists + subject: contract.kubectl-cli + predicate: fiam.relation.uses + object_ref: contract.k8s-api + - id: check.kubectl-manifest + kind: relation-exists + subject: resource.manifest + predicate: fiam.relation.conforms-to-shape + object_ref: shape.k8s-manifest + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations diff --git a/history/FIAM_v0.2_Draft6/specimens/composition/02-shape-identity-reconciliation.yaml b/history/FIAM_v0.2_Draft6/specimens/composition/02-shape-identity-reconciliation.yaml new file mode 100644 index 0000000..a5d4579 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/composition/02-shape-identity-reconciliation.yaml @@ -0,0 +1,78 @@ +fiam_version: '0.2' +instance: + id: specimen.shape.identity-reconciliation + kind: specimen + title: Shape identity across OpenAPI and source declarations + status: provisional + intent: Exercise candidate alignment versus confirmed shape identity without destructive merge. +nodes: +- id: node.user-service + kind: system-node + name: User service + node_type: fiam.node-type.service +information_shapes: +- id: shape.customer.openapi + kind: information-shape + name: Customer discovered from OpenAPI + shape_kind: fiam.information-shape.object +- id: shape.customer.java + kind: information-shape + name: Customer discovered from Java source + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.openapi + kind: artifact + name: openapi.yaml + artifact_type: fiam.artifact.api-description + describes: shape.customer.openapi +- id: artifact.customer-java + kind: artifact + name: Customer.java + artifact_type: fiam.artifact.source-code-type + describes: shape.customer.java +assertions: +- id: assertion.customer-corresponds + assertion_kind: relation + subject: shape.customer.openapi + predicate: fiam.relation.corresponds-to + polarity: asserted + object_ref: shape.customer.java + evidence: + mode: fiam.evidence.inferred + source: static analyzers matched names and structure + confidence: 0.78 +- id: assertion.customer-same + assertion_kind: relation + subject: shape.customer.openapi + predicate: fiam.relation.same-entity-as + polarity: asserted + object_ref: shape.customer.java + evidence: + mode: fiam.evidence.declared + source: service owner mapping declaration + confidence: 0.99 +tests: + stresses: + - shape-identity + - multi-artifact-reconciliation + - evidence-preserving-sameness + notes: + - Correspondence may be inferred before an authoritative same-entity-as assertion is available; identity assertion does + not merge away either discovery record. + expected_properties: + - id: check.corresponds + kind: relation-exists + subject: shape.customer.openapi + predicate: fiam.relation.corresponds-to + object_ref: shape.customer.java + - id: check.same + kind: relation-exists + subject: shape.customer.openapi + predicate: fiam.relation.same-entity-as + object_ref: shape.customer.java + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations diff --git a/history/FIAM_v0.2_Draft6/specimens/pressure/01-openapi-json-schema-payloads.yaml b/history/FIAM_v0.2_Draft6/specimens/pressure/01-openapi-json-schema-payloads.yaml new file mode 100644 index 0000000..0a53d5e --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/pressure/01-openapi-json-schema-payloads.yaml @@ -0,0 +1,145 @@ +fiam_version: '0.2' +instance: + id: specimen.shape.openapi + kind: specimen + title: OpenAPI operation with reusable logical payload shapes + status: provisional + intent: Separate logical input/output/error shapes from JSON representation and description artifacts. +nodes: +- id: node.client + kind: system-node + name: API client + node_type: fiam.node-type.application +- id: node.user-service + kind: system-node + name: User service + node_type: fiam.node-type.service +ports: +- id: port.user-service.api + owner: node.user-service + participations: + - contract: contract.user-api + mode: offers +- id: port.client.api + owner: node.client + participations: + - contract: contract.user-api + mode: requires +contracts: +- id: contract.user-api + kind: interface-contract + purpose: + - fiam.purpose.mutation + operations: + - id: operation.create-user + name: create user + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.write +endpoints: +- id: endpoint.user-api + kind: endpoint + address: https://users.example.invalid/v1 + address_scheme: fiam.address-scheme.https-url +bindings: +- id: binding.user-api.http + contract: contract.user-api + provider_port: port.user-service.api + consumer_ports: + - port.client.api + endpoints: + - endpoint.user-api + operations: + - operation.create-user + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls +information_shapes: +- id: shape.create-user.request + kind: information-shape + name: CreateUser request + shape_kind: fiam.information-shape.object +- id: shape.user.response + kind: information-shape + name: User response + shape_kind: fiam.information-shape.object +- id: shape.problem + kind: information-shape + name: Problem details + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.openapi + kind: artifact + name: openapi.yaml + artifact_type: fiam.artifact.api-description + describes: + - contract.user-api + - shape.create-user.request + - shape.user.response + - shape.problem + locator: repo://api/openapi.yaml + facets: + technology: fiam.tech.openapi +- id: artifact.create-user-jsonschema + kind: artifact + name: create-user.schema.json + artifact_type: fiam.artifact.schema-document + describes: shape.create-user.request + locator: repo://schemas/create-user.schema.json + facets: + technology: fiam.tech.json-schema +assertions: +- id: assertion.create-user.accepts + assertion_kind: relation + subject: operation.create-user + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.create-user.request + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + representation: fiam.representation.json +- id: assertion.create-user.produces + assertion_kind: relation + subject: operation.create-user + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.user.response + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + representation: fiam.representation.json +- id: assertion.create-user.errors + assertion_kind: relation + subject: operation.create-user + predicate: fiam.relation.errors-with-shape + polarity: asserted + object_ref: shape.problem + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + representation: fiam.representation.json +tests: + stresses: + - shape-vs-representation + - shape-vs-artifact + - one-shape-multiple-description-artifacts + notes: + - CreateUser request remains one InformationShape even when both OpenAPI and standalone JSON Schema describe it. + - JSON is a representation of the operation payload, not the identity of the shape. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations +x-references: +- https://spec.openapis.org/oas/latest.html diff --git a/history/FIAM_v0.2_Draft6/specimens/pressure/02-grpc-protobuf-messages.yaml b/history/FIAM_v0.2_Draft6/specimens/pressure/02-grpc-protobuf-messages.yaml new file mode 100644 index 0000000..def08c7 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/pressure/02-grpc-protobuf-messages.yaml @@ -0,0 +1,111 @@ +fiam_version: '0.2' +instance: + id: specimen.shape.grpc + kind: specimen + title: gRPC methods and Protocol Buffers message shapes + status: provisional + intent: Separate protobuf message type identity from .proto artifact and protobuf wire representation. +nodes: +- id: node.grpc-client + kind: system-node + name: gRPC client + node_type: fiam.node-type.application +- id: node.greeter + kind: system-node + name: Greeter service + node_type: fiam.node-type.service +ports: +- id: port.greeter + owner: node.greeter + participations: + - contract: contract.greeter + mode: offers +- id: port.grpc-client + owner: node.grpc-client + participations: + - contract: contract.greeter + mode: requires +contracts: +- id: contract.greeter + kind: interface-contract + operations: + - id: operation.say-hello + name: SayHello + interaction_style: fiam.interaction-style.rpc + contract_forms: + - fiam.contract-form.protobuf-service +bindings: +- id: binding.greeter.grpc + contract: contract.greeter + provider_port: port.greeter + consumer_ports: + - port.grpc-client + operations: + - operation.say-hello + binding_profile: fiam.binding-profile.grpc-http2 + communication_stack: + - role: fiam.stack-role.messaging-protocol + term: fiam.protocol.grpc + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http2 +information_shapes: +- id: shape.hello-request + kind: information-shape + name: HelloRequest + shape_kind: fiam.information-shape.object +- id: shape.hello-reply + kind: information-shape + name: HelloReply + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.greeter-proto + kind: artifact + name: greeter.proto + artifact_type: fiam.artifact.protobuf-source + describes: + - contract.greeter + - shape.hello-request + - shape.hello-reply + locator: repo://proto/greeter.proto +assertions: +- id: assertion.hello.accepts + assertion_kind: relation + subject: operation.say-hello + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.hello-request + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + representation: fiam.representation.protobuf +- id: assertion.hello.produces + assertion_kind: relation + subject: operation.say-hello + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.hello-reply + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + representation: fiam.representation.protobuf +tests: + stresses: + - message-type-vs-wire-format + - one-artifact-describes-contract-and-shapes + notes: + - HelloRequest and HelloReply are InformationShapes; protobuf is their operation representation. + - .proto is an Artifact that describes shapes and contract, not the shape entity itself. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations +x-references: +- https://protobuf.dev/programming-guides/proto3/ +- https://grpc.io/docs/what-is-grpc/core-concepts/ diff --git a/history/FIAM_v0.2_Draft6/specimens/pressure/03-graphql-types-and-response-envelope.yaml b/history/FIAM_v0.2_Draft6/specimens/pressure/03-graphql-types-and-response-envelope.yaml new file mode 100644 index 0000000..9c53610 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/pressure/03-graphql-types-and-response-envelope.yaml @@ -0,0 +1,113 @@ +fiam_version: '0.2' +instance: + id: specimen.shape.graphql + kind: specimen + title: GraphQL named types, input types and response envelope + status: provisional + intent: Separate GraphQL type-system shapes from operation documents, JSON encoding and schema artifact. +nodes: +- id: node.graphql-service + kind: system-node + name: GraphQL service + node_type: fiam.node-type.service +ports: +- id: port.graphql + owner: node.graphql-service + participations: + - contract: contract.graphql + mode: offers +contracts: +- id: contract.graphql + kind: interface-contract + operations: + - id: operation.update-user + name: updateUser mutation + interaction_style: fiam.interaction-style.query + contract_forms: + - fiam.contract-form.graphql-schema +information_shapes: +- id: shape.graphql.user-input + kind: information-shape + name: UserInput + shape_kind: fiam.information-shape.object +- id: shape.graphql.user + kind: information-shape + name: User + shape_kind: fiam.information-shape.object +- id: shape.graphql.response + kind: information-shape + name: GraphQL response envelope + shape_kind: fiam.information-shape.envelope +artifacts: +- id: artifact.graphql-schema + kind: artifact + name: schema.graphql + artifact_type: fiam.artifact.graphql-schema + describes: + - contract.graphql + - shape.graphql.user-input + - shape.graphql.user + - shape.graphql.response + locator: repo://graphql/schema.graphql +assertions: +- id: assertion.graphql.accepts + assertion_kind: relation + subject: operation.update-user + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.graphql.user-input + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + representation: fiam.representation.json +- id: assertion.graphql.produces + assertion_kind: relation + subject: operation.update-user + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.graphql.response + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + representation: fiam.representation.json +- id: assertion.graphql.response-embeds-user + assertion_kind: relation + subject: shape.graphql.response + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.graphql.user + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + slot: data.updateUser + role: fiam.shape-role.payload +tests: + stresses: + - type-system-vs-operation-document + - response-envelope-vs-domain-type + - shape-composition + notes: + - GraphQL named types are shapes, while a GraphQL document is a request representation/expression. + - The response envelope can embed a domain User shape without collapsing the two. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations + - id: check.graphql-pressure.slot + kind: relation-exists + subject: shape.graphql.response + predicate: fiam.relation.embeds-shape + object_ref: shape.graphql.user + facets: + slot: data.updateUser +x-references: +- https://spec.graphql.org/September2025/ diff --git a/history/FIAM_v0.2_Draft6/specimens/pressure/04-postgresql-table-row-shape.yaml b/history/FIAM_v0.2_Draft6/specimens/pressure/04-postgresql-table-row-shape.yaml new file mode 100644 index 0000000..6327090 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/pressure/04-postgresql-table-row-shape.yaml @@ -0,0 +1,101 @@ +fiam_version: '0.2' +instance: + id: specimen.shape.postgres-row + kind: specimen + title: PostgreSQL table resource and row InformationShape + status: provisional + intent: Separate persistent table identity from the row structure governing its elements and the DDL artifact declaring + that structure. +nodes: +- id: node.postgres + kind: system-node + name: PostgreSQL + node_type: fiam.node-type.database +information_resources: +- id: resource.exchange-table + kind: information-resource + owner: node.postgres + name: public.integration_exchange + resource_kind: fiam.information-resource.relational-table + resource_scope: fiam.resource-scope.concrete-collection + selectors: + - kind: fiam.resource-selector.sql-qualified-name + value: public.integration_exchange +information_shapes: +- id: shape.exchange-table + kind: information-shape + name: integration_exchange table collection + shape_kind: fiam.information-shape.collection +- id: shape.exchange-row.v1 + kind: information-shape + name: integration_exchange row v1 + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.exchange-ddl + kind: artifact + name: 001_create_exchange.sql + artifact_type: fiam.artifact.sql-ddl + describes: + - resource.exchange-table + - shape.exchange-table + - shape.exchange-row.v1 + locator: repo://migrations/001_create_exchange.sql +assertions: +- id: assertion.exchange.conforms + assertion_kind: relation + subject: resource.exchange-table + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.exchange-table + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.exchange.element-shape + assertion_kind: relation + subject: resource.exchange-table + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.exchange-row.v1 + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + slot: row + role: fiam.shape-role.element +- id: assertion.exchange.collection-element + assertion_kind: relation + subject: shape.exchange-table + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.exchange-row.v1 + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + slot: row + role: fiam.shape-role.element +tests: + stresses: + - resource-vs-element-shape + - shape-vs-ddl + notes: + - The table remains the InformationResource; its rows have an InformationShape. + - SQL DDL describes resource/shape but is not itself the shape. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations + - id: check.pg-pressure.conforms + kind: relation-exists + subject: resource.exchange-table + predicate: fiam.relation.conforms-to-shape + object_ref: shape.exchange-table +x-references: +- https://www.postgresql.org/docs/current/rowtypes.html +- https://www.postgresql.org/docs/current/ddl-basics.html diff --git a/history/FIAM_v0.2_Draft6/specimens/pressure/05-cli-input-output-shapes.yaml b/history/FIAM_v0.2_Draft6/specimens/pressure/05-cli-input-output-shapes.yaml new file mode 100644 index 0000000..930c483 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/pressure/05-cli-input-output-shapes.yaml @@ -0,0 +1,105 @@ +fiam_version: '0.2' +instance: + id: specimen.shape.cli + kind: specimen + title: CLI argument and JSON result shapes + status: provisional + intent: Test operations whose input and output shapes use different concrete representations. +nodes: +- id: node.kubectl + kind: system-node + name: kubectl + node_type: fiam.node-type.process +ports: +- id: port.kubectl.cli + owner: node.kubectl + participations: + - contract: contract.kubectl-cli + mode: offers +contracts: +- id: contract.kubectl-cli + kind: interface-contract + operations: + - id: operation.kubectl-get + name: kubectl get + interaction_style: fiam.interaction-style.command +information_shapes: +- id: shape.kubectl-get-args + kind: information-shape + name: kubectl get arguments/options + shape_kind: fiam.information-shape.argument-set +- id: shape.pod-list + kind: information-shape + name: PodList + shape_kind: fiam.information-shape.collection +- id: shape.pod + kind: information-shape + name: Pod + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.kubectl-help + kind: artifact + name: kubectl get --help + artifact_type: fiam.artifact.cli-contract-description + describes: + - contract.kubectl-cli + - shape.kubectl-get-args +assertions: +- id: assertion.kubectl.accepts + assertion_kind: relation + subject: operation.kubectl-get + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.kubectl-get-args + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + representation: fiam.representation.command-tokens +- id: assertion.kubectl.produces + assertion_kind: relation + subject: operation.kubectl-get + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.pod-list + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + representation: fiam.representation.json +- id: assertion.pod-list.element-shape + assertion_kind: relation + subject: shape.pod-list + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.pod + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + slot: items + role: fiam.shape-role.element +tests: + stresses: + - different-input-output-representations + - cli-shape-without-network + notes: + - Input and output representations attach to shape participation relations rather than forcing one operation-wide representation. + - CLI argument structure is a valid InformationShape even without network serialization. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations + - id: check.cli.element + kind: relation-exists + subject: shape.pod-list + predicate: fiam.relation.element-shape + object_ref: shape.pod + facets: + slot: items diff --git a/history/FIAM_v0.2_Draft6/specimens/pressure/06-cloudevents-envelope-and-data-shape.yaml b/history/FIAM_v0.2_Draft6/specimens/pressure/06-cloudevents-envelope-and-data-shape.yaml new file mode 100644 index 0000000..63ff689 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/pressure/06-cloudevents-envelope-and-data-shape.yaml @@ -0,0 +1,92 @@ +fiam_version: '0.2' +instance: + id: specimen.shape.cloudevents + kind: specimen + title: CloudEvents envelope and independent event-data shape + status: provisional + intent: Test an envelope shape whose data payload has its own shape and potentially different content representation. +nodes: +- id: node.publisher + kind: system-node + name: Order publisher + node_type: fiam.node-type.service +contracts: +- id: contract.order-events + kind: interface-contract + purpose: + - fiam.purpose.domain-event-publication + operations: + - id: operation.publish-order-created + name: publish OrderCreated + interaction_style: fiam.interaction-style.publish +information_shapes: +- id: shape.cloudevent-envelope + kind: information-shape + name: CloudEvent envelope + shape_kind: fiam.information-shape.envelope + facets: + semantic_standard: fiam.tech.cloudevents +- id: shape.order-created-data + kind: information-shape + name: OrderCreated data + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.order-created-schema + kind: artifact + name: order-created.schema.json + artifact_type: fiam.artifact.schema-document + describes: shape.order-created-data + facets: + technology: fiam.tech.json-schema +assertions: +- id: assertion.publish.produces-envelope + assertion_kind: relation + subject: operation.publish-order-created + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.cloudevent-envelope + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + representation: fiam.representation.json +- id: assertion.envelope.embeds-data + assertion_kind: relation + subject: shape.cloudevent-envelope + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.order-created-data + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + slot: data + role: fiam.shape-role.payload +tests: + stresses: + - envelope-vs-domain-data + - semantic-model-vs-event-format + - nested-shape + notes: + - CloudEvent envelope and domain event data are distinct InformationShapes. + - JSON event format does not determine the domain data shape. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations + - id: check.cloudevents.slot + kind: relation-exists + subject: shape.cloudevent-envelope + predicate: fiam.relation.embeds-shape + object_ref: shape.order-created-data + facets: + slot: data + role: fiam.shape-role.payload +x-references: +- https://github.com/cloudevents/spec/blob/main/cloudevents/spec.md +- https://github.com/cloudevents/spec/blob/main/cloudevents/formats/json-format.md diff --git a/history/FIAM_v0.2_Draft6/specimens/pressure/07-java-native-object-shapes.yaml b/history/FIAM_v0.2_Draft6/specimens/pressure/07-java-native-object-shapes.yaml new file mode 100644 index 0000000..50841c5 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/pressure/07-java-native-object-shapes.yaml @@ -0,0 +1,88 @@ +fiam_version: '0.2' +instance: + id: specimen.shape.java-native + kind: specimen + title: In-process Java operation with native object shapes + status: provisional + intent: Show that InformationShape is useful without serialization or a network boundary. +nodes: +- id: node.processor + kind: system-node + name: Customer processor module + node_type: fiam.node-type.library-module +ports: +- id: port.processor.spi + owner: node.processor + participations: + - contract: contract.processor-spi + mode: offers +contracts: +- id: contract.processor-spi + kind: interface-contract + operations: + - id: operation.process-customer + name: process(Customer) + interaction_style: fiam.interaction-style.function-call + contract_forms: + - fiam.contract-form.language-interface +information_shapes: +- id: shape.customer + kind: information-shape + name: Customer + shape_kind: fiam.information-shape.object +- id: shape.processing-result + kind: information-shape + name: ProcessingResult + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.customer-java + kind: artifact + name: Customer.java + artifact_type: fiam.artifact.source-code-type + describes: shape.customer + locator: repo://src/Customer.java +- id: artifact.result-java + kind: artifact + name: ProcessingResult.java + artifact_type: fiam.artifact.source-code-type + describes: shape.processing-result + locator: repo://src/ProcessingResult.java +assertions: +- id: assertion.process.accepts + assertion_kind: relation + subject: operation.process-customer + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.customer + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + representation: fiam.representation.language-native-object +- id: assertion.process.produces + assertion_kind: relation + subject: operation.process-customer + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.processing-result + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + representation: fiam.representation.language-native-object +tests: + stresses: + - shape-without-serialization + - runtime-type-vs-source-artifact + notes: + - InformationShape applies to in-process native objects, so it is broader than MessageType. + - Java source declarations are artifacts describing shapes, not substitutes for shape identity. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations diff --git a/history/FIAM_v0.2_Draft6/specimens/pressure/08-shape-evolution-over-stable-resource.yaml b/history/FIAM_v0.2_Draft6/specimens/pressure/08-shape-evolution-over-stable-resource.yaml new file mode 100644 index 0000000..db01d5d --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/pressure/08-shape-evolution-over-stable-resource.yaml @@ -0,0 +1,81 @@ +fiam_version: '0.2' +instance: + id: specimen.shape.evolution + kind: specimen + title: Stable resource with evolving element shape + status: provisional + intent: Test shape identity/lifecycle independently of InformationResource identity. +nodes: +- id: node.store + kind: system-node + name: Shared store + node_type: fiam.node-type.database +information_resources: +- id: resource.customer-table + kind: information-resource + owner: node.store + name: public.customer + resource_kind: fiam.information-resource.relational-table + resource_scope: fiam.resource-scope.concrete-collection + selectors: + - kind: fiam.resource-selector.sql-qualified-name + value: public.customer +information_shapes: +- id: shape.customer-row.v1 + kind: information-shape + name: Customer row v1 + shape_kind: fiam.information-shape.object +- id: shape.customer-row.v2 + kind: information-shape + name: Customer row v2 + shape_kind: fiam.information-shape.object +assertions: +- id: assertion.customer-shape-v1 + assertion_kind: relation + subject: resource.customer-table + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.customer-row.v1 + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + valid_time: + valid_until: '2026-06-30T23:59:59Z' +- id: assertion.customer-shape-v2 + assertion_kind: relation + subject: resource.customer-table + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.customer-row.v2 + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + valid_time: + valid_from: '2026-07-01T00:00:00Z' +- id: assertion.shape-v2-version-of-v1 + assertion_kind: relation + subject: shape.customer-row.v2 + predicate: fiam.relation.version-of + polarity: asserted + object_ref: shape.customer-row.v1 + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +tests: + stresses: + - shape-versioning + - resource-identity-stability + - validity-window + notes: + - Resource identity remains stable while the governing element shape changes. + - Shape versions get separate stable identities rather than silently mutating one shape record. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations diff --git a/history/FIAM_v0.2_Draft6/specimens/pressure/09-one-shape-multiple-representations.yaml b/history/FIAM_v0.2_Draft6/specimens/pressure/09-one-shape-multiple-representations.yaml new file mode 100644 index 0000000..fa29b5b --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/pressure/09-one-shape-multiple-representations.yaml @@ -0,0 +1,72 @@ +fiam_version: '0.2' +instance: + id: specimen.shape.multi-representation + kind: specimen + title: One logical shape with JSON and CBOR representations + status: provisional + intent: Demonstrate that InformationShape identity is independent of wire/content representation. +nodes: +- id: node.catalog + kind: system-node + name: Catalog API + node_type: fiam.node-type.service +ports: +- id: port.catalog.api + owner: node.catalog + participations: + - contract: contract.catalog + mode: offers +contracts: +- id: contract.catalog + kind: interface-contract + purpose: + - fiam.purpose.query + operations: + - id: operation.get-product + name: get product + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.read +information_shapes: +- id: shape.product + kind: information-shape + name: Product + shape_kind: fiam.information-shape.object +assertions: +- id: assertion.product-json + assertion_kind: relation + subject: operation.get-product + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.product + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + representation: fiam.representation.json +- id: assertion.product-cbor + assertion_kind: relation + subject: operation.get-product + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.product + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 + facets: + representation: fiam.representation.cbor +tests: + stresses: + - one-shape-multiple-representations + - content-negotiation + notes: + - Both representations point to the same InformationShape identity. + - No JSONProduct or CBORProduct Core type is minted merely because serialization differs. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations diff --git a/history/FIAM_v0.2_Draft6/specimens/pressure/10-configuration-document-four-way-distinction.yaml b/history/FIAM_v0.2_Draft6/specimens/pressure/10-configuration-document-four-way-distinction.yaml new file mode 100644 index 0000000..b6b6600 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/pressure/10-configuration-document-four-way-distinction.yaml @@ -0,0 +1,61 @@ +fiam_version: '0.2' +instance: + id: specimen.shape.config-document + kind: specimen + title: Configuration document resource, shape, schema and representation + status: provisional + intent: Put Resource, InformationShape, schema Artifact and Representation side by side in one minimal case. +nodes: +- id: node.app + kind: system-node + name: Application + node_type: fiam.node-type.application +information_resources: +- id: resource.app-config + kind: information-resource + owner: node.app + name: config.json + resource_kind: fiam.information-resource.file + resource_scope: fiam.resource-scope.concrete-instance + selectors: + - kind: fiam.resource-selector.filesystem-path + value: /etc/example/config.json + facets: + representation: fiam.representation.json +information_shapes: +- id: shape.app-config + kind: information-shape + name: AppConfig + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.app-config-schema + kind: artifact + name: app-config.schema.json + artifact_type: fiam.artifact.schema-document + describes: shape.app-config + facets: + technology: fiam.tech.json-schema +assertions: +- id: assertion.config.conforms + assertion_kind: relation + subject: resource.app-config + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.app-config + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +tests: + stresses: + - resource-vs-shape-vs-schema-vs-representation + notes: + - config.json is an InformationResource, AppConfig is an InformationShape, app-config.schema.json is an Artifact, and JSON + is a Representation. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations diff --git a/history/FIAM_v0.2_Draft6/specimens/regression/01-mcp-stdio.yaml b/history/FIAM_v0.2_Draft6/specimens/regression/01-mcp-stdio.yaml new file mode 100644 index 0000000..d9911d4 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/regression/01-mcp-stdio.yaml @@ -0,0 +1,318 @@ +fiam_version: '0.2' +instance: + id: specimen.mcp.stdio.local + kind: specimen + title: MCP server over stdio + status: provisional + intent: Model a local agent-to-tool interface using MCP over JSON-RPC and stdio. +nodes: +- id: node.agent-host + kind: system-node + name: Agent Host + node_type: fiam.node-type.application +- id: node.mcp-server + kind: system-node + name: Local MCP Server + node_type: fiam.node-type.process +ports: +- id: port.agent.mcp-client + owner: node.agent-host + participations: + - contract: contract.mcp.tools + mode: requires + roles: + - fiam.role.client +- id: port.server.mcp + owner: node.mcp-server + participations: + - contract: contract.mcp.tools + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.mcp.tools + kind: interface-contract + purpose: + - fiam.purpose.tool-invocation + contract_forms: + - fiam.contract-form.mcp + operations: + - id: operation.mcp.tools-list + name: tools/list + interaction_style: fiam.interaction-style.rpc + - id: operation.mcp.tools-call + name: tools/call + interaction_style: fiam.interaction-style.rpc +- id: contract.tool.read-file + kind: interface-contract + name: read_file tool + purpose: + - fiam.purpose.tool-invocation + operations: + - id: operation.tool.read-file + name: read_file + interaction_style: fiam.interaction-style.rpc +bindings: +- id: binding.mcp.stdio + contract: contract.mcp.tools + provider_port: port.server.mcp + consumer_ports: + - port.agent.mcp-client + binding_profile: fiam.binding-profile.mcp-stdio + communication_stack: + - role: fiam.stack-role.application-protocol + term: fiam.protocol.mcp + - role: fiam.stack-role.messaging-protocol + term: fiam.protocol.json-rpc-2.0 + - role: fiam.stack-role.ipc-process-carrier + term: fiam.carrier.stdio + addressing: + kind: fiam.addressing.process-spawn + value: command invocation + session_model: fiam.session.long-lived-process +channels: +- id: channel.mcp.stdio + kind: channel + channel_type: fiam.channel.bidirectional-byte-stream + mediation: fiam.mediation.direct +interactions: +- id: interaction.tools-call + operation: operation.mcp.tools-call + binding: binding.mcp.stdio + channel: channel.mcp.stdio + temporal_semantics: fiam.temporal.synchronous + participants: + initiator: node.agent-host + responder: node.mcp-server +- id: interaction.read-file + kind: interaction + operation: operation.tool.read-file + binding: binding.mcp.stdio + channel: channel.mcp.stdio + temporal_semantics: fiam.temporal.synchronous + participants: + initiator: node.agent-host + responder: node.mcp-server + realization_status: fiam.interaction-status.executed +assertions: +- id: assertion.mcp.protocol + subject: binding.mcp.stdio + predicate: fiam.property.communication-protocol + value: fiam.protocol.mcp + evidence: + mode: fiam.evidence.declared + source: MCP specification + confidence: 1.0 + assertion_kind: property + polarity: asserted +- id: assertion.local-boundary + subject: binding.mcp.stdio + predicate: fiam.property.execution-boundary + value: fiam.execution-boundary.local-process + evidence: + mode: fiam.evidence.inferred + source: stdio binding semantics + confidence: 0.99 + assertion_kind: property + polarity: asserted +- id: assertion.mcp.catalog-elements + assertion_kind: relation + subject: shape.mcp.tool-catalog + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.mcp.tool-descriptor + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + slot: tools + role: fiam.shape-role.element +- id: assertion.mcp.tools-list-produces + assertion_kind: relation + subject: operation.mcp.tools-list + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.mcp.tool-catalog + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.mcp.tool-discovered + assertion_kind: relation + subject: operation.tool.read-file + predicate: fiam.relation.discovered-via + polarity: asserted + object_ref: operation.mcp.tools-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.mcp.tool-contract-embedded + assertion_kind: relation + subject: contract.tool.read-file + predicate: fiam.relation.embedded-in + polarity: asserted + object_ref: operation.mcp.tools-call + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + slot: params.arguments +- id: assertion.read-file.accepts + assertion_kind: relation + subject: operation.tool.read-file + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.read-file.args + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.request +- id: assertion.read-file.produces + assertion_kind: relation + subject: operation.tool.read-file + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.read-file.result + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response +- id: assertion.read-file.actual-input + assertion_kind: relation + subject: interaction.read-file + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.read-file.args + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.request + representation: fiam.representation.json +- id: assertion.read-file.actual-output + assertion_kind: relation + subject: interaction.read-file + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.read-file.result + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.mcp.tools-call-accepts + assertion_kind: relation + subject: operation.mcp.tools-call + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.mcp.tool-call-request + evidence: + mode: fiam.evidence.declared + source: MCP contract fixture + confidence: 0.98 + facets: + role: fiam.shape-role.request + representation: fiam.representation.json +- id: assertion.mcp.tools-call-produces + assertion_kind: relation + subject: operation.mcp.tools-call + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.mcp.tool-call-result + evidence: + mode: fiam.evidence.declared + source: MCP contract fixture + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.mcp.call-embeds-tool-args + assertion_kind: relation + subject: shape.mcp.tool-call-request + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.read-file.args + evidence: + mode: fiam.evidence.declared + source: MCP contract fixture + confidence: 0.98 + facets: + slot: params.arguments + role: fiam.shape-role.payload +tests: + stresses: + - contract-vs-binding-separation + - protocol-stack + - non-network-interface + notes: + - MCP is not modeled as a transport. + - stdio is modeled as a process carrier rather than an API family. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations + - id: check.mcp.discovery + kind: relation-exists + subject: operation.tool.read-file + predicate: fiam.relation.discovered-via + object_ref: operation.mcp.tools-list + - id: check.mcp.embedding + kind: relation-exists + subject: contract.tool.read-file + predicate: fiam.relation.embedded-in + object_ref: operation.mcp.tools-call + facets: + slot: params.arguments + - id: check.mcp.input-shape + kind: relation-exists + subject: interaction.read-file + predicate: fiam.relation.accepts-shape + object_ref: shape.read-file.args + facets: + representation: fiam.representation.json + - id: check.mcp.generic-call-shape + kind: relation-exists + subject: operation.mcp.tools-call + predicate: fiam.relation.accepts-shape + object_ref: shape.mcp.tool-call-request +information_shapes: +- id: shape.mcp.tool-catalog + kind: information-shape + name: MCP tool catalog + shape_kind: fiam.information-shape.collection +- id: shape.mcp.tool-descriptor + kind: information-shape + name: MCP tool descriptor + shape_kind: fiam.information-shape.object +- id: shape.read-file.args + kind: information-shape + name: read_file arguments + shape_kind: fiam.information-shape.object +- id: shape.read-file.result + kind: information-shape + name: read_file result + shape_kind: fiam.information-shape.object +- id: shape.mcp.tool-call-request + kind: information-shape + name: MCP tools/call request + shape_kind: fiam.information-shape.object +- id: shape.mcp.tool-call-result + kind: information-shape + name: MCP tools/call result + shape_kind: fiam.information-shape.object diff --git a/history/FIAM_v0.2_Draft6/specimens/regression/01-s3-prefix-drop.yaml b/history/FIAM_v0.2_Draft6/specimens/regression/01-s3-prefix-drop.yaml new file mode 100644 index 0000000..6203d5e --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/regression/01-s3-prefix-drop.yaml @@ -0,0 +1,168 @@ +fiam_version: '0.2' +instance: + id: specimen.resource.s3-prefix-drop + kind: specimen + title: S3 prefix file-drop integration + status: provisional + intent: Test a logical object prefix as the integration surface, distinct from the S3 API Binding and Endpoint. +nodes: +- id: node.producer + kind: system-node + name: Producer + node_type: fiam.node-type.service +- id: node.consumer + kind: system-node + name: Consumer + node_type: fiam.node-type.service +- id: node.s3 + kind: system-node + name: S3 Object Store + node_type: fiam.node-type.service +ports: +- id: port.s3.provider + owner: node.s3 + participations: + - contract: contract.object-store + mode: offers +- id: port.producer.s3 + owner: node.producer + participations: + - contract: contract.object-store + mode: requires +- id: port.consumer.s3 + owner: node.consumer + participations: + - contract: contract.object-store + mode: requires +contracts: +- id: contract.object-store + kind: interface-contract + purpose: + - fiam.purpose.transactional-data-access + operations: + - id: operation.put-object + name: PutObject + effect: fiam.effect.write + - id: operation.list-objects + name: ListObjects + effect: fiam.effect.read + - id: operation.get-object + name: GetObject + effect: fiam.effect.read +endpoints: +- id: endpoint.s3-api + kind: endpoint + address: https://example-bucket.s3.example.invalid + address_scheme: fiam.address-scheme.https-url +bindings: +- id: binding.s3 + contract: contract.object-store + provider_port: port.s3.provider + consumer_ports: + - port.producer.s3 + - port.consumer.s3 + endpoints: + - endpoint.s3-api + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + - role: fiam.stack-role.transport + term: fiam.transport.tcp +information_resources: +- id: resource.s3.bucket + kind: information-resource + name: example-bucket + resource_kind: fiam.information-resource.object-store-bucket + resource_scope: fiam.resource-scope.concrete-collection + owner: node.s3 + selectors: + - kind: fiam.resource-selector.s3-bucket-name + value: example-bucket + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +- id: resource.s3.incoming-prefix + kind: information-resource + name: incoming/ logical object set + resource_kind: fiam.information-resource.object-collection + resource_scope: fiam.resource-scope.logical-selection + owner: node.s3 + selectors: + - kind: fiam.resource-selector.s3-prefix + value: incoming/ + facets: + durability: fiam.durability.durable + mutability: fiam.mutability.mutable +interactions: +- id: interaction.producer.put + kind: interaction + operation: operation.put-object + binding: binding.s3 +- id: interaction.consumer.list + kind: interaction + operation: operation.list-objects + binding: binding.s3 +- id: interaction.consumer.get + kind: interaction + operation: operation.get-object + binding: binding.s3 +assertions: +- id: assertion.prefix.selection + assertion_kind: relation + subject: resource.s3.incoming-prefix + predicate: fiam.relation.selection-of + polarity: asserted + object_ref: resource.s3.bucket + evidence: + mode: fiam.evidence.declared + source: S3 object key/prefix semantics + confidence: 0.98 +- id: assertion.put.targets-prefix + assertion_kind: relation + subject: interaction.producer.put + predicate: fiam.relation.writes-to + polarity: asserted + object_ref: resource.s3.incoming-prefix + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.list.targets-prefix + assertion_kind: relation + subject: interaction.consumer.list + predicate: fiam.relation.reads-from + polarity: asserted + object_ref: resource.s3.incoming-prefix + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.get.targets-prefix + assertion_kind: relation + subject: interaction.consumer.get + predicate: fiam.relation.reads-from + polarity: asserted + object_ref: resource.s3.incoming-prefix + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +tests: + stresses: + - logical-selection-not-provider-native + - resource-selector-vs-endpoint + - file-drop-through-object-store + notes: + - The incoming/ prefix is modeled as a logical InformationResource selection, not as an Endpoint or Channel. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations +x-references: +- https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html +- https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-prefixes.html diff --git a/history/FIAM_v0.2_Draft6/specimens/regression/02-filesystem-watched-directory.yaml b/history/FIAM_v0.2_Draft6/specimens/regression/02-filesystem-watched-directory.yaml new file mode 100644 index 0000000..9c3d569 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/regression/02-filesystem-watched-directory.yaml @@ -0,0 +1,117 @@ +fiam_version: '0.2' +instance: + id: specimen.resource.filesystem-drop + kind: specimen + title: Watched filesystem directory + status: provisional + intent: Test a durable shared directory as an asynchronous integration surface without network API semantics. +nodes: +- id: node.writer + kind: system-node + name: Writer Process + node_type: fiam.node-type.process +- id: node.watcher + kind: system-node + name: Watcher Process + node_type: fiam.node-type.process +- id: node.os + kind: system-node + name: Operating System / Filesystem + node_type: fiam.node-type.process +ports: +- id: port.writer.fs + owner: node.writer + participations: + - contract: contract.fs + mode: requires +- id: port.watcher.fs + owner: node.watcher + participations: + - contract: contract.fs + mode: requires +- id: port.os.fs + owner: node.os + participations: + - contract: contract.fs + mode: offers +contracts: +- id: contract.fs + kind: interface-contract + purpose: + - fiam.purpose.mutation + operations: + - id: operation.fs.write + name: write/rename + effect: fiam.effect.write + - id: operation.fs.observe + name: observe directory changes + interaction_style: fiam.interaction-style.subscribe +bindings: +- id: binding.fs.local + contract: contract.fs + provider_port: port.os.fs + consumer_ports: + - port.writer.fs + - port.watcher.fs + communication_stack: + - role: fiam.stack-role.runtime + term: fiam.carrier.in-process-method-call +information_resources: +- id: resource.fs.drop-dir + kind: information-resource + name: /srv/drop/incoming + resource_kind: fiam.information-resource.filesystem-directory + resource_scope: fiam.resource-scope.shared-state + owner: node.os + selectors: + - kind: fiam.resource-selector.filesystem-path + value: /srv/drop/incoming + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +interactions: +- id: interaction.fs.write + kind: interaction + operation: operation.fs.write + binding: binding.fs.local + temporal_semantics: fiam.temporal.synchronous +- id: interaction.fs.watch + kind: interaction + operation: operation.fs.observe + binding: binding.fs.local + temporal_semantics: fiam.temporal.asynchronous +assertions: +- id: assertion.fs.write + assertion_kind: relation + subject: interaction.fs.write + predicate: fiam.relation.writes-to + polarity: asserted + object_ref: resource.fs.drop-dir + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.fs.watch + assertion_kind: relation + subject: interaction.fs.watch + predicate: fiam.relation.watches + polarity: asserted + object_ref: resource.fs.drop-dir + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +tests: + stresses: + - shared-resource-without-network-endpoint + - asynchronous-observation + - file-surface + notes: + - The directory is an InformationResource; the OS call surface is the Binding. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations diff --git a/history/FIAM_v0.2_Draft6/specimens/regression/02-mcp-streamable-http.yaml b/history/FIAM_v0.2_Draft6/specimens/regression/02-mcp-streamable-http.yaml new file mode 100644 index 0000000..e8a71f8 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/regression/02-mcp-streamable-http.yaml @@ -0,0 +1,317 @@ +fiam_version: '0.2' +instance: + id: specimen.mcp.streamable-http.remote + kind: specimen + title: MCP server over Streamable HTTP + status: provisional + intent: Reuse the same MCP/tool contract, dynamic discovery graph, and shapes as the stdio specimen while changing only + the concrete remote binding/topology. +nodes: +- id: node.remote-agent + kind: system-node + name: Remote Agent Host + node_type: fiam.node-type.application +- id: node.remote-mcp-server + kind: system-node + name: Remote MCP Server + node_type: fiam.node-type.service +ports: +- id: port.remote-agent.mcp + owner: node.remote-agent + participations: + - contract: contract.mcp.tools + mode: requires + roles: + - fiam.role.client +- id: port.remote-server.mcp + owner: node.remote-mcp-server + participations: + - contract: contract.mcp.tools + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.mcp.tools + kind: interface-contract + purpose: + - fiam.purpose.tool-invocation + contract_forms: + - fiam.contract-form.mcp + operations: + - id: operation.mcp.tools-list + name: tools/list + interaction_style: fiam.interaction-style.rpc + - id: operation.mcp.tools-call + name: tools/call + interaction_style: fiam.interaction-style.rpc +- id: contract.tool.read-file + kind: interface-contract + name: read_file tool + purpose: + - fiam.purpose.tool-invocation + operations: + - id: operation.tool.read-file + name: read_file + interaction_style: fiam.interaction-style.rpc +bindings: +- id: binding.mcp.streamable-http + contract: contract.mcp.tools + provider_port: port.remote-server.mcp + consumer_ports: + - port.remote-agent.mcp + binding_profile: fiam.binding-profile.mcp-streamable-http + communication_stack: + - role: fiam.stack-role.application-protocol + term: fiam.protocol.mcp + - role: fiam.stack-role.messaging-protocol + term: fiam.protocol.json-rpc-2.0 + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + - role: fiam.stack-role.transport + term: fiam.transport.tcp + endpoints: + - endpoint.mcp.https +channels: +- id: channel.mcp.http + kind: channel + channel_type: fiam.channel.http-exchange + mediation: fiam.mediation.direct +interactions: +- id: interaction.remote-tools-call + operation: operation.mcp.tools-call + binding: binding.mcp.streamable-http + channel: channel.mcp.http + temporal_semantics: fiam.temporal.synchronous + participants: + initiator: node.remote-agent + responder: node.remote-mcp-server +- id: interaction.remote-read-file + kind: interaction + operation: operation.tool.read-file + binding: binding.mcp.streamable-http + channel: channel.mcp.http + temporal_semantics: fiam.temporal.synchronous + participants: + initiator: node.remote-agent + responder: node.remote-mcp-server + realization_status: fiam.interaction-status.executed +assertions: +- id: assertion.remote-network + assertion_kind: property + subject: binding.mcp.streamable-http + predicate: fiam.property.execution-boundary + polarity: asserted + value: fiam.execution-boundary.remote-network + evidence: + mode: fiam.evidence.declared + source: MCP Streamable HTTP binding fixture + confidence: 1.0 +- id: assertion.mcp.catalog-elements + assertion_kind: relation + subject: shape.mcp.tool-catalog + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.mcp.tool-descriptor + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + slot: tools + role: fiam.shape-role.element +- id: assertion.mcp.tools-list-produces + assertion_kind: relation + subject: operation.mcp.tools-list + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.mcp.tool-catalog + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.mcp.tool-discovered + assertion_kind: relation + subject: operation.tool.read-file + predicate: fiam.relation.discovered-via + polarity: asserted + object_ref: operation.mcp.tools-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.mcp.tool-contract-embedded + assertion_kind: relation + subject: contract.tool.read-file + predicate: fiam.relation.embedded-in + polarity: asserted + object_ref: operation.mcp.tools-call + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + slot: params.arguments +- id: assertion.read-file.accepts + assertion_kind: relation + subject: operation.tool.read-file + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.read-file.args + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.request +- id: assertion.read-file.produces + assertion_kind: relation + subject: operation.tool.read-file + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.read-file.result + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response +- id: assertion.remote-read-file.actual-input + assertion_kind: relation + subject: interaction.remote-read-file + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.read-file.args + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.request + representation: fiam.representation.json +- id: assertion.remote-read-file.actual-output + assertion_kind: relation + subject: interaction.remote-read-file + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.read-file.result + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.mcp.tools-call-accepts + assertion_kind: relation + subject: operation.mcp.tools-call + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.mcp.tool-call-request + evidence: + mode: fiam.evidence.declared + source: MCP contract fixture + confidence: 0.98 + facets: + role: fiam.shape-role.request + representation: fiam.representation.json +- id: assertion.mcp.tools-call-produces + assertion_kind: relation + subject: operation.mcp.tools-call + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.mcp.tool-call-result + evidence: + mode: fiam.evidence.declared + source: MCP contract fixture + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +- id: assertion.mcp.call-embeds-tool-args + assertion_kind: relation + subject: shape.mcp.tool-call-request + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.read-file.args + evidence: + mode: fiam.evidence.declared + source: MCP contract fixture + confidence: 0.98 + facets: + slot: params.arguments + role: fiam.shape-role.payload +tests: + stresses: + - same-contract-different-binding + - dynamic-contract-discovery + - protocol-stack + - endpoint-addressing + notes: + - Contract ids, operation ids, tool contract, discovery relations and shape ids intentionally match the stdio specimen. + Only realization-specific nodes, ports, binding, channel, endpoint and execution boundary differ. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations + - id: check.mcp.discovery + kind: relation-exists + subject: operation.tool.read-file + predicate: fiam.relation.discovered-via + object_ref: operation.mcp.tools-list + - id: check.mcp.embedding + kind: relation-exists + subject: contract.tool.read-file + predicate: fiam.relation.embedded-in + object_ref: operation.mcp.tools-call + facets: + slot: params.arguments + - id: check.mcp.actual-shape + kind: relation-exists + subject: interaction.remote-read-file + predicate: fiam.relation.accepts-shape + object_ref: shape.read-file.args + facets: + representation: fiam.representation.json +information_shapes: +- id: shape.mcp.tool-catalog + kind: information-shape + name: MCP tool catalog + shape_kind: fiam.information-shape.collection +- id: shape.mcp.tool-descriptor + kind: information-shape + name: MCP tool descriptor + shape_kind: fiam.information-shape.object +- id: shape.read-file.args + kind: information-shape + name: read_file arguments + shape_kind: fiam.information-shape.object +- id: shape.read-file.result + kind: information-shape + name: read_file result + shape_kind: fiam.information-shape.object +- id: shape.mcp.tool-call-request + kind: information-shape + name: MCP tools/call request + shape_kind: fiam.information-shape.object +- id: shape.mcp.tool-call-result + kind: information-shape + name: MCP tools/call result + shape_kind: fiam.information-shape.object +endpoints: +- id: endpoint.mcp.https + kind: endpoint + address: https://mcp.example.test/mcp + address_scheme: fiam.address-scheme.https-url +security: +- id: security.mcp.remote + applies_to: binding.mcp.streamable-http + transport_security: fiam.security.tls + authentication: fiam.security.authentication.unspecified diff --git a/history/FIAM_v0.2_Draft6/specimens/regression/03-graphql-over-https.yaml b/history/FIAM_v0.2_Draft6/specimens/regression/03-graphql-over-https.yaml new file mode 100644 index 0000000..8d7c148 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/regression/03-graphql-over-https.yaml @@ -0,0 +1,239 @@ +fiam_version: '0.2' +instance: + id: specimen.graphql.https + kind: specimen + title: GraphQL application interface over HTTPS + status: provisional + intent: Separate GraphQL execution semantics from its HTTP realization. +nodes: +- id: node.web-client + kind: system-node + name: Web Client + node_type: fiam.node-type.application +- id: node.graphql-service + kind: system-node + name: GraphQL Service + node_type: fiam.node-type.service +ports: +- id: port.client.graphql + owner: node.web-client + participations: + - contract: contract.graphql.catalog + mode: requires + roles: + - fiam.role.client +- id: port.service.graphql + owner: node.graphql-service + participations: + - contract: contract.graphql.catalog + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.graphql.catalog + kind: interface-contract + purpose: + - fiam.purpose.query + - fiam.purpose.mutation + contract_forms: + - fiam.contract-form.graphql-schema + operations: + - id: operation.graphql.query + name: query + interaction_style: fiam.interaction-style.query + effect: fiam.effect.read + - id: operation.graphql.mutation + name: mutation + interaction_style: fiam.interaction-style.command + effect: fiam.effect.write +endpoints: +- id: endpoint.graphql + kind: endpoint + address: https://api.example.test/graphql + address_scheme: fiam.address-scheme.https-url +bindings: +- id: binding.graphql.https + contract: contract.graphql.catalog + provider_port: port.service.graphql + consumer_ports: + - port.client.graphql + binding_profile: fiam.binding-profile.graphql-over-http + communication_stack: + - role: fiam.stack-role.application-semantics + term: fiam.tech.graphql + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + - role: fiam.stack-role.transport + term: fiam.transport.tcp + endpoints: + - endpoint.graphql +interactions: +- id: interaction.graphql-query + operation: operation.graphql.query + binding: binding.graphql.https + temporal_semantics: fiam.temporal.synchronous +assertions: +- id: assertion.graphql-transport-independence + subject: contract.graphql.catalog + predicate: fiam.property.transport-independent + value: true + evidence: + mode: fiam.evidence.declared + source: GraphQL specification + confidence: 1.0 + assertion_kind: property + polarity: asserted +- id: assertion.graphql.request-embeds-document + assertion_kind: relation + subject: shape.graphql.request + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.graphql.document + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + slot: query + role: fiam.shape-role.payload +- id: assertion.graphql.response-embeds-item + assertion_kind: relation + subject: shape.graphql.response + predicate: fiam.relation.embeds-shape + polarity: asserted + object_ref: shape.graphql.catalog-item + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + slot: data.catalog + role: fiam.shape-role.payload +- id: assertion.graphql.query-accepts + assertion_kind: relation + subject: operation.graphql.query + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.graphql.request + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.request +- id: assertion.graphql.query-produces + assertion_kind: relation + subject: operation.graphql.query + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.graphql.response + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response +- id: assertion.graphql.binding-accepts-json + assertion_kind: relation + subject: binding.graphql.https + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.graphql.request + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.request + representation: fiam.representation.json + operation_ref: operation.graphql.query +- id: assertion.graphql.binding-produces-json + assertion_kind: relation + subject: binding.graphql.https + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.graphql.response + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json + operation_ref: operation.graphql.query +- id: assertion.graphql.interaction-produces-json + assertion_kind: relation + subject: interaction.graphql-query + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.graphql.response + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +tests: + stresses: + - execution-language-vs-transport + - operation-level-semantics + notes: + - GraphQL is modeled independently of HTTP. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations + - id: check.graphql.types + kind: entity-exists + ref: shape.graphql.catalog-item + entity_kind: information-shape + - id: check.graphql.slot + kind: relation-exists + subject: shape.graphql.response + predicate: fiam.relation.embeds-shape + object_ref: shape.graphql.catalog-item + facets: + slot: data.catalog + role: fiam.shape-role.payload + - id: check.graphql.binding-json + kind: relation-exists + subject: binding.graphql.https + predicate: fiam.relation.produces-shape + object_ref: shape.graphql.response + facets: + representation: fiam.representation.json +information_shapes: +- id: shape.graphql.request + kind: information-shape + name: GraphQL request envelope + shape_kind: fiam.information-shape.envelope +- id: shape.graphql.document + kind: information-shape + name: GraphQL executable document + shape_kind: fiam.information-shape.opaque + facets: + semantic_standard: fiam.tech.graphql +- id: shape.graphql.response + kind: information-shape + name: GraphQL response envelope + shape_kind: fiam.information-shape.envelope +- id: shape.graphql.catalog-item + kind: information-shape + name: Catalog item + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.graphql.schema + kind: artifact + name: schema.graphql + artifact_type: fiam.artifact.graphql-schema + describes: + - contract.graphql.catalog + - shape.graphql.catalog-item + - shape.graphql.response + locator: repo://graphql/schema.graphql diff --git a/history/FIAM_v0.2_Draft6/specimens/regression/03-shared-postgresql-table.yaml b/history/FIAM_v0.2_Draft6/specimens/regression/03-shared-postgresql-table.yaml new file mode 100644 index 0000000..d889878 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/regression/03-shared-postgresql-table.yaml @@ -0,0 +1,222 @@ +fiam_version: '0.2' +instance: + id: specimen.resource.shared-postgresql-table + kind: specimen + title: Shared PostgreSQL table integration + status: provisional + intent: Separate database protocol binding from the shared table that creates architectural coupling between applications. +nodes: +- id: node.app-a + kind: system-node + name: Application A + node_type: fiam.node-type.service +- id: node.app-b + kind: system-node + name: Application B + node_type: fiam.node-type.service +- id: node.postgres + kind: system-node + name: PostgreSQL + node_type: fiam.node-type.database +ports: +- id: port.pg.provider + owner: node.postgres + participations: + - contract: contract.sql + mode: offers +- id: port.app-a.pg + owner: node.app-a + participations: + - contract: contract.sql + mode: requires +- id: port.app-b.pg + owner: node.app-b + participations: + - contract: contract.sql + mode: requires +contracts: +- id: contract.sql + kind: interface-contract + purpose: + - fiam.purpose.transactional-data-access + operations: + - id: operation.sql.write + name: INSERT/UPDATE + effect: fiam.effect.write + - id: operation.sql.read + name: SELECT + effect: fiam.effect.read +endpoints: +- id: endpoint.pg + kind: endpoint + address: db.internal:5432 +bindings: +- id: binding.pg + contract: contract.sql + provider_port: port.pg.provider + consumer_ports: + - port.app-a.pg + - port.app-b.pg + endpoints: + - endpoint.pg + communication_stack: + - role: fiam.stack-role.database-protocol + term: fiam.protocol.postgresql-frontend-backend + - role: fiam.stack-role.transport + term: fiam.transport.tcp +information_resources: +- id: resource.pg.exchange + kind: information-resource + name: public.integration_exchange + resource_kind: fiam.information-resource.relational-table + resource_scope: fiam.resource-scope.shared-state + owner: node.postgres + selectors: + - kind: fiam.resource-selector.sql-qualified-name + value: public.integration_exchange + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +interactions: +- id: interaction.app-a.write + kind: interaction + operation: operation.sql.write + binding: binding.pg +- id: interaction.app-b.read + kind: interaction + operation: operation.sql.read + binding: binding.pg +assertions: +- id: assertion.app-a.write-table + assertion_kind: relation + subject: interaction.app-a.write + predicate: fiam.relation.writes-to + polarity: asserted + object_ref: resource.pg.exchange + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.app-b.read-table + assertion_kind: relation + subject: interaction.app-b.read + predicate: fiam.relation.reads-from + polarity: asserted + object_ref: resource.pg.exchange + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.pg.table-conforms + assertion_kind: relation + subject: resource.pg.exchange + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.pg.exchange-table + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.pg.table-element + assertion_kind: relation + subject: resource.pg.exchange + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.pg.exchange-row + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.element + slot: row +- id: assertion.pg.collection-element + assertion_kind: relation + subject: shape.pg.exchange-table + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.pg.exchange-row + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.element + slot: row +- id: assertion.pg.write-accepts + assertion_kind: relation + subject: interaction.app-a.write + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.pg.exchange-row + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.request + representation: fiam.representation.sql-row +- id: assertion.pg.read-produces + assertion_kind: relation + subject: interaction.app-b.read + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.pg.exchange-row + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.sql-row +tests: + stresses: + - shared-state-coupling + - binding-vs-data-resource + - schema-qualified-selection + notes: + - Both applications use the same PostgreSQL Binding family, but their integration coupling is through the shared table resource. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations + - id: check.pg.table-shape + kind: relation-exists + subject: resource.pg.exchange + predicate: fiam.relation.conforms-to-shape + object_ref: shape.pg.exchange-table + - id: check.pg.row-shape + kind: relation-exists + subject: resource.pg.exchange + predicate: fiam.relation.element-shape + object_ref: shape.pg.exchange-row + - id: check.pg.ddl + kind: field-contains + ref: artifact.pg.exchange-ddl + field: describes + value: shape.pg.exchange-row +x-references: +- https://www.postgresql.org/docs/current/ddl-basics.html +- https://www.postgresql.org/docs/current/infoschema-tables.html +information_shapes: +- id: shape.pg.exchange-table + kind: information-shape + name: integration_exchange collection + shape_kind: fiam.information-shape.collection +- id: shape.pg.exchange-row + kind: information-shape + name: integration_exchange row + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.pg.exchange-ddl + kind: artifact + name: integration_exchange DDL + artifact_type: fiam.artifact.sql-ddl + describes: + - resource.pg.exchange + - shape.pg.exchange-table + - shape.pg.exchange-row + locator: db://public.integration_exchange/ddl diff --git a/history/FIAM_v0.2_Draft6/specimens/regression/04-grpc-bidirectional-stream.yaml b/history/FIAM_v0.2_Draft6/specimens/regression/04-grpc-bidirectional-stream.yaml new file mode 100644 index 0000000..73c86fc --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/regression/04-grpc-bidirectional-stream.yaml @@ -0,0 +1,87 @@ +fiam_version: '0.2' +instance: + id: specimen.grpc.bidirectional-stream + kind: specimen + title: gRPC bidirectional streaming operation + status: provisional + intent: Exercise operation-level interaction semantics inside a shared gRPC contract. +nodes: +- id: node.grpc-client + kind: system-node + name: Telemetry Client + node_type: fiam.node-type.service +- id: node.grpc-server + kind: system-node + name: Telemetry Aggregator + node_type: fiam.node-type.service +ports: +- id: port.grpc-client + owner: node.grpc-client + participations: + - contract: contract.telemetry.grpc + mode: requires + roles: + - fiam.role.client +- id: port.grpc-server + owner: node.grpc-server + participations: + - contract: contract.telemetry.grpc + mode: offers + roles: + - fiam.role.server +contracts: +- id: contract.telemetry.grpc + kind: interface-contract + purpose: + - fiam.purpose.telemetry-exchange + contract_forms: + - fiam.contract-form.protobuf-service + operations: + - id: operation.telemetry.stream + name: StreamTelemetry + interaction_style: fiam.interaction-style.rpc + temporal_semantics: fiam.temporal.bidirectional-stream +bindings: +- id: binding.telemetry.grpc + contract: contract.telemetry.grpc + provider_port: port.grpc-server + consumer_ports: + - port.grpc-client + binding_profile: fiam.binding-profile.grpc-http2 + communication_stack: + - role: fiam.stack-role.rpc-protocol + term: fiam.protocol.grpc + - role: fiam.stack-role.serialization + term: fiam.representation.protobuf + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http2 + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + - role: fiam.stack-role.transport + term: fiam.transport.tcp +channels: +- id: channel.grpc-stream + kind: channel + channel_type: fiam.channel.bidirectional-message-stream + mediation: fiam.mediation.direct +interactions: +- id: interaction.telemetry-stream + operation: operation.telemetry.stream + binding: binding.telemetry.grpc + channel: channel.grpc-stream + participants: + initiator: node.grpc-client + responder: node.grpc-server +tests: + stresses: + - operation-level-temporal-semantics + - multiplexed-protocol-stack + notes: + - Streaming semantics belong to the operation/interaction, not to the API family. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations diff --git a/history/FIAM_v0.2_Draft6/specimens/regression/04-kubernetes-resource-collection.yaml b/history/FIAM_v0.2_Draft6/specimens/regression/04-kubernetes-resource-collection.yaml new file mode 100644 index 0000000..fa65964 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/regression/04-kubernetes-resource-collection.yaml @@ -0,0 +1,292 @@ +fiam_version: '0.2' +instance: + id: specimen.resource.kubernetes-pods + kind: specimen + title: Kubernetes Pod collection and object + status: provisional + intent: Test API resource collection/object modeling while keeping representation kind/schema distinct from resource identity. +nodes: +- id: node.kubectl + kind: system-node + name: kubectl / API client + node_type: fiam.node-type.application +- id: node.apiserver + kind: system-node + name: Kubernetes API Server + node_type: fiam.node-type.service +ports: +- id: port.apiserver.api + owner: node.apiserver + participations: + - contract: contract.k8s-api + mode: offers +- id: port.kubectl.api + owner: node.kubectl + participations: + - contract: contract.k8s-api + mode: requires +contracts: +- id: contract.k8s-api + kind: interface-contract + purpose: + - fiam.purpose.transactional-data-access + - fiam.purpose.mutation + operations: + - id: operation.k8s.list-pods + name: list pods + effect: fiam.effect.read + - id: operation.k8s.watch-pods + name: watch pods + interaction_style: fiam.interaction-style.subscribe + - id: operation.k8s.patch-pod + name: patch pod + effect: fiam.effect.write +endpoints: +- id: endpoint.apiserver + kind: endpoint + address: https://cluster.example.invalid + address_scheme: fiam.address-scheme.https-url +bindings: +- id: binding.k8s-api + contract: contract.k8s-api + provider_port: port.apiserver.api + consumer_ports: + - port.kubectl.api + endpoints: + - endpoint.apiserver + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls +information_resources: +- id: resource.k8s.default-pods + kind: information-resource + name: default namespace Pods collection + resource_kind: fiam.information-resource.api-resource-collection + resource_scope: fiam.resource-scope.concrete-collection + owner: node.apiserver + selectors: + - kind: fiam.resource-selector.kubernetes-resource-path + value: /api/v1/namespaces/default/pods + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +- id: resource.k8s.pod.demo + kind: information-resource + name: Pod default/demo + resource_kind: fiam.information-resource.api-resource-object + resource_scope: fiam.resource-scope.concrete-instance + owner: node.apiserver + selectors: + - kind: fiam.resource-selector.kubernetes-object-ref + value: + apiVersion: v1 + kind: Pod + namespace: default + name: demo + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +interactions: +- id: interaction.k8s.list + kind: interaction + operation: operation.k8s.list-pods + binding: binding.k8s-api +- id: interaction.k8s.watch + kind: interaction + operation: operation.k8s.watch-pods + binding: binding.k8s-api + temporal_semantics: fiam.temporal.asynchronous +- id: interaction.k8s.patch + kind: interaction + operation: operation.k8s.patch-pod + binding: binding.k8s-api +assertions: +- id: assertion.pod.in-collection + assertion_kind: relation + subject: resource.k8s.pod.demo + predicate: fiam.relation.contained-in + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.list.reads + assertion_kind: relation + subject: interaction.k8s.list + predicate: fiam.relation.reads-from + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.watch.watches + assertion_kind: relation + subject: interaction.k8s.watch + predicate: fiam.relation.watches + polarity: asserted + object_ref: resource.k8s.default-pods + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.patch.writes + assertion_kind: relation + subject: interaction.k8s.patch + predicate: fiam.relation.writes-to + polarity: asserted + object_ref: resource.k8s.pod.demo + evidence: + mode: fiam.evidence.declared + source: modeling specimen + confidence: 0.98 +- id: assertion.k8s.collection-conforms + assertion_kind: relation + subject: resource.k8s.default-pods + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.k8s.collection-element + assertion_kind: relation + subject: resource.k8s.default-pods + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.element + slot: items +- id: assertion.k8s.listshape-element + assertion_kind: relation + subject: shape.k8s.pod-list + predicate: fiam.relation.element-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.element + slot: items +- id: assertion.k8s.object-conforms + assertion_kind: relation + subject: resource.k8s.pod.demo + predicate: fiam.relation.conforms-to-shape + polarity: asserted + object_ref: shape.k8s.pod + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.k8s.list-produces + assertion_kind: relation + subject: operation.k8s.list-pods + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response +- id: assertion.k8s.list-binding-json + assertion_kind: relation + subject: binding.k8s-api + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json + operation_ref: operation.k8s.list-pods +- id: assertion.k8s.list-interaction-json + assertion_kind: relation + subject: interaction.k8s.list + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.k8s.pod-list + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.response + representation: fiam.representation.json +tests: + stresses: + - resource-type-vs-representation-kind + - collection-vs-instance + - watch-semantics + notes: + - Pod collection/object are InformationResources; Pod kind/schema is not forced into InformationResource and remains a pressure + point for InformationShape. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations + - id: check.k8s.pod-shape + kind: entity-exists + ref: shape.k8s.pod + entity_kind: information-shape + - id: check.k8s.collection-shape + kind: relation-exists + subject: resource.k8s.default-pods + predicate: fiam.relation.conforms-to-shape + object_ref: shape.k8s.pod-list + - id: check.k8s.element-shape + kind: relation-exists + subject: resource.k8s.default-pods + predicate: fiam.relation.element-shape + object_ref: shape.k8s.pod + facets: + slot: items + role: fiam.shape-role.element + - id: check.k8s.binding-representation + kind: relation-exists + subject: binding.k8s-api + predicate: fiam.relation.produces-shape + object_ref: shape.k8s.pod-list + facets: + representation: fiam.representation.json + operation_ref: operation.k8s.list-pods +x-references: +- https://kubernetes.io/docs/reference/using-api/api-concepts/ +- https://kubernetes.io/docs/reference/kubernetes-api/definitions/api-resource-v1-meta/ +information_shapes: +- id: shape.k8s.pod + kind: information-shape + name: Kubernetes Pod + shape_kind: fiam.information-shape.object +- id: shape.k8s.pod-list + kind: information-shape + name: Kubernetes Pod collection representation + shape_kind: fiam.information-shape.collection +artifacts: +- id: artifact.k8s.openapi + kind: artifact + name: Kubernetes OpenAPI schema/discovery + artifact_type: fiam.artifact.api-description + describes: + - contract.k8s-api + - shape.k8s.pod + - shape.k8s.pod-list + locator: cluster://openapi diff --git a/history/FIAM_v0.2_Draft6/specimens/regression/05-configmap-projections.yaml b/history/FIAM_v0.2_Draft6/specimens/regression/05-configmap-projections.yaml new file mode 100644 index 0000000..e8ab288 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/regression/05-configmap-projections.yaml @@ -0,0 +1,99 @@ +fiam_version: '0.2' +instance: + id: specimen.resource.configmap-projection + kind: specimen + title: Kubernetes ConfigMap projected to environment and file + status: provisional + intent: Test one configuration resource materialized into multiple local resource forms consumed by a process. +nodes: +- id: node.apiserver + kind: system-node + name: Kubernetes API Server + node_type: fiam.node-type.service +- id: node.kubelet + kind: system-node + name: kubelet + node_type: fiam.node-type.process +- id: node.app + kind: system-node + name: Application Process + node_type: fiam.node-type.process +information_resources: +- id: resource.configmap.app + kind: information-resource + name: ConfigMap default/app-config + resource_kind: fiam.information-resource.configuration-object + resource_scope: fiam.resource-scope.concrete-instance + owner: node.apiserver + selectors: + - kind: fiam.resource-selector.kubernetes-object-ref + value: + apiVersion: v1 + kind: ConfigMap + namespace: default + name: app-config + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.mutable +- id: resource.env.database-host + kind: information-resource + name: DATABASE_HOST + resource_kind: fiam.information-resource.environment-entry + resource_scope: fiam.resource-scope.concrete-instance + owner: node.app + selectors: + - kind: fiam.resource-selector.environment-key + value: DATABASE_HOST + facets: + durability: fiam.durability.ephemeral + mutability: fiam.mutability.replaceable +- id: resource.file.app-config + kind: information-resource + name: /etc/app/config.yaml + resource_kind: fiam.information-resource.file + resource_scope: fiam.resource-scope.concrete-instance + owner: node.app + selectors: + - kind: fiam.resource-selector.filesystem-path + value: /etc/app/config.yaml + facets: + durability: fiam.durability.ephemeral + mutability: fiam.mutability.replaceable +assertions: +- id: assertion.configmap.to-env + assertion_kind: relation + subject: resource.configmap.app + predicate: fiam.relation.materializes-as + polarity: asserted + object_ref: resource.env.database-host + evidence: + mode: fiam.evidence.declared + source: Kubernetes ConfigMap projection + confidence: 0.98 +- id: assertion.configmap.to-file + assertion_kind: relation + subject: resource.configmap.app + predicate: fiam.relation.materializes-as + polarity: asserted + object_ref: resource.file.app-config + evidence: + mode: fiam.evidence.declared + source: Kubernetes ConfigMap volume projection + confidence: 0.98 +tests: + stresses: + - resource-projection + - same-information-multiple-surfaces + - configuration-not-api-only + notes: + - ConfigMap, environment entry, and mounted file are distinct InformationResources linked by materialization, not one overloaded + interface record. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations +x-references: +- https://kubernetes.io/docs/concepts/configuration/configmap/ diff --git a/history/FIAM_v0.2_Draft6/specimens/regression/05-postgresql-unix-socket.yaml b/history/FIAM_v0.2_Draft6/specimens/regression/05-postgresql-unix-socket.yaml new file mode 100644 index 0000000..a70ade9 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/regression/05-postgresql-unix-socket.yaml @@ -0,0 +1,88 @@ +fiam_version: '0.2' +instance: + id: specimen.postgresql.unix-socket + kind: specimen + title: PostgreSQL frontend/backend protocol over Unix-domain socket + status: provisional + intent: Demonstrate a database interface using a non-network local carrier. +nodes: +- id: node.app + kind: system-node + name: Application Process + node_type: fiam.node-type.process +- id: node.postgres + kind: system-node + name: PostgreSQL Server + node_type: fiam.node-type.database +ports: +- id: port.app.sql + owner: node.app + participations: + - contract: contract.postgresql + mode: requires + roles: + - fiam.role.database-client +- id: port.postgres.sql + owner: node.postgres + participations: + - contract: contract.postgresql + mode: offers + roles: + - fiam.role.database-server +contracts: +- id: contract.postgresql + kind: interface-contract + purpose: + - fiam.purpose.query + - fiam.purpose.transactional-data-access + contract_forms: + - fiam.contract-form.database-wire-protocol +endpoints: +- id: endpoint.postgres.socket + kind: endpoint + address: /var/run/postgresql/.s.PGSQL.5432 + address_scheme: fiam.address-scheme.unix-socket-path +bindings: +- id: binding.postgresql.unix + contract: contract.postgresql + provider_port: port.postgres.sql + consumer_ports: + - port.app.sql + binding_profile: fiam.binding-profile.postgresql-unix-socket + communication_stack: + - role: fiam.stack-role.database-protocol + term: fiam.protocol.postgresql-frontend-backend + - role: fiam.stack-role.ipc-process-carrier + term: fiam.transport.unix-domain-socket + endpoints: + - endpoint.postgres.socket +interactions: +- id: interaction.sql-session + binding: binding.postgresql.unix + interaction_style: fiam.interaction-style.session-command-response + temporal_semantics: fiam.temporal.stateful-session +assertions: +- id: assertion.not-network + subject: binding.postgresql.unix + predicate: fiam.property.network-required + value: false + evidence: + mode: fiam.evidence.runtime-observed + source: socket path observation + confidence: 1.0 + assertion_kind: property + polarity: asserted +tests: + stresses: + - database-protocol-vs-carrier + - local-ipc + - stateful-session + notes: + - Database protocol is separated from TCP/IP assumptions. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations diff --git a/history/FIAM_v0.2_Draft6/specimens/regression/06-kafka-topic.yaml b/history/FIAM_v0.2_Draft6/specimens/regression/06-kafka-topic.yaml new file mode 100644 index 0000000..b36c82e --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/regression/06-kafka-topic.yaml @@ -0,0 +1,235 @@ +fiam_version: '0.2' +instance: + id: specimen.kafka.topic + kind: specimen + title: Kafka producer/consumer interaction through a durable topic + status: provisional + intent: Exercise mediated asynchronous interaction, durable channels, partition ordering, and decoupled participants. +nodes: +- id: node.order-service + kind: system-node + name: Order Service + node_type: fiam.node-type.service +- id: node.billing-service + kind: system-node + name: Billing Service + node_type: fiam.node-type.service +- id: node.kafka-cluster + kind: system-node + name: Kafka Cluster + node_type: fiam.node-type.broker +ports: +- id: port.order.events + owner: node.order-service + participations: + - contract: contract.order-events + mode: offers + roles: + - fiam.role.producer +- id: port.billing.events + owner: node.billing-service + participations: + - contract: contract.order-events + mode: requires + roles: + - fiam.role.consumer +contracts: +- id: contract.order-events + kind: interface-contract + purpose: + - fiam.purpose.domain-event-publication + contract_forms: + - fiam.contract-form.event-schema + operations: + - id: operation.order-created.publish + name: OrderCreated + interaction_style: fiam.interaction-style.publish + - id: operation.order-created.consume + name: OrderCreated + interaction_style: fiam.interaction-style.subscribe +channels: +- id: channel.orders + kind: channel + owner: node.kafka-cluster + channel_type: fiam.channel.durable-topic + name: orders.v1 + mediation: fiam.mediation.brokered + delivery_semantics: fiam.delivery.at-least-once + ordering_scope: fiam.ordering.partition + replay: true + retention: 7d +bindings: +- id: binding.kafka.orders + contract: contract.order-events + provider_port: port.order.events + consumer_ports: + - port.billing.events + binding_profile: fiam.binding-profile.kafka + channel: channel.orders + communication_stack: + - role: fiam.stack-role.broker-protocol + term: fiam.protocol.kafka + - role: fiam.stack-role.transport + term: fiam.transport.tcp +interactions: +- id: interaction.publish-order-created + operation: operation.order-created.publish + binding: binding.kafka.orders + channel: channel.orders + temporal_semantics: fiam.temporal.asynchronous +- id: interaction.consume-order-created + operation: operation.order-created.consume + binding: binding.kafka.orders + channel: channel.orders + temporal_semantics: fiam.temporal.asynchronous +assertions: +- id: assertion.channel-first-class + subject: channel.orders + predicate: fiam.property.mediation + value: fiam.mediation.brokered + evidence: + mode: fiam.evidence.declared + source: Kafka topology configuration + confidence: 0.98 + assertion_kind: property + polarity: asserted +- id: assertion.kafka.backed-by + assertion_kind: relation + subject: channel.orders + predicate: fiam.relation.backed-by + polarity: asserted + object_ref: resource.kafka.orders-log + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.kafka.publish-appends + assertion_kind: relation + subject: interaction.publish-order-created + predicate: fiam.relation.appends-to + polarity: asserted + object_ref: resource.kafka.orders-log + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.kafka.consume-reads + assertion_kind: relation + subject: interaction.consume-order-created + predicate: fiam.relation.reads-from + polarity: asserted + object_ref: resource.kafka.orders-log + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 +- id: assertion.kafka.publish-shape + assertion_kind: relation + subject: operation.order-created.publish + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.order-created + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.payload +- id: assertion.kafka.consume-shape + assertion_kind: relation + subject: operation.order-created.consume + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.order-created + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.payload +- id: assertion.kafka.publish-json + assertion_kind: relation + subject: interaction.publish-order-created + predicate: fiam.relation.produces-shape + polarity: asserted + object_ref: shape.order-created + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.payload + representation: fiam.representation.json +- id: assertion.kafka.consume-json + assertion_kind: relation + subject: interaction.consume-order-created + predicate: fiam.relation.accepts-shape + polarity: asserted + object_ref: shape.order-created + evidence: + mode: fiam.evidence.declared + source: FIAM v0.2 semantic specimen + confidence: 0.98 + facets: + role: fiam.shape-role.payload + representation: fiam.representation.json +tests: + stresses: + - mediated-interaction + - durable-channel + - producer-consumer-decoupling + - replay-and-ordering + notes: + - Producer and consumer are not modeled as a direct point-to-point connection. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations + - id: check.kafka.resource + kind: entity-exists + ref: resource.kafka.orders-log + entity_kind: information-resource + - id: check.kafka.shape + kind: entity-exists + ref: shape.order-created + entity_kind: information-shape + - id: check.kafka.backing + kind: relation-exists + subject: channel.orders + predicate: fiam.relation.backed-by + object_ref: resource.kafka.orders-log + - id: check.kafka.payload + kind: relation-exists + subject: interaction.publish-order-created + predicate: fiam.relation.produces-shape + object_ref: shape.order-created + facets: + representation: fiam.representation.json +information_resources: +- id: resource.kafka.orders-log + kind: information-resource + owner: node.kafka-cluster + name: orders.v1 retained log + resource_kind: fiam.information-resource.append-log + resource_scope: fiam.resource-scope.concrete-collection + selectors: + - kind: fiam.resource-selector.kafka-topic-name + value: orders.v1 + facets: + durability: fiam.durability.persistent + mutability: fiam.mutability.append-only +information_shapes: +- id: shape.order-created + kind: information-shape + name: OrderCreated event payload + shape_kind: fiam.information-shape.object +artifacts: +- id: artifact.order-created-schema + kind: artifact + name: OrderCreated schema + artifact_type: fiam.artifact.schema-document + describes: shape.order-created + locator: registry://orders/OrderCreated diff --git a/history/FIAM_v0.2_Draft6/specimens/regression/07-oidc-authorization-code-flow.yaml b/history/FIAM_v0.2_Draft6/specimens/regression/07-oidc-authorization-code-flow.yaml new file mode 100644 index 0000000..38697c8 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/regression/07-oidc-authorization-code-flow.yaml @@ -0,0 +1,173 @@ +fiam_version: '0.2' +instance: + id: specimen.oidc.authorization-code + kind: specimen + title: OIDC Authorization Code Flow + status: provisional + intent: Exercise multi-party choreography, browser-mediated redirects, token exchange, and layered identity semantics. +nodes: +- id: node.user-agent + kind: system-node + name: Browser + node_type: fiam.node-type.user-agent +- id: node.relying-party + kind: system-node + name: Relying Party + node_type: fiam.node-type.application +- id: node.authorization-server + kind: system-node + name: OpenID Provider + node_type: fiam.node-type.identity-provider +ports: +- id: port.rp.authn + owner: node.relying-party + participations: + - contract: contract.oidc + mode: requires + roles: + - fiam.role.oidc-client +- id: port.op.authorization + owner: node.authorization-server + participations: + - contract: contract.oidc + mode: offers + roles: + - fiam.role.authorization-server +- id: port.op.token + owner: node.authorization-server + participations: + - contract: contract.oidc + mode: offers + roles: + - fiam.role.token-issuer +contracts: +- id: contract.oidc + kind: interface-contract + purpose: + - fiam.purpose.authentication + - fiam.purpose.identity-federation + contract_forms: + - fiam.contract-form.oidc + operations: + - id: operation.authorization-request + name: authorization request + interaction_style: fiam.interaction-style.redirect-request + - id: operation.authorization-response + name: authorization response + interaction_style: fiam.interaction-style.redirect-response + - id: operation.token-request + name: token request + interaction_style: fiam.interaction-style.request-response +endpoints: +- id: endpoint.authorization + kind: endpoint + address: https://idp.example.test/authorize + address_scheme: fiam.address-scheme.https-url +- id: endpoint.token + kind: endpoint + address: https://idp.example.test/token + address_scheme: fiam.address-scheme.https-url +bindings: +- id: binding.oidc.authorization-https + contract: contract.oidc + provider_port: port.op.authorization + consumer_ports: + - port.rp.authn + operations: + - operation.authorization-request + - operation.authorization-response + binding_profile: fiam.binding-profile.oidc-http + communication_stack: + - role: fiam.stack-role.identity-protocol + term: fiam.protocol.openid-connect + - role: fiam.stack-role.authorization-framework + term: fiam.protocol.oauth2 + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + - role: fiam.stack-role.transport + term: fiam.transport.tcp + endpoints: + - endpoint.authorization +- id: binding.oidc.token-https + contract: contract.oidc + provider_port: port.op.token + consumer_ports: + - port.rp.authn + operations: + - operation.token-request + binding_profile: fiam.binding-profile.oidc-http + communication_stack: + - role: fiam.stack-role.identity-protocol + term: fiam.protocol.openid-connect + - role: fiam.stack-role.authorization-framework + term: fiam.protocol.oauth2 + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls + - role: fiam.stack-role.transport + term: fiam.transport.tcp + endpoints: + - endpoint.token +interaction_flows: +- id: flow.oidc.authorization-code + kind: interaction-flow + flow_type: fiam.flow.authentication-choreography + participants: + - node.user-agent + - node.relying-party + - node.authorization-server + steps: + - sequence: 1 + operation: operation.authorization-request + binding: binding.oidc.authorization-https + from: node.relying-party + via: node.user-agent + to: node.authorization-server + - sequence: 2 + operation: operation.authorization-response + binding: binding.oidc.authorization-https + from: node.authorization-server + via: node.user-agent + to: node.relying-party + - sequence: 3 + operation: operation.token-request + binding: binding.oidc.token-https + from: node.relying-party + to: node.authorization-server +security: +- id: security.oidc + applies_to: flow.oidc.authorization-code + authentication: fiam.security.authentication.federated + credential_artifacts: + - fiam.credential.authorization-code + - fiam.credential.id-token + - fiam.credential.access-token + identity_propagation: fiam.security.identity-propagation.token +assertions: +- id: assertion.flow-required + subject: flow.oidc.authorization-code + predicate: fiam.property.multi-party + value: true + evidence: + mode: fiam.evidence.declared + source: OIDC protocol definition + confidence: 1.0 + assertion_kind: property + polarity: asserted +tests: + stresses: + - multi-party-choreography + - browser-mediated-flow + - identity-overlay + notes: + - Authentication is modeled as a flow, not collapsed into one endpoint. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations diff --git a/history/FIAM_v0.2_Draft6/specimens/regression/07-transient-channel-counterexample.yaml b/history/FIAM_v0.2_Draft6/specimens/regression/07-transient-channel-counterexample.yaml new file mode 100644 index 0000000..0a35d72 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/regression/07-transient-channel-counterexample.yaml @@ -0,0 +1,82 @@ +fiam_version: '0.2' +instance: + id: specimen.resource.channel-counterexample + kind: specimen + title: Transient HTTP exchange without InformationResource + status: provisional + intent: Counterexample proving that a communication Channel need not be an InformationResource. +nodes: +- id: node.client + kind: system-node + name: Client + node_type: fiam.node-type.service +- id: node.server + kind: system-node + name: Command Service + node_type: fiam.node-type.service +ports: +- id: port.server + owner: node.server + participations: + - contract: contract.command + mode: offers +- id: port.client + owner: node.client + participations: + - contract: contract.command + mode: requires +contracts: +- id: contract.command + kind: interface-contract + purpose: + - fiam.purpose.mutation + operations: + - id: operation.restart + name: restart worker + interaction_style: fiam.interaction-style.request-response + effect: fiam.effect.write +endpoints: +- id: endpoint.command + kind: endpoint + address: https://service.example.invalid/restart + address_scheme: fiam.address-scheme.https-url +channels: +- id: channel.http + kind: channel + channel_type: fiam.channel.http-exchange + mediation: fiam.mediation.direct +bindings: +- id: binding.command + contract: contract.command + provider_port: port.server + consumer_ports: + - port.client + endpoints: + - endpoint.command + channel: channel.http + communication_stack: + - role: fiam.stack-role.application-transfer-protocol + term: fiam.protocol.http + - role: fiam.stack-role.security-protocol + term: fiam.protocol.tls +interactions: +- id: interaction.restart + kind: interaction + operation: operation.restart + binding: binding.command + channel: channel.http + temporal_semantics: fiam.temporal.synchronous +tests: + stresses: + - channel-without-persistent-resource + - command-interface + - transient-exchange + notes: + - No InformationResource is required merely because information passes through a Channel. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations diff --git a/history/FIAM_v0.2_Draft6/specimens/regression/08-java-serviceloader.yaml b/history/FIAM_v0.2_Draft6/specimens/regression/08-java-serviceloader.yaml new file mode 100644 index 0000000..1888646 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/specimens/regression/08-java-serviceloader.yaml @@ -0,0 +1,110 @@ +fiam_version: '0.2' +instance: + id: specimen.java.serviceloader + kind: specimen + title: Java ServiceLoader provider interface + status: provisional + intent: Exercise an in-process library/service-provider interface with discovery but no network or wire protocol. +nodes: +- id: node.java-application + kind: system-node + name: Java Application + node_type: fiam.node-type.process +- id: node.provider-module + kind: system-node + name: Provider Module + node_type: fiam.node-type.library-module +ports: +- id: port.app.spi + owner: node.java-application + participations: + - contract: contract.payment-provider-spi + mode: requires + roles: + - fiam.role.service-consumer +- id: port.provider.spi + owner: node.provider-module + participations: + - contract: contract.payment-provider-spi + mode: offers + roles: + - fiam.role.service-provider +contracts: +- id: contract.payment-provider-spi + kind: interface-contract + purpose: + - fiam.purpose.extension-point + contract_forms: + - fiam.contract-form.language-interface + operations: + - id: operation.provider.execute + name: execute + interaction_style: fiam.interaction-style.function-call +artifacts: +- id: artifact.java-interface + kind: artifact + artifact_type: fiam.artifact.source-code-interface + describes: contract.payment-provider-spi + locator: com.example.PaymentProvider +- id: artifact.service-registration + kind: artifact + artifact_type: fiam.artifact.service-provider-registration + implements: contract.payment-provider-spi + locator: META-INF/services/com.example.PaymentProvider +bindings: +- id: binding.java.serviceloader + contract: contract.payment-provider-spi + provider_port: port.provider.spi + consumer_ports: + - port.app.spi + binding_profile: fiam.binding-profile.java-serviceloader + communication_stack: + - role: fiam.stack-role.runtime + term: fiam.runtime.jvm + - role: fiam.stack-role.invocation-mechanism + term: fiam.carrier.in-process-method-call + discovery: + kind: fiam.discovery.runtime-service-provider-loading + source: artifact.service-registration +interactions: +- id: interaction.provider-call + operation: operation.provider.execute + binding: binding.java.serviceloader + temporal_semantics: fiam.temporal.synchronous + execution_boundary: fiam.execution-boundary.in-process +assertions: +- id: assertion.no-network + subject: binding.java.serviceloader + predicate: fiam.property.network-required + value: false + evidence: + mode: fiam.evidence.static-observed + source: artifact.service-registration + confidence: 0.95 + assertion_kind: property + polarity: asserted +- id: assertion.binding-discovered-via-registration + assertion_kind: relation + subject: binding.java.serviceloader + predicate: fiam.relation.discovered-via + object_ref: artifact.service-registration + polarity: asserted + evidence: + mode: fiam.evidence.static-observed + source: artifact.service-registration + confidence: 0.99 +tests: + stresses: + - library-interface + - runtime-discovery + - in-process-binding + - artifact-evidence + notes: + - FIAM does not assume that interfaces are networked or serialized. + expected_properties: + - id: check.evidence + kind: all-assertions-have-evidence + - id: check.no-deprecated + kind: no-deprecated-terms + - id: check.no-legacy-representations + kind: no-legacy-representations diff --git a/history/FIAM_v0.2_Draft6/tools/__pycache__/catalog_exchange.cpython-312.pyc b/history/FIAM_v0.2_Draft6/tools/__pycache__/catalog_exchange.cpython-312.pyc new file mode 100644 index 0000000..45a5f15 Binary files /dev/null and b/history/FIAM_v0.2_Draft6/tools/__pycache__/catalog_exchange.cpython-312.pyc differ diff --git a/history/FIAM_v0.2_Draft6/tools/__pycache__/declaration_matching.cpython-312.pyc b/history/FIAM_v0.2_Draft6/tools/__pycache__/declaration_matching.cpython-312.pyc new file mode 100644 index 0000000..7044a7a Binary files /dev/null and b/history/FIAM_v0.2_Draft6/tools/__pycache__/declaration_matching.cpython-312.pyc differ diff --git a/history/FIAM_v0.2_Draft6/tools/__pycache__/evidence_scoring.cpython-312.pyc b/history/FIAM_v0.2_Draft6/tools/__pycache__/evidence_scoring.cpython-312.pyc new file mode 100644 index 0000000..15447a8 Binary files /dev/null and b/history/FIAM_v0.2_Draft6/tools/__pycache__/evidence_scoring.cpython-312.pyc differ diff --git a/history/FIAM_v0.2_Draft6/tools/__pycache__/index_query.cpython-312.pyc b/history/FIAM_v0.2_Draft6/tools/__pycache__/index_query.cpython-312.pyc new file mode 100644 index 0000000..ca32216 Binary files /dev/null and b/history/FIAM_v0.2_Draft6/tools/__pycache__/index_query.cpython-312.pyc differ diff --git a/history/FIAM_v0.2_Draft6/tools/__pycache__/validate_fiam.cpython-312.pyc b/history/FIAM_v0.2_Draft6/tools/__pycache__/validate_fiam.cpython-312.pyc new file mode 100644 index 0000000..483df5b Binary files /dev/null and b/history/FIAM_v0.2_Draft6/tools/__pycache__/validate_fiam.cpython-312.pyc differ diff --git a/history/FIAM_v0.2_Draft6/tools/add_property_assertion.py b/history/FIAM_v0.2_Draft6/tools/add_property_assertion.py new file mode 100755 index 0000000..1ab377d --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/add_property_assertion.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +"""Add one evidence-backed property assertion to a FIAM model. + +Useful for governed declarations/expectations that live outside interface-description +formats, e.g. an operational architecture profile declaring an expected protocol. +""" +from __future__ import annotations +import argparse, copy +from pathlib import Path +import yaml + +def parse_value(s): + try:return yaml.safe_load(s) + except Exception:return s + +def main(): + ap=argparse.ArgumentParser(description=__doc__) + ap.add_argument('input',type=Path); ap.add_argument('-o','--output',type=Path,required=True) + ap.add_argument('--subject',required=True); ap.add_argument('--predicate',required=True); ap.add_argument('--value',required=True) + ap.add_argument('--source',type=Path,required=True); ap.add_argument('--source-type',default='architecture-declaration') + ap.add_argument('--locator',default='declaration'); ap.add_argument('--confidence',type=float,default=1.0) + args=ap.parse_args() + d=yaml.safe_load(args.input.read_text()); src=yaml.safe_load(args.source.read_text()) or {} + aid='artifact.declaration.'+args.source.stem.replace('_','-') + artifacts=d.setdefault('artifacts',[]) + if not any(x.get('id')==aid for x in artifacts): + artifacts.append({'id':aid,'kind':'artifact','name':args.source.name,'artifact_type':'fiam.artifact.architecture-declaration','locator':str(args.source), + 'facets':{'source_note':src.get('source_note') or src.get('statement') or 'Governed architecture declaration.'}}) + n=1; existing={x.get('id') for x in d.get('assertions',[]) or []} + while f'assertion.declaration.{n:04d}' in existing:n+=1 + a={'id':f'assertion.declaration.{n:04d}','assertion_kind':'property','subject':args.subject,'predicate':args.predicate,'polarity':'asserted','value':parse_value(args.value), + 'evidence':{'mode':'fiam.evidence.declared','source':{'type':args.source_type,'ref':aid,'locator':args.locator,'metadata':{'source_file':args.source.name}}, + 'observer':'governed-declaration/v0.2-draft.2','confidence':args.confidence,'stance':'supports'}} + d.setdefault('assertions',[]).append(a) + d['instance']=dict(d.get('instance',{})); d['instance']['id']=d['instance'].get('id','model')+'.expectation'; d['instance']['title']=d['instance'].get('title','FIAM model')+' + declared expectation' + args.output.parent.mkdir(parents=True,exist_ok=True); args.output.write_text(yaml.safe_dump(d,sort_keys=False,allow_unicode=True,width=120)) + print(f'wrote {args.output}: {a["id"]}') +if __name__=='__main__':main() diff --git a/history/FIAM_v0.2_Draft6/tools/architecture_changes_lens.py b/history/FIAM_v0.2_Draft6/tools/architecture_changes_lens.py new file mode 100755 index 0000000..ea1bf26 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/architecture_changes_lens.py @@ -0,0 +1,21 @@ +#!/usr/bin/env python3 +from __future__ import annotations +import argparse, sqlite3 +from pathlib import Path +import yaml +from declaration_matching import match_edge + +def edge(row,dm): + return {'edge_key':row['edge_key'],'domain':row['domain'],'kind':row['kind'],'from':row['from_ref'],'target':row['target_ref'],'target_kind':row['target_kind'],'channel':row['channel_ref'],'first_seen':row['first_seen'],'last_seen':row['last_seen'],'valid_from':row['valid_from'],'closed_at':row['closed_at'],'observation_count':int(row['observation_count'] or 0),'declared':dm['declared'],'declaration_matches':dm['matches'],'declaration_reason':dm['reason'],'close_reason':row['close_reason']} + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('db',type=Path);ap.add_argument('--population');ap.add_argument('--scope',dest='scope');ap.add_argument('--since',required=True);ap.add_argument('--until',required=True);ap.add_argument('-o','--output',type=Path,required=True);a=ap.parse_args();pop=a.population or a.scope + if not pop:ap.error('--population is required') + c=sqlite3.connect(a.db);c.row_factory=sqlite3.Row;appeared=[];undeclared=[];disappeared=[] + for r in c.execute('SELECT * FROM logical_topology_intervals WHERE population_id=? AND valid_from>=? AND valid_from<=? ORDER BY valid_from,edge_key',(pop,a.since,a.until)).fetchall(): + dm=match_edge(c,r,pop,r['valid_from']);x=edge(r,dm);appeared.append(x) + if not dm['declared']:undeclared.append(dict(x)) + for r in c.execute('SELECT * FROM logical_topology_intervals WHERE population_id=? AND closed_at IS NOT NULL AND closed_at>=? AND closed_at<=? ORDER BY closed_at,edge_key',(pop,a.since,a.until)).fetchall(): + dm=match_edge(c,r,pop,r['closed_at']);disappeared.append(edge(r,dm)) + out={'lens_id':'fiam.lens.architecture-changes','window':{'since':a.since,'until':a.until,'population_id':pop},'summary':{'appeared':len(appeared),'disappeared':len(disappeared),'newly_undeclared':len(undeclared)},'appeared':appeared,'disappeared':disappeared,'newly_undeclared':undeclared};a.output.write_text(yaml.safe_dump(out,sort_keys=False)) +if __name__=='__main__':main() diff --git a/history/FIAM_v0.2_Draft6/tools/architecture_policy_lens.py b/history/FIAM_v0.2_Draft6/tools/architecture_policy_lens.py new file mode 100755 index 0000000..17c94ac --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/architecture_policy_lens.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python3 +"""Policy projection over new architecture dependencies. Core facts remain unchanged.""" +from __future__ import annotations +import argparse,hashlib,sqlite3 +from pathlib import Path +import yaml +from declaration_matching import match_edge +from index_query import entity_owner_as_of,zones_by_type,active_observation_scopes + +def load(p):return yaml.safe_load(Path(p).read_text()) +def phash(p):return hashlib.sha256(Path(p).read_bytes()).hexdigest() + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('db',type=Path);ap.add_argument('--population',required=True);ap.add_argument('--since',required=True);ap.add_argument('--until',required=True);ap.add_argument('--policy',type=Path,required=True);ap.add_argument('-o','--output',type=Path,required=True);a=ap.parse_args();pol=load(a.policy);c=sqlite3.connect(a.db);c.row_factory=sqlite3.Row;weights=(pol.get('materiality') or {}).get('weights') or {};thr=(pol.get('materiality') or {}).get('thresholds') or {};hv=int((pol.get('materiality') or {}).get('high_volume_observation_count',100));rows=[];viol=[] + for r in c.execute('SELECT * FROM logical_topology_intervals WHERE population_id=? AND valid_from>=? AND valid_from<=? ORDER BY valid_from,edge_key',(a.population,a.since,a.until)).fetchall(): + dm=match_edge(c,r,a.population,r['valid_from']);fr=entity_owner_as_of(c,r['from_ref'],r['valid_from']);ta=entity_owner_as_of(c,r['target_ref'],r['valid_from']);fz=zones_by_type(c,fr,r['valid_from']);tz=zones_by_type(c,ta,r['valid_from']);trust=bool(fz.get('fiam.zone-type.trust-zone') and tz.get('fiam.zone-type.trust-zone') and set(fz['fiam.zone-type.trust-zone'])!=set(tz['fiam.zone-type.trust-zone']));org=bool(fz.get('fiam.zone-type.organization') and tz.get('fiam.zone-type.organization') and set(fz['fiam.zone-type.organization'])!=set(tz['fiam.zone-type.organization']));scopes=active_observation_scopes(c,a.population,r['edge_key'],r['valid_from']);components={'undeclared':not dm['declared'],'trust_boundary':trust,'organization_boundary':org,'high_volume':int(r['observation_count'] or 0)>=hv,'strong_evidence':len(scopes)>=2};score=sum(float(weights.get(k,0)) for k,v in components.items() if v);level='high' if score>=float(thr.get('high',.75)) else 'medium' if score>=float(thr.get('medium',.45)) else 'low' + item={'edge_key':r['edge_key'],'from':r['from_ref'],'target':r['target_ref'],'domain':r['domain'],'first_seen':r['first_seen'],'declared':dm['declared'],'observation_count':int(r['observation_count'] or 0),'corroborating_scopes':scopes,'materiality_score':round(score,4),'materiality':level,'components':components,'zone_context':{'from':fz,'target':tz}} + rows.append(item) + for rule in pol.get('boundary_rules') or []: + zt=rule.get('zone_type');froms=set(fz.get(zt) or []);tos=set(tz.get(zt) or []);cross=rule.get('from_zone') in froms and rule.get('to_zone') in tos + if not cross:continue + cond=rule.get('condition');bad=cond=='forbid' or (cond=='require-declared' and not dm['declared']) + if bad:viol.append({'edge_key':r['edge_key'],'rule_id':rule['id'],'severity':rule.get('severity','medium'),'condition':cond,'from_zone':rule.get('from_zone'),'to_zone':rule.get('to_zone'),'declared':dm['declared']}) + mats=[x for x in rows if x['materiality'] in ('high','medium')] + out={'lens_id':'fiam.lens.architecture-policy','policy':{'id':pol.get('id'),'sha256':phash(a.policy)},'window':{'since':a.since,'until':a.until,'population_id':a.population},'summary':{'new_dependencies':len(rows),'material_dependencies':len(mats),'policy_violations':len(viol)},'dependencies':rows,'material_dependencies':mats,'policy_violations':viol};a.output.write_text(yaml.safe_dump(out,sort_keys=False)) +if __name__=='__main__':main() diff --git a/history/FIAM_v0.2_Draft6/tools/boundary_drift_lens.py b/history/FIAM_v0.2_Draft6/tools/boundary_drift_lens.py new file mode 100755 index 0000000..2ca02da --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/boundary_drift_lens.py @@ -0,0 +1,20 @@ +#!/usr/bin/env python3 +from __future__ import annotations +import argparse, sqlite3 +from pathlib import Path +import yaml +from index_query import entity_owner_as_of,zones_by_type +DEFAULT_TYPES=['fiam.zone-type.trust-zone','fiam.zone-type.organization','fiam.zone-type.deployment-environment','fiam.zone-type.cluster'] + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('db',type=Path);ap.add_argument('--population');ap.add_argument('--scope');ap.add_argument('--since',required=True);ap.add_argument('--until',required=True);ap.add_argument('-o','--output',type=Path,required=True);ap.add_argument('--zone-type',action='append',dest='zone_types');a=ap.parse_args();pop=a.population or a.scope + if not pop:ap.error('--population required') + c=sqlite3.connect(a.db);c.row_factory=sqlite3.Row;cross=[];types=a.zone_types or DEFAULT_TYPES + rows=c.execute('SELECT * FROM logical_topology_intervals WHERE population_id=? AND valid_from>=? AND valid_from<=? ORDER BY valid_from,edge_key',(pop,a.since,a.until)).fetchall() + for r in rows: + fr=entity_owner_as_of(c,r['from_ref'],r['valid_from']);tar=entity_owner_as_of(c,r['target_ref'],r['valid_from']);fz=zones_by_type(c,fr,r['valid_from']);tz=zones_by_type(c,tar,r['valid_from']);zcs=[] + for zt in types: + if fz.get(zt) and tz.get(zt) and set(fz[zt])!=set(tz[zt]):zcs.append({'zone_type':zt,'from_zones':fz[zt],'target_zones':tz[zt]}) + if zcs:cross.append({'edge_key':r['edge_key'],'kind':r['kind'],'from':r['from_ref'],'target':r['target_ref'],'first_seen':r['first_seen'],'zone_crossings':zcs,'trust_boundary':any(z['zone_type']=='fiam.zone-type.trust-zone' for z in zcs),'organization_boundary':any(z['zone_type']=='fiam.zone-type.organization' for z in zcs)}) + out={'lens_id':'fiam.lens.boundary-drift','window':{'since':a.since,'until':a.until,'population_id':pop},'summary':{'new_cross_zone':len(cross),'new_trust_boundary':sum(x['trust_boundary'] for x in cross),'new_organization_boundary':sum(x['organization_boundary'] for x in cross)},'crossings':cross};a.output.write_text(yaml.safe_dump(out,sort_keys=False)) +if __name__=='__main__':main() diff --git a/history/FIAM_v0.2_Draft6/tools/catalog_exchange.py b/history/FIAM_v0.2_Draft6/tools/catalog_exchange.py new file mode 100755 index 0000000..132f105 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/catalog_exchange.py @@ -0,0 +1,116 @@ +#!/usr/bin/env python3 +"""Create/serialize FIAM Catalog Exchange v0.2 documents. + +This is an operational adapter above the frozen Core. It can transform a FIAM +model into a stable incremental/complete/declared catalog exchange document and +serialize the same logical content as YAML, JSON, or NDJSON. +""" +from __future__ import annotations +import argparse, hashlib, json +from pathlib import Path +import yaml + +ENTITY_SECTIONS=['participants','nodes','ports','contracts','endpoints','bindings','channels','information_resources','information_shapes','interactions','interaction_flows','artifacts','zones','security'] + +def h(*parts,n=24): + return hashlib.sha256('\x1f'.join('' if p is None else str(p) for p in parts).encode()).hexdigest()[:n] + +def file_hash(p): return hashlib.sha256(Path(p).read_bytes()).hexdigest() +def load(p): return yaml.safe_load(Path(p).read_text()) + +def zone_id(kind,value,parent=None): return f'zone.derived.{kind}.{h(kind,value,parent,n=12)}' + +def derive_zone_memberships(doc): + """Derive deployment env/cluster/namespace memberships from identity tuples. + Trust/org Zones are intentionally not derived here. + """ + existing={} + for z in doc.get('zones',[]) or []: + for m in z.get('members',[]) or []: + existing[(z.get('id'),m)]={'zone_id':z['id'],'member_id':m,'zone_type':z.get('zone_type'),'derived':False} + out=dict(existing) + zones_by_key={} + for z in doc.get('zones',[]) or []: + k=(z.get('zone_type'),z.get('name')) + zones_by_key[k]=z.get('id') + for n in doc.get('nodes',[]) or []: + it=((n.get('facets') or {}).get('identity_tuple') or {}) + env=it.get('environment') or it.get('deployment_environment') + cluster=it.get('cluster_uid') or it.get('cluster_name') or it.get('cluster') + ns=it.get('k8s_namespace') or it.get('kubernetes_namespace') + parent=None + if env: + zid=zones_by_key.get(('fiam.zone-type.deployment-environment',str(env))) or zone_id('environment',env) + out[(zid,n['id'])]={'zone_id':zid,'member_id':n['id'],'zone_type':'fiam.zone-type.deployment-environment','derived':True}; parent=zid + if cluster: + zid=zones_by_key.get(('fiam.zone-type.cluster',str(cluster))) or zone_id('cluster',cluster,env) + out[(zid,n['id'])]={'zone_id':zid,'member_id':n['id'],'zone_type':'fiam.zone-type.cluster','derived':True}; parent=zid + if ns: + zid=zones_by_key.get(('fiam.zone-type.kubernetes-namespace',str(ns))) or zone_id('k8s-namespace',ns,cluster or env) + out[(zid,n['id'])]={'zone_id':zid,'member_id':n['id'],'zone_type':'fiam.zone-type.kubernetes-namespace','derived':True} + return sorted(out.values(),key=lambda x:(x['zone_id'],x['member_id'])) + +def from_fiam(path, source_id, source_kind='fiam-model', source_ref=None, mode='declared-snapshot', observation_scope=None, population_id=None, population=None, domains=None, snapshot_time=None, authority_policy_id=None): + doc=load(path); fh=file_hash(path) + ext=doc.get('extensions') or {}; cat=ext.get('org.fiam.catalog') or {} + snapshot_time=snapshot_time or cat.get('last_ingest_at') or (doc.get('instance') or {}).get('updated_at') or (doc.get('instance') or {}).get('created_at') or '1970-01-01T00:00:00Z' + entities=[] + for sec in ENTITY_SECTIONS: + for e in doc.get(sec,[]) or []: + entities.append({'section':sec,'entity':e}) + declared_ids=set(cat.get('declared_entity_ids') or []) + # Operations nested in a declared contract are declared even when an older adapter's declared_entity_ids omitted nested operations. + for c in doc.get('contracts',[]) or []: + if mode=='declared-snapshot' or c.get('id') in declared_ids: + for op in c.get('operations',[]) or []: + if isinstance(op,dict) and op.get('id'): declared_ids.add(op['id']) + if mode=='declared-snapshot' and not declared_ids: + declared_ids.update(x['entity']['id'] for x in entities) + rec={ + 'entities':entities, + 'assertions':doc.get('assertions',[]) or [], + 'zone_memberships':derive_zone_memberships(doc), + 'runtime_aggregates':ext.get('org.fiam.runtime_aggregates') or [], + 'topology_observations':ext.get('org.fiam.runtime_topology_observations') or [], + 'unresolved':ext.get('org.fiam.runtime_unresolved') or [], + 'reconciliation_candidates':ext.get('org.fiam.reconciliation_candidates') or [], + 'declared_entity_ids':sorted(declared_ids) + } + obs={'mode':mode,'snapshot_time':snapshot_time,'observation_scope':observation_scope,'population_id':population_id,'population':population or {},'domains':domains or [],'aggregate_semantics':'cumulative'} + if authority_policy_id: obs['authority_policy_id']=authority_policy_id + payload_seed=json.dumps({'source_id':source_id,'mode':mode,'scope':observation_scope,'population_id':population_id,'snapshot_time':snapshot_time,'hash':fh},sort_keys=True,separators=(',',':')) + return {'catalog_exchange_version':'0.2','profile_id':'fiam.catalog-exchange.v0.2','exchange_id':'exchange.'+h(payload_seed),'created_at':snapshot_time, + 'source':{'source_id':source_id,'source_kind':source_kind,'source_ref':source_ref or str(path),'content_hash':fh},'observation':obs,'records':rec} + +def ndjson_lines(ex): + head={k:v for k,v in ex.items() if k!='records'}; yield json.dumps({'record_type':'header',**head},sort_keys=True) + mapping=[('entities','entity'),('assertions','assertion'),('zone_memberships','zone_membership'),('runtime_aggregates','runtime_aggregate'),('topology_observations','topology'),('unresolved','unresolved'),('reconciliation_candidates','reconciliation_candidate'),('declared_entity_ids','declared_entity_id')] + for key,rt in mapping: + for x in ex['records'].get(key,[]) or []: yield json.dumps({'record_type':rt,'data':x},sort_keys=True) + +def write(ex,path,fmt): + p=Path(path) + if fmt=='yaml': p.write_text(yaml.safe_dump(ex,sort_keys=False,allow_unicode=True,width=120)) + elif fmt=='json': p.write_text(json.dumps(ex,indent=2,sort_keys=False)+'\n') + else: p.write_text('\n'.join(ndjson_lines(ex))+'\n') + +def read_ndjson(path): + lines=[json.loads(x) for x in Path(path).read_text().splitlines() if x.strip()] + if not lines or lines[0].get('record_type')!='header': raise ValueError('NDJSON exchange requires header first') + hrec=dict(lines[0]);hrec.pop('record_type',None);hrec['records']={k:[] for k in ['entities','assertions','zone_memberships','runtime_aggregates','topology_observations','unresolved','reconciliation_candidates','declared_entity_ids']} + rev={'entity':'entities','assertion':'assertions','zone_membership':'zone_memberships','runtime_aggregate':'runtime_aggregates','topology':'topology_observations','unresolved':'unresolved','reconciliation_candidate':'reconciliation_candidates','declared_entity_id':'declared_entity_ids'} + for r in lines[1:]: + if r.get('record_type') not in rev: raise ValueError(f'unknown record_type {r.get("record_type")}') + hrec['records'][rev[r['record_type']]].append(r.get('data')) + return hrec + +def main(): + ap=argparse.ArgumentParser(); sub=ap.add_subparsers(dest='cmd',required=True) + p=sub.add_parser('from-fiam');p.add_argument('model',type=Path);p.add_argument('-o','--output',type=Path,required=True);p.add_argument('--source-id',required=True);p.add_argument('--source-kind',default='fiam-model');p.add_argument('--source-ref');p.add_argument('--mode',choices=['incremental','complete-snapshot','declared-snapshot'],default='declared-snapshot');p.add_argument('--observation-scope');p.add_argument('--population-id');p.add_argument('--population-json');p.add_argument('--domain',action='append',dest='domains');p.add_argument('--snapshot-time');p.add_argument('--authority-policy-id');p.add_argument('--format',choices=['yaml','json','ndjson'],default='yaml') + p=sub.add_parser('convert');p.add_argument('input',type=Path);p.add_argument('-o','--output',type=Path,required=True);p.add_argument('--input-format',choices=['yaml','json','ndjson'],required=True);p.add_argument('--format',choices=['yaml','json','ndjson'],required=True) + a=ap.parse_args() + if a.cmd=='from-fiam': + pop=json.loads(a.population_json) if a.population_json else {}; ex=from_fiam(a.model,a.source_id,a.source_kind,a.source_ref,a.mode,a.observation_scope,a.population_id,pop,a.domains,a.snapshot_time,a.authority_policy_id);write(ex,a.output,a.format) + else: + ex=read_ndjson(a.input) if a.input_format=='ndjson' else (json.loads(a.input.read_text()) if a.input_format=='json' else yaml.safe_load(a.input.read_text()));write(ex,a.output,a.format) +if __name__=='__main__': main() diff --git a/history/FIAM_v0.2_Draft6/tools/catalog_index.py b/history/FIAM_v0.2_Draft6/tools/catalog_index.py new file mode 100755 index 0000000..fb1c1bf --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/catalog_index.py @@ -0,0 +1,381 @@ +#!/usr/bin/env python3 +"""FIAM v0.2-draft.6 rebuildable architecture-intelligence index. + +Core rules: +- Catalog Exchange is the operational ingest contract. +- Runtime observations are scope-owned; logical architecture unions scopes. +- Complete snapshots require an explicit Snapshot Authority Policy. +- Scores are never stored: raw evidence is indexed and scored by query policy. +- Purge affects only the derived index, never exchange/source artifacts. +""" +from __future__ import annotations +import argparse, hashlib, json, sqlite3 +from datetime import datetime, timezone +from pathlib import Path +import yaml +from catalog_exchange import from_fiam, read_ndjson + +ROOT=Path(__file__).resolve().parents[1] +DEFAULT_AUTH=ROOT/'policies/SNAPSHOT-AUTHORITY-v0.2.yaml' +ENTITY_SECTIONS=['participants','nodes','ports','contracts','endpoints','bindings','channels','information_resources','information_shapes','interactions','interaction_flows','artifacts','zones','security'] +DECLARATION_RELATIONS={'fiam.relation.uses','fiam.relation.client-of','fiam.relation.reads-from','fiam.relation.writes-to','fiam.relation.targets','fiam.relation.appends-to','fiam.relation.watches'} + +def utcnow(): return datetime.now(timezone.utc).isoformat().replace('+00:00','Z') +def digest(*parts,n=24): return hashlib.sha256('\x1f'.join('' if x is None else str(x) for x in parts).encode()).hexdigest()[:n] +def j(v): return json.dumps(v,sort_keys=True,separators=(',',':')) +def parse_dt(v): return datetime.fromisoformat(str(v).replace('Z','+00:00')) if v else None +def load_yaml(p): return yaml.safe_load(Path(p).read_text()) +def exchange_hash(ex): return hashlib.sha256(json.dumps(ex,sort_keys=True,separators=(',',':')).encode()).hexdigest() + +def evidence_records(a): + e=a.get('evidence') + if isinstance(e,dict): return [e] + if isinstance(e,list): return [x for x in e if isinstance(x,dict)] + return [] + +def schema(c): + c.executescript(''' + PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON; + CREATE TABLE IF NOT EXISTS meta(key TEXT PRIMARY KEY,value TEXT NOT NULL); + CREATE TABLE IF NOT EXISTS exchange_documents( + exchange_id TEXT PRIMARY KEY, exchange_version TEXT NOT NULL, source_id TEXT NOT NULL, + source_kind TEXT, source_ref TEXT, observation_scope TEXT, population_id TEXT, + mode TEXT NOT NULL, domains_json TEXT NOT NULL, snapshot_time TEXT NOT NULL, + content_hash TEXT NOT NULL, authority_policy_id TEXT, ingested_at TEXT NOT NULL); + CREATE INDEX IF NOT EXISTS idx_exchange_population_time ON exchange_documents(population_id,snapshot_time); + CREATE TABLE IF NOT EXISTS observation_scopes( + observation_scope TEXT PRIMARY KEY, population_id TEXT NOT NULL, source_id TEXT NOT NULL, + domains_json TEXT NOT NULL, authority_policy_id TEXT, first_exchange_id TEXT NOT NULL); + CREATE TABLE IF NOT EXISTS entities( + entity_id TEXT PRIMARY KEY, kind TEXT NOT NULL, name TEXT, preferred_id TEXT NOT NULL, + json TEXT NOT NULL, last_exchange_id TEXT NOT NULL); + CREATE INDEX IF NOT EXISTS idx_entities_kind ON entities(kind); + CREATE INDEX IF NOT EXISTS idx_entities_preferred ON entities(preferred_id); + CREATE TABLE IF NOT EXISTS entity_versions( + entity_id TEXT NOT NULL, exchange_id TEXT NOT NULL, snapshot_time TEXT NOT NULL, + kind TEXT NOT NULL, name TEXT, preferred_id TEXT NOT NULL, json TEXT NOT NULL, + PRIMARY KEY(entity_id,exchange_id)); + CREATE INDEX IF NOT EXISTS idx_entity_versions_time ON entity_versions(snapshot_time,entity_id); + CREATE TABLE IF NOT EXISTS declared_entities( + entity_id TEXT NOT NULL, exchange_id TEXT NOT NULL, source_id TEXT NOT NULL, + population_id TEXT, snapshot_time TEXT NOT NULL, PRIMARY KEY(entity_id,exchange_id)); + CREATE TABLE IF NOT EXISTS zone_members( + zone_id TEXT NOT NULL, member_id TEXT NOT NULL, zone_type TEXT, derived INTEGER NOT NULL DEFAULT 0, + exchange_id TEXT NOT NULL, snapshot_time TEXT NOT NULL, PRIMARY KEY(zone_id,member_id,exchange_id)); + CREATE INDEX IF NOT EXISTS idx_zone_member_time ON zone_members(member_id,zone_type,snapshot_time); + CREATE TABLE IF NOT EXISTS assertions( + assertion_id TEXT NOT NULL, exchange_id TEXT NOT NULL, snapshot_time TEXT NOT NULL, + assertion_kind TEXT NOT NULL, subject TEXT NOT NULL, predicate TEXT NOT NULL, + polarity TEXT NOT NULL, object_ref TEXT, value_json TEXT, valid_from TEXT, + valid_until TEXT, observed_at TEXT, json TEXT NOT NULL, + PRIMARY KEY(assertion_id,exchange_id)); + CREATE INDEX IF NOT EXISTS idx_assertions_subject_pred ON assertions(subject,predicate,snapshot_time); + CREATE TABLE IF NOT EXISTS evidence( + assertion_id TEXT NOT NULL, exchange_id TEXT NOT NULL, idx INTEGER NOT NULL, + mode TEXT, source_type TEXT, source_ref TEXT, locator TEXT, confidence REAL, + stance TEXT, observed_at TEXT, observer TEXT, json TEXT NOT NULL, + PRIMARY KEY(assertion_id,exchange_id,idx)); + CREATE INDEX IF NOT EXISTS idx_evidence_observed ON evidence(observed_at,mode); + CREATE TABLE IF NOT EXISTS working_identity( + observed_ref TEXT NOT NULL, preferred_ref TEXT NOT NULL, relation TEXT NOT NULL, + exchange_id TEXT NOT NULL, snapshot_time TEXT NOT NULL, + PRIMARY KEY(observed_ref,exchange_id)); + CREATE TABLE IF NOT EXISTS declarations( + declaration_id TEXT NOT NULL, exchange_id TEXT NOT NULL, source_id TEXT NOT NULL, + population_id TEXT, snapshot_time TEXT NOT NULL, subject_ref TEXT NOT NULL, + subject_owner TEXT, predicate TEXT NOT NULL, object_ref TEXT NOT NULL, + object_owner TEXT, object_kind TEXT, PRIMARY KEY(declaration_id,exchange_id)); + CREATE INDEX IF NOT EXISTS idx_declarations_time ON declarations(population_id,snapshot_time,subject_owner,object_ref); + CREATE TABLE IF NOT EXISTS runtime_aggregates( + observation_key TEXT PRIMARY KEY, observation_scope TEXT NOT NULL, population_id TEXT NOT NULL, + source_id TEXT NOT NULL, aggregate_id TEXT NOT NULL, domain TEXT NOT NULL, role TEXT, + operation_ref TEXT, binding_ref TEXT, local_node TEXT, remote_node TEXT, channel_ref TEXT, + resource_ref TEXT, count INTEGER NOT NULL, error_count INTEGER NOT NULL, + first_seen TEXT, last_seen TEXT, last_exchange_id TEXT NOT NULL, json TEXT NOT NULL); + CREATE INDEX IF NOT EXISTS idx_runtime_agg_operation ON runtime_aggregates(population_id,operation_ref,last_seen); + CREATE TABLE IF NOT EXISTS topology_observations_current( + observation_key TEXT PRIMARY KEY, edge_key TEXT NOT NULL, observation_scope TEXT NOT NULL, + population_id TEXT NOT NULL, source_id TEXT NOT NULL, domain TEXT NOT NULL, kind TEXT NOT NULL, + from_ref TEXT NOT NULL, target_ref TEXT NOT NULL, target_kind TEXT NOT NULL, channel_ref TEXT, + binding_ref TEXT, operation_ref TEXT, via_gateway INTEGER NOT NULL DEFAULT 0, gateway_ref TEXT, + intended_target TEXT, first_seen TEXT, last_seen TEXT, count INTEGER NOT NULL DEFAULT 0, + active INTEGER NOT NULL DEFAULT 1, absence_streak INTEGER NOT NULL DEFAULT 0, + valid_from TEXT NOT NULL, closed_at TEXT, last_exchange_id TEXT NOT NULL, json TEXT NOT NULL); + CREATE INDEX IF NOT EXISTS idx_obs_topology_scope ON topology_observations_current(observation_scope,domain,active); + CREATE INDEX IF NOT EXISTS idx_obs_topology_edge ON topology_observations_current(population_id,edge_key,active); + CREATE TABLE IF NOT EXISTS topology_observation_intervals( + interval_id TEXT PRIMARY KEY, observation_key TEXT NOT NULL, edge_key TEXT NOT NULL, + observation_scope TEXT NOT NULL, population_id TEXT NOT NULL, source_id TEXT NOT NULL, + domain TEXT NOT NULL, kind TEXT NOT NULL, from_ref TEXT NOT NULL, target_ref TEXT NOT NULL, + target_kind TEXT NOT NULL, channel_ref TEXT, valid_from TEXT NOT NULL, closed_at TEXT, + first_seen TEXT, last_seen TEXT, count INTEGER NOT NULL DEFAULT 0, close_reason TEXT, + opened_exchange_id TEXT NOT NULL, closed_exchange_id TEXT); + CREATE INDEX IF NOT EXISTS idx_obs_intervals_window ON topology_observation_intervals(population_id,valid_from,closed_at); + CREATE TABLE IF NOT EXISTS logical_topology_current( + logical_key TEXT PRIMARY KEY, population_id TEXT NOT NULL, edge_key TEXT NOT NULL, + domain TEXT NOT NULL, kind TEXT NOT NULL, from_ref TEXT NOT NULL, target_ref TEXT NOT NULL, + target_kind TEXT NOT NULL, channel_ref TEXT, binding_ref TEXT, operation_ref TEXT, + via_gateway INTEGER NOT NULL DEFAULT 0, gateway_ref TEXT, intended_target TEXT, + first_seen TEXT, last_seen TEXT, observation_count INTEGER NOT NULL DEFAULT 0, + active INTEGER NOT NULL DEFAULT 1, valid_from TEXT NOT NULL, closed_at TEXT, + active_scopes_json TEXT NOT NULL, last_exchange_id TEXT NOT NULL); + CREATE INDEX IF NOT EXISTS idx_logical_current_population ON logical_topology_current(population_id,active); + CREATE TABLE IF NOT EXISTS logical_topology_intervals( + interval_id TEXT PRIMARY KEY, logical_key TEXT NOT NULL, population_id TEXT NOT NULL, + edge_key TEXT NOT NULL, domain TEXT NOT NULL, kind TEXT NOT NULL, from_ref TEXT NOT NULL, + target_ref TEXT NOT NULL, target_kind TEXT NOT NULL, channel_ref TEXT, valid_from TEXT NOT NULL, + closed_at TEXT, first_seen TEXT, last_seen TEXT, observation_count INTEGER NOT NULL DEFAULT 0, + close_reason TEXT, opened_exchange_id TEXT NOT NULL, closed_exchange_id TEXT); + CREATE INDEX IF NOT EXISTS idx_logical_intervals_window ON logical_topology_intervals(population_id,valid_from,closed_at); + CREATE TABLE IF NOT EXISTS unresolved( + unresolved_id TEXT NOT NULL, exchange_id TEXT NOT NULL, observation_scope TEXT, + population_id TEXT, domain TEXT, reason TEXT, json TEXT NOT NULL, + PRIMARY KEY(unresolved_id,exchange_id)); + CREATE TABLE IF NOT EXISTS reconciliation_candidates( + observed_ref TEXT NOT NULL, exchange_id TEXT NOT NULL, population_id TEXT, + entity_kind TEXT, status TEXT NOT NULL, json TEXT NOT NULL, + PRIMARY KEY(observed_ref,exchange_id)); + ''') + c.execute("INSERT OR REPLACE INTO meta(key,value) VALUES('schema_version','0.2-draft.6')") + +def exchange_entity_index(ex): + idx={}; kinds={}; op_contract={} + for r in ex['records'].get('entities',[]) or []: + sec=r.get('section'); x=r.get('entity') or {} + if not x.get('id'): continue + kind=x.get('kind') or ('security-profile' if sec=='security' else (sec[:-1] if sec and sec.endswith('s') else sec)) + idx[x['id']]=x;kinds[x['id']]=kind + if sec=='contracts': + for op in x.get('operations',[]) or []: + if isinstance(op,dict) and op.get('id'): + idx[op['id']]=op;kinds[op['id']]='operation';op_contract[op['id']]=x['id'] + return idx,kinds,op_contract + +def owner_node(ref,idx,kinds,op_contract): + seen=set() + def r(x): + if not x or x in seen:return None + seen.add(x);kind=kinds.get(x);obj=idx.get(x) or {} + if kind=='system-node':return x + if kind=='port':return r(obj.get('owner')) + if kind=='binding':return r(obj.get('provider_port')) or (r((obj.get('consumer_ports') or [None])[0])) + if kind in ('information-resource','channel'):return r(obj.get('owner')) + if kind=='operation':return r(op_contract.get(x)) + if kind=='interface-contract': + offers=[] + for p in idx.values(): + if not isinstance(p,dict) or p.get('kind')!='port':continue + for part in p.get('participations',[]) or []: + if part.get('contract')==x and part.get('mode')=='offers':offers.append(p.get('owner')) + offers={v for v in offers if v};return next(iter(offers)) if len(offers)==1 else None + if kind=='endpoint': + owners=set() + for b in idx.values(): + if isinstance(b,dict) and b.get('kind')=='binding' and x in (b.get('endpoints') or []): + o=r(b.get('id')) + if o:owners.add(o) + return next(iter(owners)) if len(owners)==1 else None + return None + return r(ref) + +def existing_declared(c): return {r[0] for r in c.execute('SELECT DISTINCT entity_id FROM declared_entities')} +def latest_preferred(c): + out={} + for r in c.execute('SELECT observed_ref,preferred_ref,snapshot_time FROM working_identity ORDER BY snapshot_time'): + out[r[0]]=r[1] + return out + +def preferred_map(ex,c,idx): + declared=set(ex['records'].get('declared_entity_ids') or []) | existing_declared(c); out={x:x for x in idx}; out.update({k:v for k,v in latest_preferred(c).items() if k not in out or out[k]==k}) + cand={} + for a in ex['records'].get('assertions',[]) or []: + if a.get('assertion_kind')!='relation' or a.get('polarity')!='asserted' or a.get('predicate') not in ('fiam.relation.same-entity-as','fiam.relation.corresponds-to'):continue + s,o=a.get('subject'),a.get('object_ref') + if o in declared:cand.setdefault(s,set()).add(o) + if s in declared:cand.setdefault(o,set()).add(s) + for obs,vals in cand.items(): + if len(vals)==1:out[obs]=next(iter(vals)) + return out + +def pref(ref,pmap): return pmap.get(ref,ref) if ref else ref + +def validate_authority(ex,policy,c): + obs=ex['observation']; source=ex['source']['source_id']; mode=obs['mode']; scope=obs.get('observation_scope'); pop=obs.get('population_id'); domains=set(obs.get('domains') or []) + if mode!='complete-snapshot': return None + if not policy: raise ValueError('complete-snapshot requires --authority-policy') + cfg=(policy.get('sources') or {}).get(source) + if not cfg or not cfg.get('authoritative'): raise ValueError(f'{source} is not an authoritative source') + if cfg.get('observation_scope')!=scope or cfg.get('population_id')!=pop: raise ValueError('complete-snapshot scope/population does not match authority grant') + if not domains or not domains.issubset(set(cfg.get('domains') or [])): raise ValueError('complete-snapshot domains exceed authority grant') + pid=obs.get('authority_policy_id') + if pid and pid!=policy.get('id'): raise ValueError('authority_policy_id mismatch') + old=c.execute('SELECT source_id FROM observation_scopes WHERE observation_scope=?',(scope,)).fetchone() + if old and old[0]!=source: + layered={x.get('observation_scope'):x.get('precedence',[]) for x in policy.get('layered_scopes') or []} + prec=layered.get(scope) or [] + if source not in prec or old[0] not in prec: raise ValueError(f'observation_scope {scope} already owned by {old[0]}') + if prec[0]!=source: raise ValueError(f'only highest-precedence source may close layered scope {scope}') + return {'grace_hours':float(cfg.get('grace_hours', (policy.get('defaults') or {}).get('grace_hours',0))), 'absence_snapshots':int(cfg.get('absence_snapshots',(policy.get('defaults') or {}).get('absence_snapshots',1)))} + +def register_scope(ex,c): + obs=ex['observation'];scope=obs.get('observation_scope') + if not scope:return + source=ex['source']['source_id'];pop=obs.get('population_id');domains=j(sorted(obs.get('domains') or []));pid=obs.get('authority_policy_id') + old=c.execute('SELECT source_id,population_id FROM observation_scopes WHERE observation_scope=?',(scope,)).fetchone() + if old and (old[0]!=source or old[1]!=pop): + # Authority overlap is validated separately; incremental mixed ownership is still unsafe. + raise ValueError(f'observation_scope {scope} already registered to {old[0]}/{old[1]}') + c.execute('INSERT OR IGNORE INTO observation_scopes VALUES(?,?,?,?,?,?)',(scope,pop,source,domains,pid,ex['exchange_id'])) + +def topology_record(t,pmap,pop): + fr=pref(t.get('from'),pmap) + if t.get('to'): + target=pref(t.get('intended_target') or t.get('to'),pmap);tk='node' + elif t.get('to_resource'): + target=pref(t.get('to_resource'),pmap);tk='resource' + elif t.get('via_channel'): + target=pref(t.get('via_channel'),pmap);tk='channel' + else:return None + ch=pref(t.get('via_channel'),pmap) + edge='edge.'+digest(t.get('domain'),t.get('kind'),fr,target,ch) + return {'edge_key':edge,'population_id':pop,'domain':t.get('domain') or 'unknown','kind':t.get('kind') or 'unknown','from_ref':fr,'target_ref':target,'target_kind':tk,'channel_ref':ch,'binding_ref':pref(t.get('binding'),pmap),'operation_ref':pref(t.get('operation'),pmap),'via_gateway':1 if t.get('via_gateway') else 0,'gateway_ref':pref(t.get('gateway'),pmap),'intended_target':pref(t.get('intended_target'),pmap),'first_seen':t.get('first_seen'),'last_seen':t.get('last_seen'),'count':int(t.get('count') or 0),'json':j(t)} + +def refresh_logical(c,pop,edge,snapshot_time,exchange_id): + active=c.execute('SELECT * FROM topology_observations_current WHERE population_id=? AND edge_key=? AND active=1',(pop,edge)).fetchall();lk='logical.'+digest(pop,edge) + old=c.execute('SELECT * FROM logical_topology_current WHERE logical_key=?',(lk,)).fetchone() + if active: + a=active[0]; first=min([x['first_seen'] or x['valid_from'] for x in active]); last=max([x['last_seen'] or x['valid_from'] for x in active]); count=max(int(x['count'] or 0) for x in active); scopes=sorted({x['observation_scope'] for x in active}) + vg=1 if any(x['via_gateway'] for x in active) else 0;gw=next((x['gateway_ref'] for x in active if x['gateway_ref']),None);it=next((x['intended_target'] for x in active if x['intended_target']),None) + if old and old['active']: + c.execute('UPDATE logical_topology_current SET first_seen=?,last_seen=?,observation_count=?,active_scopes_json=?,via_gateway=?,gateway_ref=?,intended_target=?,last_exchange_id=? WHERE logical_key=?',(min(old['first_seen'] or first,first),max(old['last_seen'] or last,last),max(int(old['observation_count'] or 0),count),j(scopes),vg,gw,it,exchange_id,lk)) + c.execute('UPDATE logical_topology_intervals SET first_seen=?,last_seen=?,observation_count=? WHERE logical_key=? AND closed_at IS NULL',(first,last,count,lk)) + else: + vf=min(x['valid_from'] for x in active) + c.execute('''INSERT OR REPLACE INTO logical_topology_current(logical_key,population_id,edge_key,domain,kind,from_ref,target_ref,target_kind,channel_ref,binding_ref,operation_ref,via_gateway,gateway_ref,intended_target,first_seen,last_seen,observation_count,active,valid_from,closed_at,active_scopes_json,last_exchange_id) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,1,?,NULL,?,?)''',(lk,pop,edge,a['domain'],a['kind'],a['from_ref'],a['target_ref'],a['target_kind'],a['channel_ref'],a['binding_ref'],a['operation_ref'],vg,gw,it,first,last,count,vf,j(scopes),exchange_id)) + iid='logical-interval.'+digest(lk,vf,exchange_id);c.execute('INSERT INTO logical_topology_intervals VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)',(iid,lk,pop,edge,a['domain'],a['kind'],a['from_ref'],a['target_ref'],a['target_kind'],a['channel_ref'],vf,None,first,last,count,None,exchange_id,None)) + elif old and old['active']: + c.execute('UPDATE logical_topology_current SET active=0,closed_at=?,active_scopes_json=?,last_exchange_id=? WHERE logical_key=?',(snapshot_time,'[]',exchange_id,lk)) + c.execute('UPDATE logical_topology_intervals SET closed_at=?,close_reason=?,closed_exchange_id=? WHERE logical_key=? AND closed_at IS NULL',(snapshot_time,'all-observation-scopes-closed',exchange_id,lk)) + +def ingest_exchange(db,ex,authority_policy=None): + ch=exchange_hash(ex);eid=ex['exchange_id'];obs=ex['observation'];source=ex['source']['source_id'];snap=obs['snapshot_time'];scope=obs.get('observation_scope');pop=obs.get('population_id');mode=obs['mode'];sem=obs.get('aggregate_semantics','cumulative') + c=sqlite3.connect(db);c.row_factory=sqlite3.Row;schema(c) + if c.execute('SELECT 1 FROM exchange_documents WHERE exchange_id=?',(eid,)).fetchone():c.close();return {'status':'already-indexed','exchange_id':eid} + close_cfg=validate_authority(ex,authority_policy,c);register_scope(ex,c) + c.execute('INSERT INTO exchange_documents VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?)',(eid,ex['catalog_exchange_version'],source,ex['source'].get('source_kind'),ex['source'].get('source_ref'),scope,pop,mode,j(sorted(obs.get('domains') or [])),snap,ch,obs.get('authority_policy_id'),utcnow())) + idx,kinds,op_contract=exchange_entity_index(ex);pmap=preferred_map(ex,c,idx);declared=set(ex['records'].get('declared_entity_ids') or []) + if mode=='declared-snapshot' and not declared:declared|=set(idx) + for rid in declared:c.execute('INSERT OR IGNORE INTO declared_entities VALUES(?,?,?,?,?)',(rid,eid,source,pop,snap)) + for rid,obj in idx.items(): + kind=kinds[rid];name=obj.get('name') or obj.get('title');pr=pref(rid,pmap) + c.execute('INSERT INTO entities VALUES(?,?,?,?,?,?) ON CONFLICT(entity_id) DO UPDATE SET kind=excluded.kind,name=COALESCE(excluded.name,entities.name),preferred_id=excluded.preferred_id,json=excluded.json,last_exchange_id=excluded.last_exchange_id',(rid,kind,name,pr,j(obj),eid)) + c.execute('INSERT OR REPLACE INTO entity_versions VALUES(?,?,?,?,?,?,?)',(rid,eid,snap,kind,name,pr,j(obj))) + for z in ex['records'].get('zone_memberships',[]) or []:c.execute('INSERT OR IGNORE INTO zone_members VALUES(?,?,?,?,?,?)',(z['zone_id'],pref(z['member_id'],pmap),z.get('zone_type'),1 if z.get('derived') else 0,eid,snap)) + # Raw assertions and evidence only: scores are query-time policy projections. + for a in ex['records'].get('assertions',[]) or []: + vt=a.get('valid_time') or {};val=j(a.get('value')) if 'value' in a else None;sub=pref(a.get('subject'),pmap);obj=pref(a.get('object_ref'),pmap) + c.execute('INSERT OR REPLACE INTO assertions VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?)',(a['id'],eid,snap,a.get('assertion_kind'),sub,a.get('predicate'),a.get('polarity'),obj,val,vt.get('valid_from'),vt.get('valid_until'),vt.get('observed_at'),j(a))) + for n,e in enumerate(evidence_records(a)): + s=e.get('source');st=s.get('type') if isinstance(s,dict) else ('entity-ref' if isinstance(s,str) else None);sr=s.get('ref') if isinstance(s,dict) else s;loc=s.get('locator') if isinstance(s,dict) else None + c.execute('INSERT OR REPLACE INTO evidence VALUES(?,?,?,?,?,?,?,?,?,?,?,?)',(a['id'],eid,n,e.get('mode'),st,sr,loc,e.get('confidence'),e.get('stance'),e.get('observed_at'),e.get('observer'),j(e))) + if a.get('assertion_kind')=='relation' and a.get('polarity')=='asserted' and a.get('predicate') in ('fiam.relation.same-entity-as','fiam.relation.corresponds-to'): + s,o=a.get('subject'),a.get('object_ref');pr=pmap.get(s) + if pr and pr!=s:c.execute('INSERT OR REPLACE INTO working_identity VALUES(?,?,?,?,?)',(s,pr,a.get('predicate'),eid,snap)) + # Declaration inventory is generic over relation target kind, not node-only uses. + is_decl = mode=='declared-snapshot' or (a.get('subject') in declared and a.get('object_ref') in declared) + if is_decl and a.get('assertion_kind')=='relation' and a.get('polarity')=='asserted' and a.get('predicate') in DECLARATION_RELATIONS and a.get('object_ref'): + sr=pref(a['subject'],pmap);or_=pref(a['object_ref'],pmap);so=owner_node(a['subject'],idx,kinds,op_contract) or sr;oo=owner_node(a['object_ref'],idx,kinds,op_contract) or or_ + c.execute('INSERT OR REPLACE INTO declarations VALUES(?,?,?,?,?,?,?,?,?,?,?)',(a['id'],eid,source,pop,snap,sr,pref(so,pmap),a.get('predicate'),or_,pref(oo,pmap),kinds.get(a.get('object_ref')))) + # Runtime aggregates allow coverage/dormancy without retaining spans. + for a in ex['records'].get('runtime_aggregates',[]) or []: + if not scope or not pop:continue + key='aggobs.'+digest(scope,a.get('id'));old=c.execute('SELECT * FROM runtime_aggregates WHERE observation_key=?',(key,)).fetchone();cnt=int(a.get('count') or 0);err=int(a.get('error_count') or 0) + if old: + nc=max(old['count'],cnt) if sem=='cumulative' else old['count']+cnt;ne=max(old['error_count'],err) if sem=='cumulative' else old['error_count']+err;fs=min(filter(None,[old['first_seen'],a.get('first_seen')])) if old['first_seen'] or a.get('first_seen') else None;ls=max(filter(None,[old['last_seen'],a.get('last_seen')])) if old['last_seen'] or a.get('last_seen') else None + c.execute('UPDATE runtime_aggregates SET count=?,error_count=?,first_seen=?,last_seen=?,last_exchange_id=?,json=? WHERE observation_key=?',(nc,ne,fs,ls,eid,j(a),key)) + else: + c.execute('INSERT INTO runtime_aggregates VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)',(key,scope,pop,source,a.get('id'),a.get('domain'),a.get('role'),pref(a.get('operation'),pmap),pref(a.get('binding'),pmap),pref(a.get('local_node'),pmap),pref(a.get('remote_node'),pmap),pref(a.get('channel'),pmap),pref(a.get('resource'),pmap),cnt,err,a.get('first_seen'),a.get('last_seen'),eid,j(a))) + seen=set();affected=set() + for t in ex['records'].get('topology_observations',[]) or []: + if not scope or not pop:continue + r=topology_record(t,pmap,pop) + if not r:continue + ok='obs.'+digest(scope,r['edge_key']);seen.add(ok);affected.add(r['edge_key']);old=c.execute('SELECT * FROM topology_observations_current WHERE observation_key=?',(ok,)).fetchone();vf=r['first_seen'] or snap;ls=r['last_seen'] or snap + if old and old['active']: + cnt=max(old['count'],r['count']) if sem=='cumulative' else old['count']+r['count'];first=min(filter(None,[old['first_seen'],r['first_seen']])) if old['first_seen'] or r['first_seen'] else vf;last=max(filter(None,[old['last_seen'],ls])) + c.execute('UPDATE topology_observations_current SET first_seen=?,last_seen=?,count=?,absence_streak=0,last_exchange_id=?,json=?,via_gateway=?,gateway_ref=?,intended_target=? WHERE observation_key=?',(first,last,cnt,eid,r['json'],r['via_gateway'],r['gateway_ref'],r['intended_target'],ok)) + c.execute('UPDATE topology_observation_intervals SET first_seen=?,last_seen=?,count=? WHERE observation_key=? AND closed_at IS NULL',(first,last,cnt,ok)) + else: + c.execute('''INSERT OR REPLACE INTO topology_observations_current(observation_key,edge_key,observation_scope,population_id,source_id,domain,kind,from_ref,target_ref,target_kind,channel_ref,binding_ref,operation_ref,via_gateway,gateway_ref,intended_target,first_seen,last_seen,count,active,absence_streak,valid_from,closed_at,last_exchange_id,json) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,1,0,?,NULL,?,?)''',(ok,r['edge_key'],scope,pop,source,r['domain'],r['kind'],r['from_ref'],r['target_ref'],r['target_kind'],r['channel_ref'],r['binding_ref'],r['operation_ref'],r['via_gateway'],r['gateway_ref'],r['intended_target'],r['first_seen'],ls,r['count'],vf,eid,r['json'])) + iid='obs-interval.'+digest(ok,vf,eid);c.execute('INSERT INTO topology_observation_intervals VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)',(iid,ok,r['edge_key'],scope,pop,source,r['domain'],r['kind'],r['from_ref'],r['target_ref'],r['target_kind'],r['channel_ref'],vf,None,r['first_seen'],ls,r['count'],None,eid,None)) + # Completeness applies only to the authorized scope and covered domains. + if mode=='complete-snapshot': + domains=set(obs.get('domains') or []);now=parse_dt(snap);rows=c.execute('SELECT * FROM topology_observations_current WHERE observation_scope=? AND active=1',(scope,)).fetchall() + for row in rows: + if row['domain'] not in domains or row['observation_key'] in seen:continue + streak=int(row['absence_streak'])+1;last=parse_dt(row['last_seen'] or row['valid_from']);age=(now-last).total_seconds()/3600 if last else 1e9 + if streak>=close_cfg['absence_snapshots'] and age>=close_cfg['grace_hours']: + c.execute('UPDATE topology_observations_current SET active=0,absence_streak=?,closed_at=?,last_exchange_id=? WHERE observation_key=?',(streak,snap,eid,row['observation_key'])) + c.execute('UPDATE topology_observation_intervals SET closed_at=?,close_reason=?,closed_exchange_id=? WHERE observation_key=? AND closed_at IS NULL',(snap,'confirmed-absent-from-authoritative-scope',eid,row['observation_key']));affected.add(row['edge_key']) + else:c.execute('UPDATE topology_observations_current SET absence_streak=?,last_exchange_id=? WHERE observation_key=?',(streak,eid,row['observation_key'])) + for edge in affected:refresh_logical(c,pop,edge,snap,eid) + for u in ex['records'].get('unresolved',[]) or []:c.execute('INSERT OR REPLACE INTO unresolved VALUES(?,?,?,?,?,?,?)',(u['id'],eid,scope,pop,u.get('domain'),u.get('reason'),j(u))) + for x in ex['records'].get('reconciliation_candidates',[]) or []:c.execute('INSERT OR REPLACE INTO reconciliation_candidates VALUES(?,?,?,?,?,?)',(x['observed_ref'],eid,pop,x.get('entity_kind'),x.get('status'),j(x))) + c.commit();stats={'status':'indexed','exchange_id':eid,'mode':mode,'observation_scope':scope,'population_id':pop,'entities':len(idx),'assertions':len(ex['records'].get('assertions') or []),'topology_observations':len(seen)};c.close();return stats + +def read_exchange(path,fmt=None): + p=Path(path);fmt=fmt or ('ndjson' if p.suffix=='.ndjson' else 'json' if p.suffix=='.json' else 'yaml') + if fmt=='ndjson':return read_ndjson(p) + if fmt=='json':return json.loads(p.read_text()) + return yaml.safe_load(p.read_text()) + +def stats(db): + c=sqlite3.connect(db);c.row_factory=sqlite3.Row;schema(c);out={} + for t in ['exchange_documents','entities','entity_versions','assertions','evidence','declarations','runtime_aggregates','topology_observations_current','topology_observation_intervals','logical_topology_current','logical_topology_intervals']: + out[t]=c.execute(f'SELECT COUNT(*) c FROM {t}').fetchone()['c'] + out['active_observations']=c.execute('SELECT COUNT(*) c FROM topology_observations_current WHERE active=1').fetchone()['c'];out['active_logical_topology']=c.execute('SELECT COUNT(*) c FROM logical_topology_current WHERE active=1').fetchone()['c'];c.close();return out + +def export_exchange(db,scope,out): + c=sqlite3.connect(db);c.row_factory=sqlite3.Row;schema(c);sc=c.execute('SELECT * FROM observation_scopes WHERE observation_scope=?',(scope,)).fetchone() + if not sc:raise ValueError('unknown observation scope') + latest=c.execute('SELECT * FROM exchange_documents WHERE observation_scope=? ORDER BY snapshot_time DESC LIMIT 1',(scope,)).fetchone();snap=latest['snapshot_time'] if latest else utcnow() + ents=[{'section':'indexed','entity':json.loads(r['json'])} for r in c.execute('SELECT * FROM entities ORDER BY entity_id')] + ass=[json.loads(r['json']) for r in c.execute('SELECT a.* FROM assertions a JOIN (SELECT assertion_id,MAX(snapshot_time) mt FROM assertions GROUP BY assertion_id) q ON a.assertion_id=q.assertion_id AND a.snapshot_time=q.mt ORDER BY a.assertion_id')] + zm=[{'zone_id':r['zone_id'],'member_id':r['member_id'],'zone_type':r['zone_type'],'derived':bool(r['derived'])} for r in c.execute('SELECT z.* FROM zone_members z JOIN (SELECT zone_id,member_id,MAX(snapshot_time) mt FROM zone_members GROUP BY zone_id,member_id) q ON z.zone_id=q.zone_id AND z.member_id=q.member_id AND z.snapshot_time=q.mt ORDER BY z.zone_id,z.member_id')] + ag=[json.loads(r['json']) for r in c.execute('SELECT * FROM runtime_aggregates WHERE observation_scope=? ORDER BY aggregate_id',(scope,))] + tops=[json.loads(r['json']) for r in c.execute('SELECT * FROM topology_observations_current WHERE observation_scope=? AND active=1 ORDER BY edge_key',(scope,))] + ex={'catalog_exchange_version':'0.2','profile_id':'fiam.catalog-exchange.v0.2','exchange_id':'exchange.index-export.'+digest(scope,snap),'created_at':snap,'source':{'source_id':'fiam.index-export','source_kind':'index-checkpoint','source_ref':str(db),'content_hash':None},'observation':{'mode':'incremental','observation_scope':scope,'population_id':sc['population_id'],'population':{},'domains':json.loads(sc['domains_json']),'snapshot_time':snap,'aggregate_semantics':'cumulative'},'records':{'entities':ents,'assertions':ass,'zone_memberships':zm,'runtime_aggregates':ag,'topology_observations':tops,'unresolved':[],'reconciliation_candidates':[],'declared_entity_ids':[]}} + Path(out).write_text(yaml.safe_dump(ex,sort_keys=False,allow_unicode=True,width=120));c.close() + +def purge(db,before,confirm): + if not confirm:raise ValueError('purge requires --confirm-derived-index-only') + c=sqlite3.connect(db);schema(c);counts={} + # Closed topology history and historical versions may be purged; current rows remain. + for t,col in [('logical_topology_intervals','closed_at'),('topology_observation_intervals','closed_at')]: + cur=c.execute(f'DELETE FROM {t} WHERE {col} IS NOT NULL AND {col}1:conflicts.append({'subject':sub,'predicate':pred,'alternatives':[{'value':v,'assertion_id':s['assertion_id'],'support_score':s['support_score']} for v,s in vals]}) + # Evidence challenges on a single assertion remain visible even if no competing value exists. + challenged=[{'assertion_id':s['assertion_id'],'subject':s['subject'],'predicate':s['predicate'],'support_score':s['support_score'],'challenge_score':s['challenge_score'],'net_support':s['net_support']} for s in scored if s['challenge_score']>0] + cutoff=now-timedelta(days=a.stale_runtime_days);stale=[] + for s in scored: + ev=s.get('evidence_sources') or [];runtime=[e for e in ev if e.get('mode') in ('runtime-observed','fiam.evidence.runtime-observed')] + if not runtime:continue + # Get raw timestamps from index because scoring details intentionally stay compact. + er=c.execute('SELECT observed_at FROM evidence WHERE assertion_id=? AND observed_at IS NOT NULL ORDER BY observed_at DESC',(s['assertion_id'],)).fetchall();latest=max([dt(x[0]) for x in er],default=None) + if latest and latest=float(t.get('strong',.85)):return 'strong' + if v>=float(t.get('moderate',.60)):return 'moderate' + if v>=float(t.get('weak',.30)):return 'weak' + return 'very-weak' + +def score_assertion(a,policy,now=None): + now=now or datetime.now(timezone.utc) + grouped={} + details=[] + for e in evidence_records(a): + s=evidence_strength(e,policy,now); key=independence_key(e,policy) + # Multiple records from the same evidential source are corroboration only once. + old=grouped.get((e.get('stance','supports'),key),0.0) + grouped[(e.get('stance','supports'),key)]=max(old,s) + details.append({'stance':e.get('stance','supports'),'mode':e.get('mode'),'source_type':source_type(e),'source_ref':source_part(e,'ref'),'strength':round(s,6)}) + supports=combine([v for (stance,_),v in grouped.items() if stance=='supports']) + challenges=combine([v for (stance,_),v in grouped.items() if stance=='challenges']) + neutral=combine([v for (stance,_),v in grouped.items() if stance=='neutral']) + net=supports-challenges + return {'assertion_id':a.get('id'),'support_score':round(supports,6),'challenge_score':round(challenges,6),'neutral_score':round(neutral,6),'net_support':round(net,6),'support_class':classify(supports,policy),'evidence_sources':details} + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('model',type=Path);ap.add_argument('-p','--policy',type=Path,default=DEFAULT_POLICY);ap.add_argument('--at');ap.add_argument('-o','--output',type=Path) + args=ap.parse_args();model=yaml.safe_load(args.model.read_text());policy=yaml.safe_load(args.policy.read_text());now=parse_dt(args.at) if args.at else datetime.now(timezone.utc) + rows=[score_assertion(a,policy,now) for a in model.get('assertions',[]) or []] + out={'policy_id':policy['id'],'policy_sha256':hashlib.sha256(args.policy.read_bytes()).hexdigest(),'evaluated_at':now.isoformat().replace('+00:00','Z'),'assertions':rows} + text=yaml.safe_dump(out,sort_keys=False) + if args.output:args.output.write_text(text) + else:print(text,end='') +if __name__=='__main__':main() diff --git a/history/FIAM_v0.2_Draft6/tools/generate_estate_fixture.py b/history/FIAM_v0.2_Draft6/tools/generate_estate_fixture.py new file mode 100755 index 0000000..c4860bb --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/generate_estate_fixture.py @@ -0,0 +1,20 @@ +#!/usr/bin/env python3 +"""Generate deterministic high-volume OTLP/JSON fixtures for FIAM estate tests.""" +from __future__ import annotations +import argparse,json +from pathlib import Path + +def av(v): + if isinstance(v,bool):return {'boolValue':v} + if isinstance(v,int):return {'intValue':str(v)} + return {'stringValue':str(v)} +def attrs(d):return [{'key':k,'value':av(v)} for k,v in d.items()] +def main(): + ap=argparse.ArgumentParser();ap.add_argument('-o','--output',type=Path,required=True);ap.add_argument('--count',type=int,default=5000);ap.add_argument('--start-ns',type=int,default=1788937200000000000);args=ap.parse_args() + spans=[] + for i in range(args.count): + tr=f'{i+1:032x}'[-32:];sid=f'{i+1:016x}'[-16:];status=500 if i%100==0 else 200 + spans.append({'traceId':tr,'spanId':sid,'kind':2,'name':'GET /orders/{orderId}','startTimeUnixNano':str(args.start_ns+i*1_000_000),'endTimeUnixNano':str(args.start_ns+i*1_000_000+500_000),'attributes':attrs({'http.request.method':'GET','http.route':'/orders/{orderId}','url.path':f'/orders/{1000000+i}','url.scheme':'https','server.address':'orders.example.internal','server.port':443,'network.protocol.version':'2','http.response.status_code':status})}) + doc={'resourceSpans':[{'resource':{'attributes':attrs({'service.name':'orders-api','service.namespace':'commerce','deployment.environment.name':'production','k8s.cluster.name':'prod-eu1','k8s.namespace.name':'commerce'})},'scopeSpans':[{'scope':{'name':'fixture.http'},'spans':spans}]}]} + args.output.parent.mkdir(parents=True,exist_ok=True);args.output.write_text(json.dumps(doc,separators=(',',':'))) +if __name__=='__main__':main() diff --git a/history/FIAM_v0.2_Draft6/tools/generate_topology_snapshot.py b/history/FIAM_v0.2_Draft6/tools/generate_topology_snapshot.py new file mode 100755 index 0000000..f29fc2c --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/generate_topology_snapshot.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python3 +"""Generate a large low-detail FIAM topology snapshot for index conformance.""" +from __future__ import annotations +import argparse +from pathlib import Path +import yaml + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('-o','--output',type=Path,required=True);ap.add_argument('--count',type=int,default=5000);ap.add_argument('--time',required=True);ap.add_argument('--offset',type=int,default=0);args=ap.parse_args() + nodes=[{'id':'node.root','kind':'system-node','name':'root','node_type':'fiam.node-type.service'}] + topo=[] + for i in range(args.offset,args.offset+args.count): + nid=f'node.target.{i:06d}';nodes.append({'id':nid,'kind':'system-node','name':f'target-{i:06d}','node_type':'fiam.node-type.service'}) + topo.append({'id':f'topology.edge.{i:06d}','domain':'rpc','kind':'direct-call','from':'node.root','to':nid,'count':1,'first_seen':args.time,'last_seen':args.time,'correlation':'generated'}) + doc={'fiam_version':'0.2','instance':{'id':'model.index-scale','kind':'model','title':'Index scale fixture','status':'provisional'},'nodes':nodes,'extensions':{'org.fiam.catalog':{'version':'0.2-draft.6','processed_batches':['3'*64],'declared_entity_ids':[],'last_ingest_at':args.time,'runtime_policy':'aggregate-by-architectural-tuple','occurrence_retention':'none','sample_size':0},'org.fiam.runtime_aggregates':[],'org.fiam.runtime_topology_observations':topo,'org.fiam.runtime_unresolved':[],'org.fiam.reconciliation_candidates':[]}} + args.output.write_text(yaml.safe_dump(doc,sort_keys=False)) +if __name__=='__main__':main() diff --git a/history/FIAM_v0.2_Draft6/tools/identity_view.py b/history/FIAM_v0.2_Draft6/tools/identity_view.py new file mode 100755 index 0000000..9c666a3 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/identity_view.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +"""Render FIAM identity query semantics without destructively merging entities.""" +from __future__ import annotations +import argparse +from pathlib import Path +import yaml + +ROOT=Path(__file__).resolve().parents[1] +CANON=ROOT/'canon/FIAM-Canon-v0.2.yaml' + +def evidence_records(e): return e if isinstance(e,list) else ([e] if isinstance(e,dict) else []) + +def source_signature(r): + s=r.get('source') + if isinstance(s,dict): return (s.get('type'),s.get('ref'),s.get('locator')) + return ('source',str(s),None) + +def main(): + ap=argparse.ArgumentParser(description=__doc__); ap.add_argument('model',type=Path); ap.add_argument('-o','--output',type=Path) + args=ap.parse_args(); doc=yaml.safe_load(args.model.read_text()); canon=yaml.safe_load(CANON.read_text()) + policy=canon.get('semantic_policies',{}).get('identity_relations',{}) + threshold=float(policy.get('default_reconciliation_threshold',0.98)); need=int(policy.get('required_independent_signals_for_inferred_promotion',2)) + parent={} + def find(x): + parent.setdefault(x,x) + if parent[x]!=x: parent[x]=find(parent[x]) + return parent[x] + def union(x,y): + rx,ry=find(x),find(y) + if rx!=ry: parent[ry]=rx + same=[]; corr=[] + for x in doc.get('assertions',[]) or []: + if x.get('assertion_kind')!='relation' or x.get('polarity')!='asserted': continue + if x.get('predicate')=='fiam.relation.same-entity-as': + union(x['subject'],x['object_ref']); same.append(x) + elif x.get('predicate')=='fiam.relation.corresponds-to': corr.append(x) + members={} + for x in list(parent): members.setdefault(find(x),[]).append(x) + candidates=[] + for x in corr: + recs=evidence_records(x.get('evidence')) + inferred=[r for r in recs if r.get('mode')=='fiam.evidence.inferred' and float(r.get('confidence',0))>=threshold] + distinct=len({source_signature(r) for r in inferred}) + candidates.append({ + 'subject':x['subject'],'object_ref':x['object_ref'],'assertion_id':x.get('id'), + 'evidence_confidences':[r.get('confidence') for r in recs], + 'meets_default_inferred_signal_threshold': len(inferred)>=need and distinct>=need, + 'automatic_promotion':'never', + 'recommended_next_state':'governed identity review' if len(inferred)>=need and distinct>=need else 'remain corresponds-to' + }) + result={ + 'policy':{ + 'query_semantics':'Asserted same-entity-as defines query-time equivalence only; ids and evidence remain distinct.', + 'default_inferred_threshold':threshold,'required_independent_signals':need, + 'automatic_promotion':'disabled' + }, + 'equivalence_classes':[{'members':sorted(v),'merged':False} for v in members.values() if len(v)>1], + 'correspondence_candidates':candidates + } + text=yaml.safe_dump(result,sort_keys=False,allow_unicode=True,width=120) + if args.output: args.output.write_text(text,encoding='utf-8') + else: print(text,end='') +if __name__=='__main__': main() diff --git a/history/FIAM_v0.2_Draft6/tools/index_query.py b/history/FIAM_v0.2_Draft6/tools/index_query.py new file mode 100644 index 0000000..16cd250 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/index_query.py @@ -0,0 +1,33 @@ +from __future__ import annotations +import json + +def zone_memberships_as_of(conn,member,at,zone_type=None): + # latest membership state per zone/member before time; exchange snapshots are append evidence, + # so membership exists if it has ever been asserted by the latest applicable source. For + # deployment-derived memberships this is tied to the entity version/identity tuple. + q='SELECT zone_id,zone_type,derived,MAX(snapshot_time) mt FROM zone_members WHERE member_id=? AND snapshot_time<=?' + p=[member,at] + if zone_type:q+=' AND zone_type=?';p.append(zone_type) + q+=' GROUP BY zone_id,zone_type,derived' + return [{'zone_id':r[0],'zone_type':r[1],'derived':bool(r[2])} for r in conn.execute(q,p).fetchall()] + +def zones_by_type(conn,member,at): + out={} + for x in zone_memberships_as_of(conn,member,at):out.setdefault(x['zone_type'],[]).append(x['zone_id']) + for k in out:out[k]=sorted(set(out[k])) + return out + +def entity_owner_as_of(conn,ref,at): + # entities are already working-set preferred; resources may still need owner projection. + r=conn.execute('SELECT kind,json,preferred_id FROM entity_versions WHERE entity_id=? AND snapshot_time<=? ORDER BY snapshot_time DESC LIMIT 1',(ref,at)).fetchone() + if not r:r=conn.execute('SELECT kind,json,preferred_id FROM entities WHERE entity_id=?',(ref,)).fetchone() + if not r:return ref + if r['kind']=='system-node':return r['preferred_id'] or ref + try:o=json.loads(r['json']) + except:return r['preferred_id'] or ref + if r['kind'] in ('information-resource','channel') and o.get('owner'):return o['owner'] + return r['preferred_id'] or ref + +def active_observation_scopes(conn,population_id,edge_key,at): + rows=conn.execute('SELECT DISTINCT observation_scope FROM topology_observation_intervals WHERE population_id=? AND edge_key=? AND valid_from<=? AND (closed_at IS NULL OR closed_at>?)',(population_id,edge_key,at,at)).fetchall() + return sorted({r[0] for r in rows}) diff --git a/history/FIAM_v0.2_Draft6/tools/openapi_to_fiam.py b/history/FIAM_v0.2_Draft6/tools/openapi_to_fiam.py new file mode 100755 index 0000000..f662bce --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/openapi_to_fiam.py @@ -0,0 +1,328 @@ +#!/usr/bin/env python3 +"""OpenAPI 3.x -> FIAM v0.2-draft.4 declared-model ingest. + +The importer is intentionally architecture-oriented, not a lossless OpenAPI converter. +It creates FIAM nodes/ports/contracts/operations/bindings/endpoints/resources/shapes, +plus evidence-backed relations. Detailed schema fields stay in the OpenAPI artifact. +""" +from __future__ import annotations +import argparse, hashlib, json, re +from pathlib import Path +from urllib.parse import urlparse +import yaml + +HTTP_METHODS = ["get","put","post","delete","options","head","patch","trace"] +IGNORE_FINGERPRINT_KEYS = { + "title","description","example","examples","externalDocs","deprecated","xml", + "$comment","readOnly","writeOnly" +} + +def safe(s: str) -> str: + s = re.sub(r"[^A-Za-z0-9._:-]+", "-", str(s)).strip("-.") + return s or "unnamed" + +def load_doc(path: Path): + text = path.read_text(encoding="utf-8") + return json.loads(text) if path.suffix.lower()==".json" else yaml.safe_load(text) + +def pointer_escape(s): return str(s).replace("~","~0").replace("/","~1") + +def schema_pointer(name): return f"#/components/schemas/{pointer_escape(name)}" + +def shape_kind(schema): + if not isinstance(schema, dict): return "fiam.information-shape.opaque" + if "$ref" in schema: return None + if "oneOf" in schema or "anyOf" in schema: return "fiam.information-shape.union" + typ=schema.get("type") + if typ=="array": return "fiam.information-shape.collection" + if typ=="object" or "properties" in schema or "additionalProperties" in schema: return "fiam.information-shape.object" + if typ in {"string","number","integer","boolean","null"} or "enum" in schema: return "fiam.information-shape.scalar" + return "fiam.information-shape.opaque" + +def normalize_schema(x): + if isinstance(x, dict): + return {k:normalize_schema(v) for k,v in sorted(x.items()) if k not in IGNORE_FINGERPRINT_KEYS} + if isinstance(x, list): return [normalize_schema(v) for v in x] + return x + +def fingerprint(schema): + raw=json.dumps(normalize_schema(schema),sort_keys=True,separators=(",",":"),ensure_ascii=False) + return hashlib.sha256(raw.encode()).hexdigest() + +def media_rep(media): + m=(media or "").lower().split(";",1)[0].strip() + if m=="application/json" or m.endswith("+json"): return "fiam.representation.json" + if m in {"application/xml","text/xml"} or m.endswith("+xml"): return "fiam.representation.xml" + if m=="application/x-www-form-urlencoded": return "fiam.representation.form-urlencoded" + if m.startswith("text/"): return "fiam.representation.text" + if m in {"application/octet-stream","application/pdf","image/png","image/jpeg"}: return "fiam.representation.binary" + return None + +def deref_name(ref): + p="#/components/schemas/" + return ref[len(p):].replace("~1","/").replace("~0","~") if isinstance(ref,str) and ref.startswith(p) else None + +class Importer: + def __init__(self, doc, source_path, source_url=None): + self.doc=doc; self.source_path=str(source_path) + self.source_url=source_url or doc.get("x-source-url") or self.source_path + title=doc.get("info",{}).get("title") or Path(source_path).stem + self.slug=safe(title.lower()) + self.model={ + "fiam_version":"0.2", + "instance":{ + "id":f"model.openapi.{self.slug}","kind":"model","title":f"OpenAPI ingest — {title}", + "status":"provisional","intent":"Declared FIAM architecture model generated from an OpenAPI 3.x description." + }, + "nodes":[],"ports":[],"contracts":[],"endpoints":[],"bindings":[], + "information_resources":[],"information_shapes":[],"artifacts":[],"security":[],"assertions":[] + } + self.contract_id=f"contract.openapi.{self.slug}" + self.node_id=f"node.openapi.{self.slug}" + self.port_id=f"port.openapi.{self.slug}" + self.artifact_id=f"artifact.openapi.{self.slug}" + self.shape_ids={}; self.inline_shape_ids={}; self.op_ids=[]; self.binding_ids=[] + self.assert_n=0 + + def evidence(self, locator, mode="fiam.evidence.declared", confidence=1.0, source_type="openapi-document", metadata=None): + md={"source_url":self.source_url} + if metadata: md.update(metadata) + return {"mode":mode,"source":{"type":source_type,"ref":self.artifact_id if source_type=="openapi-document" else source_type, + "locator":locator,"metadata":md}, + "observer":"openapi-ingest/v0.2-draft.4","confidence":confidence,"stance":"supports"} + + def relation(self, subject,predicate,obj,locator,facets=None,mode="fiam.evidence.declared",confidence=1.0,source_type="openapi-document",metadata=None): + self.assert_n+=1 + a={"id":f"assertion.openapi.{self.assert_n:04d}","assertion_kind":"relation","subject":subject,"predicate":predicate, + "polarity":"asserted","object_ref":obj,"evidence":self.evidence(locator,mode,confidence,source_type,metadata)} + if facets: a["facets"]=facets + self.model["assertions"].append(a); return a + + def property(self, subject,predicate,value,locator,facets=None,mode="fiam.evidence.declared",confidence=1.0,source_type="openapi-document",metadata=None): + self.assert_n+=1 + a={"id":f"assertion.openapi.{self.assert_n:04d}","assertion_kind":"property","subject":subject,"predicate":predicate, + "polarity":"asserted","value":value,"evidence":self.evidence(locator,mode,confidence,source_type,metadata)} + if facets: a["facets"]=facets + self.model["assertions"].append(a); return a + + def component_shape(self,name,schema): + if name in self.shape_ids: return self.shape_ids[name] + sid=f"shape.openapi.{self.slug}.{safe(name)}"; self.shape_ids[name]=sid + self.model["information_shapes"].append({"id":sid,"kind":"information-shape","name":name, + "shape_kind":shape_kind(schema) or "fiam.information-shape.opaque", + "facets":{"openapi_component":name}}) + return sid + + def ensure_inline_shape(self, schema, pointer, name_hint): + if not isinstance(schema,dict): return None + if "$ref" in schema: + n=deref_name(schema["$ref"]) + return self.shape_ids.get(n) or (self.component_shape(n,self.doc.get("components",{}).get("schemas",{}).get(n,{})) if n else None) + key=pointer + if key in self.inline_shape_ids: return self.inline_shape_ids[key] + sid=f"shape.openapi.{self.slug}.inline.{safe(name_hint)}.{hashlib.sha1(pointer.encode()).hexdigest()[:8]}" + self.inline_shape_ids[key]=sid + self.model["information_shapes"].append({"id":sid,"kind":"information-shape","name":name_hint, + "shape_kind":shape_kind(schema) or "fiam.information-shape.opaque", + "facets":{"openapi_pointer":pointer}}) + # Array element shape when meaningful. + if schema.get("type")=="array" and isinstance(schema.get("items"),dict): + child=self.ensure_inline_shape(schema["items"],pointer+"/items",name_hint+" element") + if child: + self.relation(sid,"fiam.relation.element-shape",child,pointer+"/items", + {"slot":"items","role":"fiam.shape-role.element"}) + return sid + + def build_component_shapes(self): + schemas=self.doc.get("components",{}).get("schemas",{}) or {} + # First pass: identity. + for name,schema in schemas.items(): self.component_shape(name,schema or {}) + # Second pass: coarse composition, still no field lists in Core. + for name,schema in schemas.items(): + sid=self.shape_ids[name] + if not isinstance(schema,dict): continue + if schema.get("type")=="array" and isinstance(schema.get("items"),dict): + child=self.ensure_inline_shape(schema["items"],schema_pointer(name)+"/items",f"{name} element") + if child: self.relation(sid,"fiam.relation.element-shape",child,schema_pointer(name)+"/items",{"slot":"items","role":"fiam.shape-role.element"}) + for prop,ps in (schema.get("properties") or {}).items(): + if not isinstance(ps,dict): continue + pp=schema_pointer(name)+"/properties/"+pointer_escape(prop) + target=None; slot=prop + if "$ref" in ps: + target=self.ensure_inline_shape(ps,pp,prop) + elif ps.get("type")=="array" and isinstance(ps.get("items"),dict): + # Preserve array-ness as its own shape, then link element type. + target=self.ensure_inline_shape(ps,pp,f"{name}.{prop}") + elif ps.get("type") in {"object","array"} or "oneOf" in ps or "anyOf" in ps: + target=self.ensure_inline_shape(ps,pp,f"{name}.{prop}") + if target: + self.relation(sid,"fiam.relation.embeds-shape",target,pp,{"slot":slot,"role":"fiam.shape-role.envelope-member"}) + # Source artifact describes all component and inline shapes plus contract. + + def identity_candidates(self): + schemas=self.doc.get("components",{}).get("schemas",{}) or {} + groups={} + for name,schema in schemas.items(): groups.setdefault(fingerprint(schema or {}),[]).append(name) + for fp,names in groups.items(): + if len(names)<2: continue + for i in range(len(names)): + for j in range(i+1,len(names)): + a,b=names[i],names[j] + # structural equality is a candidate alignment only; never same-entity-as. + self.relation(self.shape_ids[a],"fiam.relation.corresponds-to",self.shape_ids[b], + f"fingerprint:sha256:{fp}",mode="fiam.evidence.inferred",confidence=0.75, + source_type="schema-structural-fingerprint", + metadata={"left":schema_pointer(a),"right":schema_pointer(b),"algorithm":"normalized-openapi-schema-sha256"}) + + + def security_mapping(self, scheme): + typ=str((scheme or {}).get("type") or "") + if typ=="apiKey": return "fiam.security.authentication.api-key", ["fiam.credential.api-key"], None + if typ=="http": + hs=str(scheme.get("scheme") or "").lower() + if hs=="basic": return "fiam.security.authentication.http-basic", ["fiam.credential.basic-credentials"], None + if hs=="bearer": return "fiam.security.authentication.bearer-token", ["fiam.credential.bearer-token"], None + return "fiam.security.authentication.unspecified", [], None + if typ=="oauth2": return "fiam.security.authentication.oauth2", ["fiam.credential.access-token"], None + if typ=="openIdConnect": return "fiam.security.authentication.openid-connect", ["fiam.credential.id-token","fiam.credential.access-token"], None + if typ=="mutualTLS": return "fiam.security.authentication.mutual-tls", ["fiam.credential.client-certificate"], "fiam.security.tls" + return "fiam.security.authentication.unspecified", [], None + + def apply_security_requirements(self, applies_to, requirements, pointer, scope_kind): + """Map OpenAPI Security Requirement alternatives without flattening OR/AND semantics. + + The array is OR. Multiple scheme names inside one requirement object are AND. + One FIAM SecurityProfile is emitted per referenced scheme with a shared + requirement_alternative facet. + """ + if requirements is None: return + if requirements==[]: + self.property(applies_to,"fiam.property.security-override","none",pointer) + return + schemes=(self.doc.get("components",{}).get("securitySchemes",{}) or {}) + anonymous_alt=any(isinstance(r,dict) and not r for r in requirements) + state="anonymous-alternative" if anonymous_alt else ("operation" if scope_kind=="operation" else "declared") + self.property(applies_to,"fiam.property.security-override",state,pointer) + for alt, req in enumerate(requirements, start=1): + if not isinstance(req,dict) or not req: continue + for name, scopes in req.items(): + sd=schemes.get(name) + if not isinstance(sd,dict) or "$ref" in sd: continue + auth, creds, transport=self.security_mapping(sd) + sid=f"security.openapi.{self.slug}.{safe(applies_to)}.{alt}.{safe(name)}" + facets={"openapi_security_scheme":name,"openapi_security_type":sd.get("type"),"requirement_alternative":alt,"requirement_operator":"and-within-alternative","required_scopes":list(scopes or [])} + for k in ("name","in","scheme","bearerFormat","openIdConnectUrl"): + if sd.get(k) is not None: facets["openapi_"+k]=sd.get(k) + if sd.get("flows"): facets["openapi_oauth_flows"]=sorted(sd["flows"].keys()) + prof={"id":sid,"applies_to":applies_to,"authentication":auth,"facets":facets} + if creds: prof["credential_artifacts"]=creds + if transport: prof["transport_security"]=transport + if not any(x.get("id")==sid for x in self.model["security"]): self.model["security"].append(prof) + # Evidence that the security profile is declared by the source description. + self.property(sid,"fiam.property.security-override","required",pointer+"/"+str(alt-1)+"/"+pointer_escape(name),facets={"applies_to":applies_to}) + + def add_shape_participation(self, opid, binding_ids, pred, schema, pointer, media, role): + sid=self.ensure_inline_shape(schema,pointer,opid.split('.')[-1]+" "+role.split('.')[-1]) + if not sid: return + self.relation(opid,pred,sid,pointer,{"role":role}) + rep=media_rep(media) + for bid in binding_ids: + facets={"operation_ref":opid,"role":role} + if rep: facets["representation"]=rep + self.relation(bid,pred,sid,pointer,facets) + + def build(self): + info=self.doc.get("info",{}) + self.model["nodes"].append({"id":self.node_id,"kind":"system-node","name":info.get("title",self.slug),"node_type":"fiam.node-type.service"}) + self.model["ports"].append({"id":self.port_id,"owner":self.node_id,"participations":[{"contract":self.contract_id,"mode":"offers"}]}) + contract={"id":self.contract_id,"kind":"interface-contract","name":info.get("title",self.slug),"contract_forms":["fiam.contract-form.openapi"],"operations":[]} + self.model["contracts"].append(contract) + self.build_component_shapes() + self.apply_security_requirements(self.contract_id,self.doc.get("security"),"#/security","contract") + + # Endpoints/bindings from servers. If none, keep an unlocated HTTP binding. + servers=self.doc.get("servers") or [{}] + for idx,server in enumerate(servers): + url=server.get("url") if isinstance(server,dict) else None + eid=f"endpoint.openapi.{self.slug}.{idx+1}"; bid=f"binding.openapi.{self.slug}.{idx+1}" + ep={"id":eid,"kind":"endpoint","name":server.get("description",f"OpenAPI server {idx+1}") if isinstance(server,dict) else f"OpenAPI server {idx+1}"} + if url: + ep["address"]=url + if urlparse(url).scheme.lower()=="https": ep["address_scheme"]="fiam.address-scheme.https-url" + self.model["endpoints"].append(ep) + stack=[{"role":"fiam.stack-role.application-transfer-protocol","term":"fiam.protocol.http"}] + if url and urlparse(url).scheme.lower()=="https": stack += [{"role":"fiam.stack-role.security-protocol","term":"fiam.protocol.tls"}] + b={"id":bid,"kind":"binding","contract":self.contract_id,"provider_port":self.port_id,"endpoints":[eid],"communication_stack":stack,"operations":[]} + self.model["bindings"].append(b); self.binding_ids.append(bid) + self.property(bid,"fiam.property.communication-protocol","fiam.protocol.http",f"#/servers/{idx}") + if url: + pu=urlparse(url) + if pu.hostname: + self.property(eid,"fiam.property.server-address",pu.hostname,f"#/servers/{idx}/url") + if pu.port: + self.property(eid,"fiam.property.server-port",pu.port,f"#/servers/{idx}/url") + + for path,pitem in (self.doc.get("paths") or {}).items(): + if not isinstance(pitem,dict): continue + # Path template is a logical information resource selected through the HTTP API. + collection = not bool(re.search(r"\{[^}]+\}\s*$",path)) + rid=f"resource.openapi.{self.slug}.{safe(path)}" + self.model["information_resources"].append({ + "id":rid,"kind":"information-resource","owner":self.node_id,"name":path, + "resource_kind":"fiam.information-resource.api-resource-collection" if collection else "fiam.information-resource.api-resource-object", + "resource_scope":"fiam.resource-scope.logical-selection", + "selectors":[{"kind":"fiam.resource-selector.http-path-template","value":path}] + }) + for method in HTTP_METHODS: + op=pitem.get(method) + if not isinstance(op,dict): continue + opkey=op.get("operationId") or f"{method}-{path}" + opid=f"operation.openapi.{self.slug}.{safe(opkey)}"; self.op_ids.append(opid) + effect="fiam.effect.read" if method in {"get","head","options"} else "fiam.effect.write" + purpose=["fiam.purpose.query"] if effect=="fiam.effect.read" else ["fiam.purpose.mutation"] + o={"id":opid,"kind":"operation","name":op.get("summary") or opkey,"description":op.get("description",""), + "interaction_style":"fiam.interaction-style.request-response","effect":effect,"purpose":purpose, + "x-http-method":method.upper(),"x-openapi-path":path,"x-openapi-operation-id":op.get("operationId")} + if o["x-openapi-operation-id"] is None: o.pop("x-openapi-operation-id") + contract["operations"].append(o) + for b in self.model["bindings"]: b["operations"].append(opid) + op_ptr=f"#/paths/{pointer_escape(path)}/{method}" + if "security" in op: self.apply_security_requirements(opid,op.get("security"),op_ptr+"/security","operation") + self.property(opid,"fiam.property.http-method",method.upper(),op_ptr) + self.property(opid,"fiam.property.http-route",path,op_ptr) + self.relation(opid,"fiam.relation.targets",rid,op_ptr) + # Request body + rb=op.get("requestBody") or {} + if isinstance(rb,dict) and "$ref" not in rb: + for media,md in (rb.get("content") or {}).items(): + if isinstance(md,dict) and isinstance(md.get("schema"),dict): + self.add_shape_participation(opid,self.binding_ids,"fiam.relation.accepts-shape",md["schema"],op_ptr+"/requestBody/content/"+pointer_escape(media)+"/schema",media,"fiam.shape-role.request") + # Responses + for status,resp in (op.get("responses") or {}).items(): + if not isinstance(resp,dict) or "$ref" in resp: continue + pred="fiam.relation.produces-shape" if str(status).startswith("2") else "fiam.relation.errors-with-shape" + role="fiam.shape-role.response" if pred.endswith("produces-shape") else "fiam.shape-role.error" + for media,md in (resp.get("content") or {}).items(): + if isinstance(md,dict) and isinstance(md.get("schema"),dict): + self.add_shape_participation(opid,self.binding_ids,pred,md["schema"],op_ptr+"/responses/"+pointer_escape(status)+"/content/"+pointer_escape(media)+"/schema",media,role) + + self.identity_candidates() + described=[self.contract_id]+[x["id"] for x in self.model["information_shapes"]]+[x["id"] for x in self.model.get("security",[])] + self.model["artifacts"].append({"id":self.artifact_id,"kind":"artifact","name":Path(self.source_path).name, + "artifact_type":"fiam.artifact.api-description","describes":described,"locator":self.source_url, + "facets":{"openapi_version":str(self.doc.get("openapi","")),"document_version":str(info.get("version","")),"source_file":Path(self.source_path).name, + **({"source_note":self.doc.get("x-source-note")} if self.doc.get("x-source-note") else {})}}) + # strip empty sections + self.model={k:v for k,v in self.model.items() if not isinstance(v,list) or v} + return self.model + +def main(): + ap=argparse.ArgumentParser(description=__doc__) + ap.add_argument("input",type=Path); ap.add_argument("-o","--output",type=Path,required=True); ap.add_argument("--source-url") + args=ap.parse_args(); doc=load_doc(args.input) + if not isinstance(doc,dict) or not str(doc.get("openapi","")).startswith("3."): + raise SystemExit("Only OpenAPI 3.x documents are supported in draft.4") + out=Importer(doc,args.input,args.source_url).build(); args.output.parent.mkdir(parents=True,exist_ok=True) + args.output.write_text(yaml.safe_dump(out,sort_keys=False,allow_unicode=True,width=120),encoding="utf-8") + print(f"wrote {args.output}: {len(out.get('contracts',[{}])[0].get('operations',[]))} operations, {len(out.get('information_shapes',[]))} shapes, {len(out.get('assertions',[]))} assertions") +if __name__=="__main__": main() diff --git a/history/FIAM_v0.2_Draft6/tools/operation_coverage_lens.py b/history/FIAM_v0.2_Draft6/tools/operation_coverage_lens.py new file mode 100755 index 0000000..d375d41 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/operation_coverage_lens.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 +"""Declared operation coverage/dormancy from runtime aggregate last-seen evidence.""" +from __future__ import annotations +import argparse,json,sqlite3 +from datetime import datetime,timedelta +from pathlib import Path +import yaml + +def dt(v):return datetime.fromisoformat(str(v).replace('Z','+00:00')) + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('db',type=Path);ap.add_argument('--population',required=True);ap.add_argument('--at',required=True);ap.add_argument('--window-days',type=int,default=90);ap.add_argument('-o','--output',type=Path,required=True);a=ap.parse_args();c=sqlite3.connect(a.db);c.row_factory=sqlite3.Row;since=(dt(a.at)-timedelta(days=a.window_days)).isoformat().replace('+00:00','Z') + # latest declared snapshot per source, then operations declared by those exchanges + xs=c.execute("SELECT source_id,exchange_id,snapshot_time FROM exchange_documents WHERE mode='declared-snapshot' AND snapshot_time<=? AND (population_id IS NULL OR population_id=?) ORDER BY source_id,snapshot_time DESC",(a.at,a.population)).fetchall();latest={} + for x in xs: + if x['source_id'] not in latest:latest[x['source_id']]=x['exchange_id'] + ops=[] + for exid in latest.values(): + for r in c.execute("SELECT de.entity_id,e.name FROM declared_entities de JOIN entity_versions e ON e.entity_id=de.entity_id AND e.exchange_id=de.exchange_id WHERE de.exchange_id=? AND e.kind='operation'",(exid,)).fetchall():ops.append((r['entity_id'],r['name'])) + seen={} + for r in c.execute('SELECT operation_ref,MAX(last_seen) ls,SUM(count) cnt,SUM(error_count) err FROM runtime_aggregates WHERE population_id=? AND last_seen<=? GROUP BY operation_ref',(a.population,a.at)).fetchall():seen[r['operation_ref']]={'last_seen':r['ls'],'count':int(r['cnt'] or 0),'error_count':int(r['err'] or 0)} + rows=[] + for oid,name in sorted(set(ops)): + s=seen.get(oid) + if not s:cls='never-observed' + elif s['last_seen'] FIAM v0.2-draft.4 estate-oriented runtime catalog ingest. + +Default behavior is architectural aggregation, not span mirroring. Runtime spans update +stable architecture entities plus idempotent evidence-backed observation statistics. +Only a bounded number of span-shaped Interactions are retained as optional samples. + +The Core model is unchanged. Estate/catalog mechanics live in adapters, assertions, +Zones, and namespaced extensions. +""" +from __future__ import annotations +import argparse, copy, hashlib, json, re +from datetime import datetime, timezone +from pathlib import Path +from urllib.parse import urlparse +import yaml + +SPAN_KIND={0:'unspecified',1:'internal',2:'server',3:'client',4:'producer',5:'consumer'} +SEMCONV='OpenTelemetry Semantic Conventions 1.44.0' +OTLP='OTLP 1.11.0' +OBSERVER='otel-ingest/v0.2-draft.4' +CATALOG_EXT='org.fiam.catalog' +AGG_EXT='org.fiam.runtime_aggregates' +TOPO_EXT='org.fiam.runtime_topology_observations' +UNRESOLVED_EXT='org.fiam.runtime_unresolved' +RECON_EXT='org.fiam.reconciliation_candidates' + + +def safe(s): + s=re.sub(r'[^A-Za-z0-9._:-]+','-',str(s)).strip('-.') + return s or 'unnamed' + +def any_value(v): + if not isinstance(v,dict): return v + for k in ('stringValue','boolValue','doubleValue','intValue','bytesValue'): + if k in v: + x=v[k] + if k=='intValue': + try:return int(x) + except Exception:return x + return x + if 'arrayValue' in v:return [any_value(x) for x in (v['arrayValue'] or {}).get('values',[])] + if 'kvlistValue' in v:return {x.get('key'):any_value(x.get('value',{})) for x in (v['kvlistValue'] or {}).get('values',[])} + return None + +def attrs(items): + return {x.get('key'):any_value(x.get('value',{})) for x in (items or []) if isinstance(x,dict) and x.get('key')} + +def load_otlp(path:Path): + text=path.read_text(encoding='utf-8').strip() + if not text:return [] + try:return [json.loads(text)] + except json.JSONDecodeError:return [json.loads(line) for line in text.splitlines() if line.strip()] + +def ns_to_iso(v): + if v in (None,''):return None + try:return datetime.fromtimestamp(int(v)/1_000_000_000,tz=timezone.utc).isoformat().replace('+00:00','Z') + except Exception:return None + +def iso_min(a,b):return min([x for x in (a,b) if x],default=None) +def iso_max(a,b):return max([x for x in (a,b) if x],default=None) +def default_port(scheme):return 443 if scheme=='https' else 80 if scheme=='http' else None + +def origin(scheme,host,port): + if not host:return None + scheme=scheme or 'http'; d=default_port(scheme) + return f'{scheme}://{host}' if not port or int(port)==d else f'{scheme}://{host}:{port}' + +def host_port(host,port): + if not host:return None + return f'{host}:{port}' if port is not None else str(host) + +def route_join(base_url,path): + if not base_url:return path or '' + p=urlparse(base_url); base=(p.path or '').rstrip('/'); child=path or '' + if child and not child.startswith('/'):child='/'+child + return re.sub(r'/+','/',(base+child) or '/') + +def normalize_route(r): + if not r:return '' + r='/' + str(r).strip().lstrip('/'); r=re.sub(r'/+','/',r) + return r.rstrip('/') or '/' + +def route_similarity(a,b): + a,b=normalize_route(a),normalize_route(b) + if not a or not b:return 0.0 + if a==b:return 1.0 + sa=[x for x in a.split('/') if x]; sb=[x for x in b.split('/') if x] + # Ignore parameter names but retain segment positions. + def norm(xs):return ['{}' if (x.startswith('{') and x.endswith('}')) else x for x in xs] + na,nb=norm(sa),norm(sb) + if na==nb:return .95 + if len(na)<=len(nb) and nb[-len(na):]==na:return .72 + if len(nb)<=len(na) and na[-len(nb):]==nb:return .72 + common=sum(1 for x,y in zip(na,nb) if x==y) + return common/max(len(na),len(nb),1) + +def http_protocol_term(version): + v=str(version or '').strip().lower().replace('http/','') + if v in {'1.1','1_1'}:return 'fiam.protocol.http1.1' + if v in {'2','2.0','2_0'}:return 'fiam.protocol.http2' + if v in {'3','3.0','3_0'}:return 'fiam.protocol.http3' + return 'fiam.protocol.http' + +def rpc_protocol_term(system):return {'grpc':'fiam.protocol.grpc'}.get(str(system or '').lower()) +def messaging_protocol_term(system):return {'kafka':'fiam.protocol.kafka'}.get(str(system or '').lower()) +def database_protocol_term(system):return {'postgresql':'fiam.protocol.postgresql-frontend-backend','postgres':'fiam.protocol.postgresql-frontend-backend'}.get(str(system or '').lower()) +def db_effect(operation): + op=str(operation or '').strip().upper() + if op in {'SELECT','SHOW','DESCRIBE','EXPLAIN','GET','FIND','SCAN','READ'}:return 'read' + if op in {'INSERT','UPDATE','DELETE','UPSERT','MERGE','REPLACE','CREATE','DROP','ALTER','SET','WRITE','HMSET'}:return 'write' + return None + +def terminal_method(name): + s=str(name or '').strip().rstrip('/'); return s.split('/')[-1] if s else '' + +def digest(*parts,n=12): + raw=json.dumps(parts,sort_keys=True,separators=(',',':'),ensure_ascii=False,default=str) + return hashlib.sha256(raw.encode()).hexdigest()[:n] + +def identity_id(prefix,label,*tuple_parts): + return f'{prefix}.{safe(label)[:80]}.{digest(*tuple_parts)}' + +def batch_hash(path:Path):return hashlib.sha256(path.read_bytes()).hexdigest() + +def entity_index(doc): + idx={}; kinds={}; op_contract={} + if not doc:return idx,kinds,op_contract + for sec,kind in [('participants','participant'),('nodes','system-node'),('ports','port'),('contracts','interface-contract'),('endpoints','endpoint'),('bindings','binding'),('channels','channel'),('information_resources','information-resource'),('information_shapes','information-shape'),('interactions','interaction'),('interaction_flows','interaction-flow'),('artifacts','artifact'),('zones','zone'),('security','security-profile')]: + for x in doc.get(sec,[]) or []: + if isinstance(x,dict) and x.get('id'):idx[x['id']]=x;kinds[x['id']]=kind + if sec=='contracts': + for op in x.get('operations',[]) or []: + if isinstance(op,dict) and op.get('id'):idx[op['id']]=op;kinds[op['id']]='operation';op_contract[op['id']]=x['id'] + return idx,kinds,op_contract + +def add_unique(doc,section,item): + arr=doc.setdefault(section,[]) + for old in arr: + if old.get('id')==item.get('id'): + for k in ('operations','consumer_ports','endpoints','members','participations'): + if k in item: + old.setdefault(k,[]) + for v in item[k]: + if v not in old[k]:old[k].append(v) + # Merge safe facets, never overwrite existing non-empty facts. + if item.get('facets'): + old.setdefault('facets',{}) + for k,v in item['facets'].items():old['facets'].setdefault(k,v) + return old + arr.append(item);return item + +def evidence_records(a): + e=a.get('evidence') + return [e] if isinstance(e,dict) else [x for x in (e or []) if isinstance(x,dict)] + +def evidence_has_mode(a,mode):return any(e.get('mode')==mode for e in evidence_records(a)) + +class Importer: + def __init__(self,objects,source_path:Path,base=None,source_url=None,occurrences='sample',sample_size=3,authoritative_snapshot=False): + self.objects=objects; self.source_path=source_path; self.source_url=source_url or str(source_path) + self.batch_hash=batch_hash(source_path); self.occurrences=occurrences; self.sample_size=max(0,int(sample_size)); self.authoritative_snapshot=authoritative_snapshot + self.base=copy.deepcopy(base) if base else None + if self.base: + self.model=copy.deepcopy(self.base); self.model.pop('tests',None) + ext=self.model.setdefault('extensions',{}); cat=ext.get(CATALOG_EXT) + if cat: + # Existing catalog: preserve stable catalog identity across incremental batches. + self.model['instance']=dict(self.model.get('instance',{})) + else: + self.model['instance']=dict(self.model.get('instance',{})); original=self.model['instance'].get('id','model') + self.model['instance']['id']=safe(original+'.catalog'); self.model['instance']['kind']='model'; self.model['instance']['title']=str(self.model['instance'].get('title','FIAM model'))+' — runtime catalog' + self.model['instance']['intent']='Incremental FIAM catalog combining declared architecture with aggregated runtime observations.'; self.model['instance']['status']='provisional' + else: + stem=safe(source_path.stem.lower()); self.model={'fiam_version':'0.2','instance':{'id':f'model.otel.catalog.{stem}','kind':'model','title':f'OpenTelemetry runtime catalog — {source_path.name}','status':'provisional','intent':'Incremental runtime-observed FIAM architecture catalog generated from OTLP/JSON traces.'}} + self.ext=self.model.setdefault('extensions',{}); self.catalog=self.ext.setdefault(CATALOG_EXT,{'version':'0.2-draft.4','processed_batches':[],'declared_entity_ids':[]}) + if not self.catalog.get('declared_entity_ids') and base and CATALOG_EXT not in (base.get('extensions') or {}): + self.catalog['declared_entity_ids']=sorted(entity_index(base)[0]) + self.declared_ids=set(self.catalog.get('declared_entity_ids') or []) + self.already_processed=self.batch_hash in set(self.catalog.get('processed_batches') or []) + self.artifact_id=identity_id('artifact.otel.stream',safe(urlparse(self.source_url).netloc or source_path.stem),self.source_url) + self.idx,self.kinds,self.op_contract=entity_index(self.model) + self.assertions={a.get('id'):a for a in self.model.get('assertions',[]) or [] if a.get('id')} + self.aggs={x.get('id'):x for x in self.ext.get(AGG_EXT,[]) or [] if x.get('id')} + self.topo={x.get('id'):x for x in self.ext.get(TOPO_EXT,[]) or [] if x.get('id')} + self.unresolved={x.get('id'):x for x in self.ext.get(UNRESOLVED_EXT,[]) or [] if x.get('id')} + self.recon={x.get('observed_ref'):x for x in self.ext.get(RECON_EXT,[]) or [] if x.get('observed_ref')} + self.span_records={}; self.batch_seen_aggs=set(); self.interactions_retained=[] + self.batch_first=None; self.batch_last=None + self._build_declared_indexes() + + # ---------- evidence/assertions ---------- + def _sample_ref(self,trace,sid):return f'trace:{trace}/span:{sid}' if trace and sid else None + def ev(self,locator_class,observed_at=None,confidence=1.0,source_type='otlp-trace-stream',sample_ref=None,metadata=None,mode='fiam.evidence.runtime-observed'): + md={'source':self.source_url,'semconv_basis':SEMCONV,'otlp_basis':OTLP,'locator_class':locator_class} + if metadata:md.update(metadata) + if sample_ref:md['sample_spans']=[sample_ref] + return {'mode':mode,'source':{'type':source_type,'ref':self.artifact_id,'locator':locator_class,'metadata':md},'observer':OBSERVER,'confidence':confidence,'stance':'supports',**({'observed_at':observed_at} if observed_at else {})} + + def _aid(self,kind,subject,predicate,target,locator_class,extra=None):return f'assertion.otel.{digest(kind,subject,predicate,target,locator_class,extra,n=20)}' + def _merge_evidence(self,a,new): + recs=evidence_records(a) + # One summarized evidence record per source/locator-class; update timestamps/samples. + sig=lambda e:((e.get('source') or {}).get('type'),(e.get('source') or {}).get('ref'),(e.get('source') or {}).get('locator'),e.get('mode')) + match=next((e for e in recs if sig(e)==sig(new)),None) + if match: + match['observed_at']=iso_max(match.get('observed_at'),new.get('observed_at')) + match['confidence']=max(float(match.get('confidence',0)),float(new.get('confidence',0))) + m=(match.get('source') or {}).setdefault('metadata',{}); nm=(new.get('source') or {}).get('metadata',{}) + samples=list(m.get('sample_spans') or []) + for s in nm.get('sample_spans') or []: + if s not in samples:samples.append(s) + if samples:m['sample_spans']=samples[:self.sample_size or 3] + batches=list(m.get('sample_batch_hashes') or []) + if self.batch_hash not in batches:batches.append(self.batch_hash) + m['sample_batch_hashes']=batches[-5:] + else: + md=(new.get('source') or {}).setdefault('metadata',{});md['sample_batch_hashes']=[self.batch_hash] + recs.append(new) + a['evidence']=recs[0] if len(recs)==1 else recs + + def prop(self,subject,predicate,value,locator_class,ts=None,facets=None,confidence=1.0,sample_ref=None,mode='fiam.evidence.runtime-observed',source_type='otlp-trace-stream'): + aid=self._aid('property',subject,predicate,value,locator_class) + newev=self.ev(locator_class,ts,confidence,source_type,sample_ref,mode=mode) + if aid in self.assertions: + a=self.assertions[aid]; self._merge_evidence(a,newev); vt=a.setdefault('valid_time',{}); vt['valid_from']=iso_min(vt.get('valid_from'),ts);vt['valid_until']=iso_max(vt.get('valid_until'),ts) + return a + a={'id':aid,'assertion_kind':'property','subject':subject,'predicate':predicate,'polarity':'asserted','value':value,'evidence':newev} + if ts:a['valid_time']={'valid_from':ts,'valid_until':ts,'observed_at':ts} + if facets:a['facets']=facets + self.model.setdefault('assertions',[]).append(a);self.assertions[aid]=a;return a + + def stat(self,subject,predicate,value,agg_key,first_seen,last_seen,facets,samples): + aid=self._aid('stat',subject,predicate,'aggregate',f'aggregate:{agg_key}') + ev=self.ev(f'aggregate:{agg_key}',last_seen,1.0,'otlp-aggregate',samples[0] if samples else None,metadata={'aggregation_key':agg_key}) + if aid in self.assertions: + a=self.assertions[aid];a['value']=value;self._merge_evidence(a,ev) + else: + a={'id':aid,'assertion_kind':'property','subject':subject,'predicate':predicate,'polarity':'asserted','value':value,'evidence':ev,'facets':facets};self.model.setdefault('assertions',[]).append(a);self.assertions[aid]=a + a['valid_time']={'valid_from':first_seen,'valid_until':last_seen,'observed_at':last_seen} + return a + + def rel(self,subject,predicate,obj,locator_class,ts=None,facets=None,mode='fiam.evidence.inferred',confidence=.95,source_type='reconciliation-rule',sample_ref=None,metadata=None): + aid=self._aid('relation',subject,predicate,obj,locator_class,facets) + ev=self.ev(locator_class,ts,confidence,source_type,sample_ref,metadata,mode) + if aid in self.assertions: + a=self.assertions[aid];self._merge_evidence(a,ev);vt=a.setdefault('valid_time',{});vt['valid_from']=iso_min(vt.get('valid_from'),ts);vt['valid_until']=iso_max(vt.get('valid_until'),ts);return a + a={'id':aid,'assertion_kind':'relation','subject':subject,'predicate':predicate,'polarity':'asserted','object_ref':obj,'evidence':ev} + if ts:a['valid_time']={'valid_from':ts,'valid_until':ts,'observed_at':ts} + if facets:a['facets']=facets + self.model.setdefault('assertions',[]).append(a);self.assertions[aid]=a;return a + + # ---------- catalog + identity tuples ---------- + def ensure_artifact(self): + item={'id':self.artifact_id,'kind':'artifact','name':'OTLP runtime stream','artifact_type':'fiam.artifact.telemetry-trace-export','locator':self.source_url,'facets':{'format':'OTLP/JSON','observer_profile':SEMCONV,'latest_batch_hash':self.batch_hash}} + old=add_unique(self.model,'artifacts',item);old.setdefault('facets',{})['latest_batch_hash']=self.batch_hash + self.idx[old['id']]=old;self.kinds[old['id']]='artifact' + + def zone_context(self,ra): + return {'environment':str(ra.get('deployment.environment.name') or ''),'cluster_uid':str(ra.get('k8s.cluster.uid') or ''),'cluster_name':str(ra.get('k8s.cluster.name') or ''),'k8s_namespace':str(ra.get('k8s.namespace.name') or ''),'cloud_account':str(ra.get('cloud.account.id') or ''),'cloud_region':str(ra.get('cloud.region') or '')} + + def ensure_zones(self,z): + members=[]; parent=None + if z['environment']: + zid=identity_id('zone.otel.environment',z['environment'],'environment',z['environment']);add_unique(self.model,'zones',{'id':zid,'kind':'zone','name':z['environment'],'zone_type':'fiam.zone-type.deployment-environment','members':[]});members.append(zid);parent=zid + cluster=z['cluster_uid'] or z['cluster_name'] + if cluster: + zid=identity_id('zone.otel.cluster',z['cluster_name'] or cluster,'cluster',cluster,z['environment']);item={'id':zid,'kind':'zone','name':z['cluster_name'] or cluster,'zone_type':'fiam.zone-type.cluster','members':[]} + if parent:item['parent']=parent + add_unique(self.model,'zones',item);members.append(zid);parent=zid + if z['k8s_namespace']: + zid=identity_id('zone.otel.k8s-namespace',z['k8s_namespace'],'k8s-namespace',cluster,z['k8s_namespace'],z['environment']);item={'id':zid,'kind':'zone','name':z['k8s_namespace'],'zone_type':'fiam.zone-type.kubernetes-namespace','members':[]} + if parent:item['parent']=parent + add_unique(self.model,'zones',item);members.append(zid);parent=zid + if not members: + zid='zone.otel.unscoped';add_unique(self.model,'zones',{'id':zid,'kind':'zone','name':'Unscoped runtime observations','zone_type':'fiam.zone-type.unscoped','members':[]});members=[zid] + self.idx,self.kinds,self.op_contract=entity_index(self.model) + return members + + def zone_key(self,z):return (z['environment'],z['cluster_uid'] or z['cluster_name'],z['k8s_namespace'],z['cloud_account'],z['cloud_region']) + def ensure_service_node(self,service,namespace,ra): + z=self.zone_context(ra); zones=self.ensure_zones(z); tup=('service',namespace,service,*self.zone_key(z));nodeid=identity_id('node.otel.service',f'{namespace+"." if namespace else ""}{service}',*tup) + facets={'identity_tuple':{'kind':'service-deployment','service_namespace':namespace,'service_name':service,**{k:v for k,v in z.items() if v}}} + if ra.get('service.instance.id'):facets['sample_service_instance_id']=str(ra['service.instance.id']) + node=add_unique(self.model,'nodes',{'id':nodeid,'kind':'system-node','name':service,'node_type':'fiam.node-type.service','facets':facets});self.idx[nodeid]=node;self.kinds[nodeid]='system-node' + for zid in zones: + zone=self.idx.get(zid) or next(x for x in self.model.get('zones',[]) if x['id']==zid);zone.setdefault('members',[]) + if nodeid not in zone['members']:zone['members'].append(nodeid) + return nodeid,z,zones + + def ensure_target_node(self,node_type,label,address,system,z): + if not address:return None + tup=(node_type,system,address,*self.zone_key(z));nid=identity_id(f'node.otel.{node_type}',f'{system}.{address}',*tup);term='fiam.node-type.broker' if node_type=='broker' else 'fiam.node-type.database' if node_type=='database' else 'fiam.node-type.service' + node=add_unique(self.model,'nodes',{'id':nid,'kind':'system-node','name':label,'node_type':term,'facets':{'identity_tuple':{'kind':node_type,'system':system,'logical_address':address,'zone':self.zone_key(z)}}});self.idx[nid]=node;self.kinds[nid]='system-node';return nid + + def ensure_contract_operation(self,cid,cname,op): + contract=self.idx.get(cid) + if not contract: + contract={'id':cid,'kind':'interface-contract','name':cname,'operations':[]};self.model.setdefault('contracts',[]).append(contract);self.idx[cid]=contract;self.kinds[cid]='interface-contract' + if not any(x.get('id')==op['id'] for x in contract['operations']):contract['operations'].append(op);self.idx[op['id']]=op;self.kinds[op['id']]='operation';self.op_contract[op['id']]=cid + return contract + + def ensure_endpoint(self,prefix,label,address,address_scheme,z,facets=None): + tup=('endpoint',address,address_scheme,*self.zone_key(z));eid=identity_id(prefix,label,*tup);ep={'id':eid,'kind':'endpoint','name':label,'address_scheme':address_scheme,'facets':{'identity_tuple':{'address':address,'address_scheme':address_scheme,'zone':self.zone_key(z)},**(facets or {})}} + if address:ep['address']=address + ep=add_unique(self.model,'endpoints',ep);self.idx[eid]=ep;self.kinds[eid]='endpoint';return eid + + def span_context(self,service,namespace,scope,span,ra): + nodeid,z,zones=self.ensure_service_node(service,namespace,ra);trace=span.get('traceId','');sid=span.get('spanId','');ts=ns_to_iso(span.get('startTimeUnixNano'));loc=self._sample_ref(trace,sid);kind=SPAN_KIND.get(span.get('kind'),'unknown') + self.batch_first=iso_min(self.batch_first,ts);self.batch_last=iso_max(self.batch_last,ts) + links=[] + for l in span.get('links',[]) or []: + if l.get('traceId') and l.get('spanId'):links.append(f"{l['traceId']}:{l['spanId']}") + # Raw span names are intentionally not persisted: when semantic route/resource attributes are missing, + # span names often contain high-cardinality paths, identifiers, or user data. Trace/span ids are enough + # to retrieve a bounded diagnostic sample from the telemetry system of record. + fac={'otel_trace_id':trace,'otel_span_id':sid,'otel_span_kind':kind,'instrumentation_scope':scope,'observed_service':nodeid} + if span.get('parentSpanId'):fac['otel_parent_span_id']=span['parentSpanId'] + if links:fac['otel_links']=links + return nodeid,z,zones,trace,sid,ts,loc,kind,fac + + # ---------- aggregation + occurrence sampling ---------- + def aggregate(self,domain,role,operation,binding,local_node,ts,sample_ref,error=False,channel=None,resource=None,remote_node=None,extra=None): + tuple_obj={'domain':domain,'role':role,'operation':operation,'binding':binding,'local_node':local_node,'remote_node':remote_node,'channel':channel,'resource':resource,**(extra or {})} + key=digest(tuple_obj,n=24);aid=f'aggregate.otel.{key}';old=self.aggs.get(aid) + if not old: + old={'id':aid,**tuple_obj,'count':0,'error_count':0,'first_seen':ts,'last_seen':ts,'sample_spans':[]};self.aggs[aid]=old + if not self.already_processed: + old['count']=int(old.get('count',0))+1;old['error_count']=int(old.get('error_count',0))+(1 if error else 0);old['first_seen']=iso_min(old.get('first_seen'),ts);old['last_seen']=iso_max(old.get('last_seen'),ts) + if sample_ref and sample_ref not in old.setdefault('sample_spans',[]) and len(old['sample_spans'])=.7 and len(ties)==1 else 'ambiguous' + self._record_candidates(nodeid,'system-node',c,status) + if status=='matched':self.rel(nodeid,'fiam.relation.corresponds-to',top['declared_ref'],'reconcile:service-identity',ts,confidence=min(.98,max(.92,top['score']+.2)),metadata={'signals':top['signals']},sample_ref=sample_ref) + + def reconcile_http(self,obs): + if not self.base:return + candidates=[] + for d in self.declared_http: + score=0;signals=[];rs=route_similarity(obs.get('route'),d.get('route')) + if obs.get('method')==d.get('method'):score+=.3;signals.append('http-method') + if rs>=.99:score+=.5;signals.append('http-route-exact') + elif rs>=.7:score+=.34;signals.append('http-route-near') + elif rs>=.4:score+=.18;signals.append('http-route-partial') + if obs.get('host') and d.get('host') and obs['host'].lower()==d['host'].lower():score+=.2;signals.append('server-address') + if score>=.3:candidates.append({'declared_ref':d['operation'],'binding_ref':d['binding'],'endpoint_ref':d.get('endpoint'),'node_ref':d.get('node'),'score':round(score,3),'signals':signals}) + if not candidates: + self._record_candidates(obs['operation'],'operation',[],'unmatched');return + candidates.sort(key=lambda x:-x['score']);top=candidates[0];ties=[x for x in candidates if abs(x['score']-top['score'])<.05] + status='matched' if top['score']>=.92 and len(ties)==1 else 'ambiguous' if len(candidates)>1 else 'near-match' + self._record_candidates(obs['operation'],'operation',candidates,status) + if status!='matched':return + md={'signals':top['signals'],'score':top['score']};ts=obs['observed_at'];sr=obs['sample_ref'] + self.rel(obs['operation'],'fiam.relation.corresponds-to',top['declared_ref'],'reconcile:http',ts,confidence=.97,metadata=md,sample_ref=sr) + self.rel(obs['binding'],'fiam.relation.corresponds-to',top['binding_ref'],'reconcile:http',ts,confidence=.96,metadata=md,sample_ref=sr) + if obs.get('endpoint') and top.get('endpoint_ref'):self.rel(obs['endpoint'],'fiam.relation.corresponds-to',top['endpoint_ref'],'reconcile:http',ts,confidence=.95,metadata=md,sample_ref=sr) + if obs.get('node') and top.get('node_ref'):self.rel(obs['node'],'fiam.relation.corresponds-to',top['node_ref'],'reconcile:http',ts,confidence=.94,metadata=md,sample_ref=sr) + + def reconcile_rpc(self,system,method,nodeid,opid,bid,eid,kind,peer_name,sample_ref,ts): + if not self.base:return + proto=rpc_protocol_term(system);c=[] + for d in self.declared_rpc: + b=self.idx.get(d['binding'],{});score=0;signals=[] + if proto and any(x.get('term')==proto for x in b.get('communication_stack',[]) or []):score+=.2;signals.append('rpc-protocol') + if d['method']==method:score+=.6;signals.append('rpc-method-exact') + elif terminal_method(d['method'])==terminal_method(method):score+=.42;signals.append('rpc-method-terminal') + if peer_name and d.get('node'): + dn=(self.idx.get(d['node']) or {}).get('name') + if dn and str(dn).lower()==str(peer_name).lower():score+=.2;signals.append('service-peer-name') + if score>=.4:c.append({'declared_ref':d['operation'],'binding_ref':d['binding'],'node_ref':d.get('node'),'score':round(score,3),'signals':signals}) + if not c:self._record_candidates(opid,'operation',[],'unmatched');return + c.sort(key=lambda x:-x['score']);top=c[0];ties=[x for x in c if abs(x['score']-top['score'])<.05];status='matched' if top['score']>=.8 and len(ties)==1 else 'ambiguous' if len(c)>1 else 'near-match';self._record_candidates(opid,'operation',c,status) + if status=='matched': + md={'signals':top['signals'],'score':top['score']};self.rel(opid,'fiam.relation.corresponds-to',top['declared_ref'],'reconcile:rpc',ts,confidence=.96,metadata=md,sample_ref=sample_ref);self.rel(bid,'fiam.relation.corresponds-to',top['binding_ref'],'reconcile:rpc',ts,confidence=.95,metadata=md,sample_ref=sample_ref) + + def reconcile_messaging(self,system,dest,nodeid,opid,bid,chid,role,sample_ref,ts): + if not self.base:return + c=[] + for d in self.declared_msg: + score=0;signals=[] + if str(d.get('name',''))==str(dest):score+=.7;signals.append('destination-name') + ch=self.idx.get(d['channel'],{});owner=self.idx.get(ch.get('owner'),{}) + if str((owner.get('facets') or {}).get('runtime_system','')).lower()==str(system).lower():score+=.2;signals.append('messaging-system') + if score:c.append({'declared_ref':d['channel'],'score':round(score,3),'signals':signals}) + if c: + c.sort(key=lambda x:-x['score']);top=c[0];ties=[x for x in c if abs(x['score']-top['score'])<.05];status='matched' if top['score']>=.7 and len(ties)==1 else 'ambiguous';self._record_candidates(chid,'channel',c,status) + if status=='matched':self.rel(chid,'fiam.relation.corresponds-to',top['declared_ref'],'reconcile:messaging',ts,confidence=.96,metadata={'signals':top['signals']},sample_ref=sample_ref) + + def reconcile_database(self,system,collection,namespace,effect,nodeid,opid,bid,eid,rid,sample_ref,ts): + if not self.base:return + c=[] + if rid: + for d in self.declared_db: + score=0;signals=[] + if collection and str(d.get('name',''))==str(collection):score+=.75;signals.append('collection-name') + elif collection and str(d.get('name','')).split('.')[-1]==str(collection).split('.')[-1]:score+=.48;signals.append('collection-terminal-name') + if score:c.append({'declared_ref':d['resource'],'score':round(score,3),'signals':signals}) + if c: + c.sort(key=lambda x:-x['score']);top=c[0];ties=[x for x in c if abs(x['score']-top['score'])<.05];status='matched' if top['score']>=.7 and len(ties)==1 else 'ambiguous';self._record_candidates(rid,'information-resource',c,status) + if status=='matched':self.rel(rid,'fiam.relation.corresponds-to',top['declared_ref'],'reconcile:database',ts,confidence=.96,metadata={'signals':top['signals']},sample_ref=sample_ref) + + # ---------- per-domain mapping ---------- + def process_http_server(self,service,namespace,scope,span,a,ra): + nodeid,z,zones,trace,sid,ts,sample_ref,kind,fac=self.span_context(service,namespace,scope,span,ra);method=str(a.get('http.request.method') or a.get('http.method') or '').upper();route=a.get('http.route');route_key=normalize_route(route) if route else 'unknown-route';host=str(a.get('server.address') or '');port=a.get('server.port');scheme=str(a.get('url.scheme') or ('https' if int(port or 0)==443 else 'http'));proto_version=a.get('network.protocol.version');proto=http_protocol_term(proto_version) + zonekey=self.zone_key(z);cid=identity_id('contract.otel.http',service,'http-contract',nodeid);pid=identity_id('port.otel.http',service,'http-port',nodeid,cid);opid=identity_id('operation.otel.http',f'{method}-{route_key}','http-op',cid,method,route_key) + add_unique(self.model,'ports',{'id':pid,'kind':'port','owner':nodeid,'participations':[{'contract':cid,'mode':'offers','roles':['fiam.role.server']}]});self.idx,self.kinds,self.op_contract=entity_index(self.model) + self.ensure_contract_operation(cid,f'Observed HTTP surface — {service}',{'id':opid,'kind':'operation','name':f'{method} {route_key}','interaction_style':'fiam.interaction-style.request-response','x-http-method':method,'x-http-route':route_key}) + addr=origin(scheme,host,port);eid=self.ensure_endpoint('endpoint.otel.http',host or 'unlocated',addr,'fiam.address-scheme.https-url' if scheme=='https' else 'fiam.address-scheme.http-url',z,{'logical_server_address':host}) + bid=identity_id('binding.otel.http',f'{service}-{host or "unlocated"}','http-binding',nodeid,host,port,zonekey);stack=[{'role':'fiam.stack-role.application-transfer-protocol','term':proto}]; + if scheme=='https':stack.append({'role':'fiam.stack-role.security-protocol','term':'fiam.protocol.tls'}) + b=add_unique(self.model,'bindings',{'id':bid,'kind':'binding','contract':cid,'provider_port':pid,'endpoints':[eid],'communication_stack':stack,'operations':[opid],'facets':{'identity_tuple':{'kind':'http-binding','service_node':nodeid,'server_address':host,'server_port':port,'zone':zonekey}}});self.idx[bid]=b;self.kinds[bid]='binding' + peer_addr=a.get('network.peer.address');peer_name=a.get('service.peer.name') or a.get('peer.service') + error=bool(a.get('error.type')) or (isinstance(a.get('http.response.status_code'),int) and int(a['http.response.status_code'])>=500) + agg=self.aggregate('http','server',opid,bid,nodeid,ts,sample_ref,error,extra={'method':method,'route':route_key}) + inter={'operation':opid,'contract':cid,'binding':bid,'interaction_style':'fiam.interaction-style.request-response','execution_boundary':'fiam.execution-boundary.remote-network','realization_status':'fiam.interaction-status.failed' if error else 'fiam.interaction-status.completed','participants':{'responder':nodeid},'facets':fac};iid=self.keep_interaction(agg,trace,sid,inter) + self.record_span(trace,sid,aggregate=agg['id'],interaction=iid,node=nodeid,domain='http',role='server',binding=bid,operation=opid,peer_name=peer_name,server_address=host,parent=span.get('parentSpanId'),links=fac.get('otel_links',[])) + if not route: + uid=f'unresolved.http-route.{digest(trace,sid,n=20)}';self.unresolved[uid]={'id':uid,'domain':'http','reason':'HTTP span has no low-cardinality http.route; mapped to unknown-route and raw url.path was not promoted into architecture identity','sample_span':sample_ref} + self.prop(nodeid,'fiam.property.service-name',service,'attribute:service.name',ts,sample_ref=sample_ref) + if namespace:self.prop(nodeid,'fiam.property.service-namespace',namespace,'attribute:service.namespace',ts,sample_ref=sample_ref) + self.prop(opid,'fiam.property.http-method',method,'attribute:http.request.method',ts,sample_ref=sample_ref) + if route:self.prop(opid,'fiam.property.http-route',normalize_route(route),'attribute:http.route',ts,sample_ref=sample_ref) + self.prop(bid,'fiam.property.communication-protocol',proto,'attribute:network.protocol.version',ts,sample_ref=sample_ref) + if proto_version is not None:self.prop(bid,'fiam.property.network-protocol-version',str(proto_version),'attribute:network.protocol.version',ts,sample_ref=sample_ref) + if host:self.prop(eid,'fiam.property.server-address',host,'attribute:server.address',ts,sample_ref=sample_ref) + if port is not None:self.prop(eid,'fiam.property.server-port',int(port),'attribute:server.port',ts,sample_ref=sample_ref) + if peer_addr:self.prop(eid,'fiam.property.network-peer-address',str(peer_addr),'attribute:network.peer.address',ts,sample_ref=sample_ref) + if peer_name:self.prop(bid,'fiam.property.service-peer-name',str(peer_name),'attribute:service.peer.name',ts,sample_ref=sample_ref) + if iid and a.get('http.response.status_code') is not None:self.prop(iid,'fiam.property.http-response-status-code',int(a['http.response.status_code']),'attribute:http.response.status_code',ts,sample_ref=sample_ref) + self.reconcile_local_node(nodeid,service,namespace,z,sample_ref,ts);self.reconcile_http({'method':method,'route':route,'host':host,'operation':opid,'binding':bid,'endpoint':eid,'node':nodeid,'sample_ref':sample_ref,'observed_at':ts}) + + def process_rpc(self,service,namespace,scope,span,a,ra): + nodeid,z,zones,trace,sid,ts,sample_ref,kind,fac=self.span_context(service,namespace,scope,span,ra);system=str(a.get('rpc.system.name') or a.get('rpc.system') or '').lower();method=str(a.get('rpc.method') or 'unknown-rpc-method');peer_name=a.get('service.peer.name') or a.get('peer.service');addr=host_port(a.get('server.address'),a.get('server.port'));role='client' if kind=='client' else 'server' + cid=identity_id('contract.otel.rpc',f'{service}-{system}',nodeid,system);pid=identity_id('port.otel.rpc',f'{service}-{system}-{role}',nodeid,cid,role);opid=identity_id('operation.otel.rpc',terminal_method(method) or method,cid,method) + add_unique(self.model,'ports',{'id':pid,'kind':'port','owner':nodeid,'participations':[{'contract':cid,'mode':'requires' if role=='client' else 'offers','roles':['fiam.role.client' if role=='client' else 'fiam.role.server']}]});self.ensure_contract_operation(cid,f'Observed {system or "RPC"} surface — {service}',{'id':opid,'kind':'operation','name':method,'interaction_style':'fiam.interaction-style.rpc','x-rpc-method':method}) + eid=None;endpoints=[] + if addr:eid=self.ensure_endpoint('endpoint.otel.rpc',addr,addr,'fiam.address-scheme.host-port',z,{'logical_server_address':a.get('server.address')});endpoints=[eid] + bid=identity_id('binding.otel.rpc',f'{service}-{system}-{addr or "unlocated"}-{role}',nodeid,system,addr,role,self.zone_key(z));proto=rpc_protocol_term(system);stack=[] + if proto:stack.append({'role':'fiam.stack-role.rpc-protocol','term':proto}) + b={'id':bid,'kind':'binding','contract':cid,'operations':[opid],'communication_stack':stack,'facets':{'identity_tuple':{'kind':'rpc-binding','service_node':nodeid,'system':system,'logical_address':addr,'role':role,'zone':self.zone_key(z)}}}; + if role=='server':b['provider_port']=pid + else:b['consumer_ports']=[pid] + if endpoints:b['endpoints']=endpoints + add_unique(self.model,'bindings',b);self.idx,self.kinds,self.op_contract=entity_index(self.model) + remote_node=None + if role=='client' and peer_name:remote_node=self.ensure_target_node('service',str(peer_name),str(peer_name),system,z) + error=bool(a.get('error.type')) or str(a.get('rpc.response.status_code') or '').upper() not in {'','OK','0'} + agg=self.aggregate('rpc',role,opid,bid,nodeid,ts,sample_ref,error,remote_node=remote_node,extra={'rpc_system':system,'rpc_method':method}) + parts={'initiator':nodeid} if role=='client' else {'responder':nodeid}; + if remote_node and role=='client':parts['responder']=remote_node + iid=self.keep_interaction(agg,trace,sid,{'operation':opid,'contract':cid,'binding':bid,'interaction_style':'fiam.interaction-style.rpc','temporal_semantics':'fiam.temporal.synchronous','execution_boundary':'fiam.execution-boundary.remote-network','realization_status':'fiam.interaction-status.failed' if error else 'fiam.interaction-status.completed','participants':parts,'facets':fac}) + self.record_span(trace,sid,aggregate=agg['id'],interaction=iid,node=nodeid,domain='rpc',role=role,binding=bid,operation=opid,peer_name=peer_name,server_address=a.get('server.address'),parent=span.get('parentSpanId'),links=fac.get('otel_links',[])) + self.prop(nodeid,'fiam.property.service-name',service,'attribute:service.name',ts,sample_ref=sample_ref);self.prop(opid,'fiam.property.rpc-system-name',system,'attribute:rpc.system.name',ts,sample_ref=sample_ref);self.prop(opid,'fiam.property.rpc-method',method,'attribute:rpc.method',ts,sample_ref=sample_ref) + if namespace:self.prop(nodeid,'fiam.property.service-namespace',namespace,'attribute:service.namespace',ts,sample_ref=sample_ref) + if proto:self.prop(bid,'fiam.property.communication-protocol',proto,'attribute:rpc.system.name',ts,sample_ref=sample_ref) + if peer_name:self.prop(bid,'fiam.property.service-peer-name',str(peer_name),'attribute:service.peer.name',ts,sample_ref=sample_ref) + if eid and a.get('network.peer.address'):self.prop(eid,'fiam.property.network-peer-address',str(a['network.peer.address']),'attribute:network.peer.address',ts,sample_ref=sample_ref) + self.reconcile_local_node(nodeid,service,namespace,z,sample_ref,ts);self.reconcile_rpc(system,method,nodeid,opid,bid,eid,kind,peer_name,sample_ref,ts) + + def messaging_role(self,op_type,kind): + t=str(op_type or '').lower() + if t in {'create','send'}:return 'producer' + if t in {'process','receive'}:return 'consumer' + return 'producer' if kind=='producer' else 'consumer' if kind=='consumer' else 'client' if kind=='client' else kind + + def process_messaging(self,service,namespace,scope,span,a,ra): + nodeid,z,zones,trace,sid,ts,sample_ref,kind,fac=self.span_context(service,namespace,scope,span,ra);system=str(a.get('messaging.system') or '').lower();dest=str(a.get('messaging.destination.name') or 'unknown-destination');op_type=str(a.get('messaging.operation.type') or 'unknown');op_name=str(a.get('messaging.operation.name') or op_type or 'unknown-messaging-operation');role=self.messaging_role(op_type,kind);addr=host_port(a.get('server.address'),a.get('server.port'));peer_name=a.get('service.peer.name') or a.get('peer.service') + cid=identity_id('contract.otel.messaging',f'{service}-{system}',nodeid,system);pid=identity_id('port.otel.messaging',f'{service}-{system}-{role}',nodeid,cid,role);opid=identity_id('operation.otel.messaging',f'{op_type}-{dest}',cid,op_type,dest,role) + add_unique(self.model,'ports',{'id':pid,'kind':'port','owner':nodeid,'participations':[{'contract':cid,'mode':'requires' if role in {'producer','consumer','client'} else 'offers','roles':['fiam.role.producer' if role=='producer' else 'fiam.role.consumer' if role=='consumer' else 'fiam.role.client']}]});self.ensure_contract_operation(cid,f'Observed {system or "messaging"} surface — {service}',{'id':opid,'kind':'operation','name':op_name,'interaction_style':'fiam.interaction-style.publish' if role=='producer' else 'fiam.interaction-style.subscribe' if role=='consumer' else 'fiam.interaction-style.command'}) + broker=self.ensure_target_node('broker',f'{system or "Broker"} at {addr or "unknown"}',addr,system,z) if addr else None;chid=identity_id('channel.otel.messaging',dest,system,addr,dest,*self.zone_key(z));ch={'id':chid,'kind':'channel','name':dest,'channel_type':'fiam.channel.durable-topic' if system=='kafka' else 'fiam.channel.message-destination','mediation':'fiam.mediation.brokered','facets':{'identity_tuple':{'kind':'messaging-channel','system':system,'logical_broker':addr,'destination':dest,'zone':self.zone_key(z)}}}; + if broker:ch['owner']=broker + add_unique(self.model,'channels',ch);self.idx[chid]=ch;self.kinds[chid]='channel';bid=identity_id('binding.otel.messaging',f'{service}-{system}-{dest}-{role}',nodeid,system,addr,dest,role,*self.zone_key(z));proto=messaging_protocol_term(system);stack=[] + if proto:stack.append({'role':'fiam.stack-role.broker-protocol','term':proto}) + b={'id':bid,'kind':'binding','contract':cid,'consumer_ports':[pid],'operations':[opid],'communication_stack':stack,'channel':chid,'facets':{'identity_tuple':{'kind':'messaging-binding','service_node':nodeid,'system':system,'destination':dest,'role':role,'zone':self.zone_key(z)}}};add_unique(self.model,'bindings',b);self.idx,self.kinds,self.op_contract=entity_index(self.model) + error=bool(a.get('error.type'));agg=self.aggregate('messaging',role,opid,bid,nodeid,ts,sample_ref,error,channel=chid,remote_node=broker,extra={'messaging_system':system,'operation_type':op_type}) + parts={role:nodeid}; + if broker:parts['broker']=broker + iid=self.keep_interaction(agg,trace,sid,{'operation':opid,'contract':cid,'binding':bid,'channel':chid,'interaction_style':'fiam.interaction-style.publish' if role=='producer' else 'fiam.interaction-style.subscribe' if role=='consumer' else 'fiam.interaction-style.command','temporal_semantics':'fiam.temporal.asynchronous','execution_boundary':'fiam.execution-boundary.remote-network','realization_status':'fiam.interaction-status.failed' if error else 'fiam.interaction-status.completed','participants':parts,'facets':fac}) + self.record_span(trace,sid,aggregate=agg['id'],interaction=iid,node=nodeid,domain='messaging',role=role,binding=bid,operation=opid,channel=chid,peer_name=peer_name,server_address=a.get('server.address'),parent=span.get('parentSpanId'),links=fac.get('otel_links',[])) + self.prop(nodeid,'fiam.property.service-name',service,'attribute:service.name',ts,sample_ref=sample_ref);self.prop(opid,'fiam.property.messaging-system',system,'attribute:messaging.system',ts,sample_ref=sample_ref);self.prop(chid,'fiam.property.messaging-destination-name',dest,'attribute:messaging.destination.name',ts,sample_ref=sample_ref);self.prop(opid,'fiam.property.messaging-operation-type',op_type,'attribute:messaging.operation.type',ts,sample_ref=sample_ref);self.prop(opid,'fiam.property.messaging-operation-name',op_name,'attribute:messaging.operation.name',ts,sample_ref=sample_ref) + if namespace:self.prop(nodeid,'fiam.property.service-namespace',namespace,'attribute:service.namespace',ts,sample_ref=sample_ref) + if proto:self.prop(bid,'fiam.property.communication-protocol',proto,'attribute:messaging.system',ts,sample_ref=sample_ref) + if peer_name:self.prop(bid,'fiam.property.service-peer-name',str(peer_name),'attribute:service.peer.name',ts,sample_ref=sample_ref) + self.reconcile_local_node(nodeid,service,namespace,z,sample_ref,ts);self.reconcile_messaging(system,dest,nodeid,opid,bid,chid,role,sample_ref,ts) + + def process_database(self,service,namespace,scope,span,a,ra): + nodeid,z,zones,trace,sid,ts,sample_ref,kind,fac=self.span_context(service,namespace,scope,span,ra);system=str(a.get('db.system.name') or a.get('db.system') or '').lower();collection=a.get('db.collection.name');dbns=a.get('db.namespace');opname=str(a.get('db.operation.name') or 'unknown-db-operation');effect=db_effect(opname);addr=host_port(a.get('server.address'),a.get('server.port')) + cid=identity_id('contract.otel.db',f'{service}-{system}',nodeid,system);pid=identity_id('port.otel.db',f'{service}-{system}',nodeid,cid);opid=identity_id('operation.otel.db',f'{opname}-{collection or "namespace"}',cid,opname,collection or '',dbns or '') + add_unique(self.model,'ports',{'id':pid,'kind':'port','owner':nodeid,'participations':[{'contract':cid,'mode':'requires','roles':['fiam.role.database-client']}]});op={'id':opid,'kind':'operation','name':opname,'interaction_style':'fiam.interaction-style.query' if effect=='read' else 'fiam.interaction-style.command'} + if effect:op['effect']='fiam.effect.read' if effect=='read' else 'fiam.effect.write' + self.ensure_contract_operation(cid,f'Observed {system or "database"} client surface — {service}',op);dbnode=self.ensure_target_node('database',f'{system or "Database"} at {addr or "unknown"}',addr,system,z) if addr else None;eid=None;endpoints=[] + if addr:eid=self.ensure_endpoint('endpoint.otel.db',addr,addr,'fiam.address-scheme.host-port',z,{'logical_server_address':a.get('server.address')});endpoints=[eid] + bid=identity_id('binding.otel.db',f'{service}-{system}-{addr or "unlocated"}',nodeid,system,addr,*self.zone_key(z));proto=database_protocol_term(system);stack=[] + if proto:stack.append({'role':'fiam.stack-role.database-protocol','term':proto}) + b={'id':bid,'kind':'binding','contract':cid,'consumer_ports':[pid],'operations':[opid],'communication_stack':stack,'facets':{'identity_tuple':{'kind':'database-binding','service_node':nodeid,'system':system,'logical_address':addr,'zone':self.zone_key(z)}}}; + if endpoints:b['endpoints']=endpoints + add_unique(self.model,'bindings',b);self.idx,self.kinds,self.op_contract=entity_index(self.model);rid=None + if collection or dbns: + label=str(collection or dbns);rkind='fiam.information-resource.relational-table' if collection and system in {'postgresql','postgres'} else 'fiam.information-resource.database-collection' if collection else 'fiam.information-resource.database-namespace';rid=identity_id('resource.otel.db',label,system,addr,dbns or '',collection or '',*self.zone_key(z));r={'id':rid,'kind':'information-resource','name':label,'resource_kind':rkind,'resource_scope':'fiam.resource-scope.concrete-collection','selectors':[],'facets':{'identity_tuple':{'kind':'database-resource','system':system,'logical_server':addr,'namespace':dbns,'collection':collection,'zone':self.zone_key(z)}}} + if dbnode:r['owner']=dbnode + if collection and system in {'postgresql','postgres'}:r['selectors'].append({'kind':'fiam.resource-selector.sql-qualified-name','value':str(collection)}) + add_unique(self.model,'information_resources',r);self.idx[rid]=r;self.kinds[rid]='information-resource' + error=bool(a.get('error.type'));agg=self.aggregate('database','client',opid,bid,nodeid,ts,sample_ref,error,resource=rid,remote_node=dbnode,extra={'database_system':system,'effect':effect}) + parts={'initiator':nodeid}; + if dbnode:parts['responder']=dbnode + iid=self.keep_interaction(agg,trace,sid,{'operation':opid,'contract':cid,'binding':bid,'interaction_style':op['interaction_style'],'temporal_semantics':'fiam.temporal.synchronous','execution_boundary':'fiam.execution-boundary.remote-network','realization_status':'fiam.interaction-status.failed' if error else 'fiam.interaction-status.completed','participants':parts,'facets':fac}) + self.record_span(trace,sid,aggregate=agg['id'],interaction=iid,node=nodeid,domain='database',role='client',binding=bid,operation=opid,resource=rid,server_address=a.get('server.address'),parent=span.get('parentSpanId'),links=fac.get('otel_links',[])) + self.prop(nodeid,'fiam.property.service-name',service,'attribute:service.name',ts,sample_ref=sample_ref);self.prop(bid,'fiam.property.database-system-name',system,'attribute:db.system.name',ts,sample_ref=sample_ref);self.prop(opid,'fiam.property.database-operation-name',opname,'attribute:db.operation.name',ts,sample_ref=sample_ref) + if namespace:self.prop(nodeid,'fiam.property.service-namespace',namespace,'attribute:service.namespace',ts,sample_ref=sample_ref) + if dbns:self.prop(rid or bid,'fiam.property.database-namespace',str(dbns),'attribute:db.namespace',ts,sample_ref=sample_ref) + if collection and rid:self.prop(rid,'fiam.property.database-collection-name',str(collection),'attribute:db.collection.name',ts,sample_ref=sample_ref) + if proto:self.prop(bid,'fiam.property.communication-protocol',proto,'attribute:db.system.name',ts,sample_ref=sample_ref) + if eid and a.get('network.peer.address'):self.prop(eid,'fiam.property.network-peer-address',str(a['network.peer.address']),'attribute:network.peer.address',ts,sample_ref=sample_ref) + # db.query.text / db.query.parameter.* are intentionally ignored. + if iid and rid: + pred='fiam.relation.reads-from' if effect=='read' else 'fiam.relation.writes-to' if effect=='write' else 'fiam.relation.targets';self.rel(iid,pred,rid,'inference:database-operation-effect',ts,mode='fiam.evidence.inferred',confidence=.97,source_type='database-operation-semantics',sample_ref=sample_ref,metadata={'db.operation.name':opname}) + if rid:self.rel(opid,'fiam.relation.targets',rid,'attribute:db.collection.name' if collection else 'attribute:db.namespace',ts,mode='fiam.evidence.inferred',confidence=.92,source_type='database-resource-mapping',sample_ref=sample_ref) + self.reconcile_local_node(nodeid,service,namespace,z,sample_ref,ts);self.reconcile_database(system,collection,dbns,effect,nodeid,opid,bid,eid,rid,sample_ref,ts) + + def process_generic(self,service,namespace,scope,span,a,ra): + nodeid,z,zones,trace,sid,ts,sample_ref,kind,fac=self.span_context(service,namespace,scope,span,ra);self.prop(nodeid,'fiam.property.service-name',service,'attribute:service.name',ts,sample_ref=sample_ref) + if namespace:self.prop(nodeid,'fiam.property.service-namespace',namespace,'attribute:service.namespace',ts,sample_ref=sample_ref) + # Generic spans do not create catalog Interactions; evidence remains at the Node. + + # ---------- topology correlation without storing every span ---------- + def _topology(self,kind,key,record): + tid=f'topology.otel.{kind}.{digest(key,n=20)}';old=self.topo.get(tid) + if not old:old={'id':tid,'domain':kind,'count':0,'first_seen':record.get('first_seen'),'last_seen':record.get('last_seen'),'sample_correlations':[],**{k:v for k,v in record.items() if k not in {'count','first_seen','last_seen','sample_correlations'}}};self.topo[tid]=old + if not self.already_processed:old['count']=int(old.get('count',0))+int(record.get('count',1));old['first_seen']=iso_min(old.get('first_seen'),record.get('first_seen'));old['last_seen']=iso_max(old.get('last_seen'),record.get('last_seen')) + for s in record.get('sample_correlations') or []: + if s not in old.setdefault('sample_correlations',[]) and len(old['sample_correlations']){server.get("interaction") or sid}'],'correlation':'trace-parent','via_gateway':via_gateway} + if via_gateway:rec['gateway']=gateway;rec['intended_target']=intended + self._topology('rpc',(rec['from'],rec['to'],rec['binding'],rec['operation'],via_gateway,intended),rec) + for (trace,sid),client in sorted(self.span_records.items()): + if client.get('domain')=='rpc' and client.get('role')=='client' and (trace,sid) not in paired_rpc_clients: + uid=f'unresolved.rpc-client.{digest(trace,sid,n=20)}';self.unresolved[uid]={'id':uid,'domain':'rpc','reason':'client span has no observed server child in this batch; topology remains partial under sampling','sample_span':self._sample_ref(trace,sid)} + # Messaging causality uses span links. Producer-only without link remains useful but unresolved for downstream topology. + for (trace,sid),consumer in sorted(self.span_records.items()): + if consumer.get('domain')!='messaging' or consumer.get('role')!='consumer':continue + matched=False + for link in consumer.get('links') or []: + try:ltrace,lspan=link.split(':',1) + except ValueError:continue + producer=self.span_records.get((ltrace,lspan)) + if not producer or producer.get('domain')!='messaging' or producer.get('role')!='producer':continue + matched=True;rec={'kind':'mediated-message-flow','from':producer.get('node'),'to':consumer.get('node'),'via_channel':consumer.get('channel') or producer.get('channel'),'first_seen':self.aggs.get(producer.get('aggregate'),{}).get('first_seen'),'last_seen':self.aggs.get(consumer.get('aggregate'),{}).get('last_seen'),'sample_correlations':[link],'correlation':'span-link'};self._topology('messaging',(rec['from'],rec['to'],rec['via_channel']),rec) + if not matched: + uid=f'unresolved.messaging.{digest(trace,sid,n=20)}';self.unresolved[uid]={'id':uid,'domain':'messaging','reason':'consumer/receive span has no resolvable producer span link in this batch','sample_span':self._sample_ref(trace,sid)} + # Producer spans with no downstream link are explicitly partial, not a failure. + linked_sources={s for r in self.span_records.values() for s in (r.get('links') or [])} + for (trace,sid),r in sorted(self.span_records.items()): + if r.get('domain')=='messaging' and r.get('role')=='producer' and f'{trace}:{sid}' not in linked_sources: + uid=f'unresolved.messaging-producer.{digest(trace,sid,n=20)}';self.unresolved[uid]={'id':uid,'domain':'messaging','reason':'producer span has no observed downstream linked span in this batch','sample_span':self._sample_ref(trace,sid),'channel':r.get('channel')} + # DB resource access needs no trace pair. + for (trace,sid),r in self.span_records.items(): + if r.get('domain')!='database':continue + if not r.get('resource'): + uid=f'unresolved.database.{digest(trace,sid,n=20)}';self.unresolved[uid]={'id':uid,'domain':'database','reason':'database span identifies a system/operation but no stable namespace or collection resource','sample_span':self._sample_ref(trace,sid)};continue + agg=self.aggs.get(r.get('aggregate'),{});effect=(agg.get('effect') or '') + rec={'kind':'resource-read' if effect=='read' else 'resource-write' if effect=='write' else 'resource-access','from':r.get('node'),'to_resource':r.get('resource'),'binding':r.get('binding'),'first_seen':agg.get('first_seen'),'last_seen':agg.get('last_seen'),'sample_correlations':agg.get('sample_spans',[])[:1],'correlation':'span-resource'};self._topology('database',(rec['from'],rec['to_resource'],rec['kind'],rec['binding']),rec) + + def finalize_catalog(self): + # Close activity only for explicitly authoritative snapshots; absence in sampled traces is NOT absence in architecture. + if self.authoritative_snapshot: + for aid,agg in self.aggs.items(): + if aid in self.batch_seen_aggs:continue + key=aid.split('.')[-1];facets={'aggregation_key':key,'domain':agg.get('domain'),'role':agg.get('role'),'operation_ref':agg.get('operation'),'local_node_ref':agg.get('local_node')} + if agg.get('channel'):facets['channel_ref']=agg['channel'] + if agg.get('resource'):facets['resource_ref']=agg['resource'] + self.stat(agg.get('binding'),'fiam.property.runtime-active',False,key,agg.get('first_seen'),self.batch_last or agg.get('last_seen'),facets,agg.get('sample_spans',[])) + if not self.already_processed:self.catalog.setdefault('processed_batches',[]).append(self.batch_hash) + self.catalog['processed_batches']=sorted(set(self.catalog.get('processed_batches') or [])); + if self.batch_last:self.catalog['last_ingest_at']=self.batch_last + self.catalog['runtime_policy']='aggregate-by-architectural-tuple';self.catalog['occurrence_retention']=self.occurrences;self.catalog['sample_size']=self.sample_size + self.ext[AGG_EXT]=sorted(self.aggs.values(),key=lambda x:x['id']);self.ext[TOPO_EXT]=sorted(self.topo.values(),key=lambda x:x['id']);self.ext[UNRESOLVED_EXT]=sorted(self.unresolved.values(),key=lambda x:x['id']);self.ext[RECON_EXT]=sorted(self.recon.values(),key=lambda x:x['observed_ref']) + # Artifact describes bounded samples, not every occurrence. + art=self.idx.get(self.artifact_id) or next((x for x in self.model.get('artifacts',[]) or [] if x.get('id')==self.artifact_id),None) + if art:art['describes']=sorted(set((art.get('describes') or [])+self.interactions_retained)) + # deterministic array ordering makes catalog updates reproducible. + for sec in ('participants','nodes','ports','contracts','endpoints','bindings','channels','information_resources','information_shapes','interactions','interaction_flows','artifacts','zones','security','assertions'): + if sec in self.model: + if sec=='contracts': + for c in self.model[sec]:c['operations']=sorted(c.get('operations',[]),key=lambda x:x.get('id','')) + self.model[sec]=sorted(self.model[sec],key=lambda x:x.get('id','')) + return self.model + + def build(self): + self.ensure_artifact() + if self.already_processed: + # Same batch + same catalog is exactly idempotent; no counters/timestamps advance. + return self.finalize_catalog() + for obj in self.objects: + if not isinstance(obj,dict) or 'resourceSpans' not in obj:raise ValueError('Input is not OTLP/JSON TracesData: missing resourceSpans') + for rs in obj.get('resourceSpans',[]) or []: + ra=attrs((rs.get('resource') or {}).get('attributes'));service=str(ra.get('service.name') or 'unknown_service');namespace=str(ra.get('service.namespace') or '') + for ss in rs.get('scopeSpans',[]) or []: + scope=(ss.get('scope') or {}).get('name') or '' + for span in ss.get('spans',[]) or []: + if not isinstance(span.get('kind',0),int):raise ValueError('OTLP/JSON span.kind must be encoded as an integer enum value') + for key,n in [('traceId',32),('spanId',16)]: + v=span.get(key) + if v and (len(v)!=n or not re.fullmatch(r'[0-9A-Fa-f]+',v)):raise ValueError(f'{key} must be {n} hexadecimal characters in OTLP/JSON') + a=attrs(span.get('attributes'));is_http=bool(a.get('http.request.method') or a.get('http.method'));is_rpc=bool(a.get('rpc.system.name') or a.get('rpc.system'));is_msg=bool(a.get('messaging.system'));is_db=bool(a.get('db.system.name') or a.get('db.system')) + if span.get('kind')==2 and is_http:self.process_http_server(service,namespace,scope,span,a,ra) + elif is_rpc and span.get('kind') in {2,3}:self.process_rpc(service,namespace,scope,span,a,ra) + elif is_msg:self.process_messaging(service,namespace,scope,span,a,ra) + elif is_db and span.get('kind') in {1,3}:self.process_database(service,namespace,scope,span,a,ra) + else:self.process_generic(service,namespace,scope,span,a,ra) + self.build_correlations();return self.finalize_catalog() + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('input',type=Path);ap.add_argument('-o','--output',type=Path,required=True);ap.add_argument('--base',type=Path,help='Existing declared model or FIAM runtime catalog to update incrementally.');ap.add_argument('--source-url',help='Stable stream/source identifier. Strongly recommended for incremental catalogs.');ap.add_argument('--occurrences',choices=['none','sample','all'],default='sample');ap.add_argument('--sample-size',type=int,default=3);ap.add_argument('--authoritative-snapshot',action='store_true',help='Deprecated/disabled in draft.6. Use Catalog Exchange complete-snapshot plus Snapshot Authority Policy for closure.') + args=ap.parse_args(); + if args.authoritative_snapshot: + ap.error('--authoritative-snapshot is disabled in v0.2-draft.6; completeness/closure requires Catalog Exchange plus a validated Snapshot Authority Policy') + objects=load_otlp(args.input);base=yaml.safe_load(args.base.read_text()) if args.base else None;out=Importer(objects,args.input,base,args.source_url,args.occurrences,args.sample_size,False).build();args.output.parent.mkdir(parents=True,exist_ok=True);args.output.write_text(yaml.safe_dump(out,sort_keys=False,allow_unicode=True,width=120),encoding='utf-8') + ext=out.get('extensions',{});aggs=len(ext.get(AGG_EXT,[]) or []);samples=len(out.get('interactions',[]) or []);runtime=sum(1 for a in out.get('assertions',[]) or [] if any(e.get('mode')=='fiam.evidence.runtime-observed' for e in evidence_records(a)));print(f'wrote {args.output}: {aggs} architectural runtime aggregates, {samples} retained Interaction samples, {runtime} runtime assertions') +if __name__=='__main__':main() diff --git a/history/FIAM_v0.2_Draft6/tools/runtime_topology_lens.py b/history/FIAM_v0.2_Draft6/tools/runtime_topology_lens.py new file mode 100755 index 0000000..a9dd212 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/runtime_topology_lens.py @@ -0,0 +1,71 @@ +#!/usr/bin/env python3 +"""Execute the FIAM Runtime Topology Lens over estate-oriented runtime aggregates.""" +from __future__ import annotations +import argparse +from pathlib import Path +import yaml +try: + from working_set_view import execute as working_view +except Exception: + working_view=None + +TOPO_EXT='org.fiam.runtime_topology_observations';UNRESOLVED_EXT='org.fiam.runtime_unresolved' + +def index(doc): + objs={};kinds={} + for sec,kind in [('nodes','system-node'),('ports','port'),('contracts','interface-contract'),('endpoints','endpoint'),('bindings','binding'),('channels','channel'),('information_resources','information-resource'),('information_shapes','information-shape'),('interactions','interaction'),('interaction_flows','interaction-flow'),('artifacts','artifact')]: + for x in doc.get(sec,[]) or []: + if x.get('id'):objs[x['id']]=x;kinds[x['id']]=kind + if sec=='contracts': + for o in x.get('operations',[]) or []: + if o.get('id'):objs[o['id']]=o;kinds[o['id']]='operation' + return objs,kinds + +def execute(doc,lens,working_set=True): + obj,kinds=index(doc);ext=doc.get('extensions',{}) or {};topo=ext.get(TOPO_EXT,[]) or [];unresolved=list(ext.get(UNRESOLVED_EXT,[]) or []) + ws=working_view(doc) if working_set and working_view else {'preferred_ref_by_observed':{}};pref=ws.get('preferred_ref_by_observed',{}) + def p(ref):return pref.get(ref,ref) + edges=[] + for x in topo: + domain=x.get('domain'); + if domain not in lens.get('domains',[]):continue + e={'id':'edge.'+x['id'],'domain':domain,'kind':x.get('kind'),'count':x.get('count',1),'first_seen':x.get('first_seen'),'last_seen':x.get('last_seen'),'correlation':x.get('correlation')} + if x.get('from'):e['from']=p(x['from']);e['observed_from']=x['from'] + if x.get('to'):e['to']=p(x['to']);e['observed_to']=x['to'] + if x.get('via_channel'):e['via_channel']=p(x['via_channel']);e['observed_via_channel']=x['via_channel'] + if x.get('to_resource'):e['to_resource']=p(x['to_resource']);e['observed_to_resource']=x['to_resource'] + if x.get('binding'):e['binding']=p(x['binding']);e['observed_binding']=x['binding'] + if x.get('operation'):e['operation']=p(x['operation']);e['observed_operation']=x['operation'] + if x.get('via_gateway'): + e['via_gateway']=True;e['gateway']=p(x.get('gateway'));e['observed_gateway']=x.get('gateway');e['intended_target']=p(x.get('intended_target')) + edges.append(e) + counts={};nodes=set() + for e in edges: + counts[e['domain']]=counts.get(e['domain'],0)+1 + for k in ('from','to','gateway'): + if e.get(k):nodes.add(e[k]) + return {'lens':lens['id'],'lens_version':lens.get('version'),'model':doc.get('instance',{}).get('id'),'summary':{'edges':len(edges),'domains':dict(sorted(counts.items())),'architectural_nodes':len(nodes),'unresolved':len(unresolved),'working_set_attachments':len(ws.get('attachments',[]))},'edges':edges,'unresolved':unresolved,'working_set':{'enabled':working_set,'ambiguous':ws.get('ambiguous',[])}} + +def markdown(r,doc): + obj,_=index(doc) + def label(ref):return (obj.get(ref,{}) or {}).get('name') or ref or '?' + lines=['# Runtime Interaction Topology','',f"Model: `{r.get('model')}`",'', '## Summary',''] + lines += [f"- **{k}:** {v}" for k,v in r['summary']['domains'].items()] + lines += [f"- **unresolved:** {r['summary']['unresolved']}",f"- **working-set attachments:** {r['summary']['working_set_attachments']}",'','## Edges',''] + for e in r['edges']: + suffix=f" × {e.get('count',1)}" if e.get('count',1)>1 else '' + if e['domain']=='rpc': + g=f" via gateway **{label(e.get('gateway'))}** toward **{label(e.get('intended_target'))}**" if e.get('via_gateway') else '' + lines.append(f"- RPC: **{label(e.get('from'))}** → **{label(e.get('to'))}**{g}{suffix}") + elif e['domain']=='messaging':lines.append(f"- Messaging: **{label(e.get('from'))}** → `{label(e.get('via_channel'))}` → **{label(e.get('to'))}**{suffix}") + elif e['domain']=='database':lines.append(f"- Database: **{label(e.get('from'))}** → **{label(e.get('to_resource'))}** (`{e.get('kind')}`){suffix}") + if r['unresolved']: + lines += ['','## Partial / unresolved observations','']+[f"- {x.get('domain')}: {x.get('reason')} — `{x.get('sample_span')}`" for x in r['unresolved']] + return '\n'.join(lines)+'\n' + +def main(): + root=Path(__file__).resolve().parents[1];ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('model',type=Path);ap.add_argument('--lens',type=Path,default=root/'lenses/runtime-topology.yaml');ap.add_argument('-o','--output',type=Path,required=True);ap.add_argument('--markdown',type=Path);ap.add_argument('--no-working-set',action='store_true') + args=ap.parse_args();doc=yaml.safe_load(args.model.read_text());lens=yaml.safe_load(args.lens.read_text());r=execute(doc,lens,not args.no_working_set);args.output.parent.mkdir(parents=True,exist_ok=True);args.output.write_text(yaml.safe_dump(r,sort_keys=False,allow_unicode=True,width=120)); + if args.markdown:args.markdown.write_text(markdown(r,doc)) + print(yaml.safe_dump(r['summary'],sort_keys=False).strip()) +if __name__=='__main__':main() diff --git a/history/FIAM_v0.2_Draft6/tools/security_coverage_lens.py b/history/FIAM_v0.2_Draft6/tools/security_coverage_lens.py new file mode 100755 index 0000000..6f12bfc --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/security_coverage_lens.py @@ -0,0 +1,35 @@ +#!/usr/bin/env python3 +"""Project declared OpenAPI security requirements into practical operation coverage.""" +from __future__ import annotations +import argparse +from pathlib import Path +import yaml + +def execute(doc): + op_contract={};ops={} + for c in doc.get('contracts',[]) or []: + for o in c.get('operations',[]) or []:ops[o['id']]=o;op_contract[o['id']]=c['id'] + profiles=doc.get('security',[]) or [];by_target={} + for p in profiles:by_target.setdefault(p.get('applies_to'),[]).append(p) + override={} + for a in doc.get('assertions',[]) or []: + if a.get('assertion_kind')=='property' and a.get('predicate')=='fiam.property.security-override' and a.get('polarity')=='asserted':override[a.get('subject')]=a.get('value') + rows=[] + for oid in sorted(ops): + own=by_target.get(oid,[]);globalp=by_target.get(op_contract.get(oid),[]);ov=override.get(oid) + if ov=='none':status='explicitly-unprotected';effective=[] + elif ov=='anonymous-alternative':status='anonymous-access-allowed';effective=own if own else globalp + elif own:status='operation-specific';effective=own + elif globalp:status='inherited-contract-security';effective=globalp + else:status='no-declared-security';effective=[] + alternatives={} + for p in effective: + alt=(p.get('facets') or {}).get('requirement_alternative',1);alternatives.setdefault(alt,[]).append({'profile':p['id'],'authentication':p.get('authentication'),'scheme':(p.get('facets') or {}).get('openapi_security_scheme'),'scopes':(p.get('facets') or {}).get('required_scopes',[])}) + rows.append({'operation_ref':oid,'contract_ref':op_contract.get(oid),'classification':status,'alternatives':[{'alternative':k,'all_of':v} for k,v in sorted(alternatives.items())],'runtime_observability':'not-inferred-from-generic-OTLP'}) + summary={} + for r in rows:summary[r['classification']]=summary.get(r['classification'],0)+1 + return {'lens':'fiam.lens.security-coverage','model':doc.get('instance',{}).get('id'),'summary':dict(sorted(summary.items())),'operations':rows,'note':'Generic OTLP does not prove authentication presence/absence; this lens reports declared coverage only unless an explicit security telemetry source is added.'} + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('model',type=Path);ap.add_argument('-o','--output',type=Path,required=True);args=ap.parse_args();r=execute(yaml.safe_load(args.model.read_text()));args.output.write_text(yaml.safe_dump(r,sort_keys=False,allow_unicode=True,width=120));print(yaml.safe_dump(r['summary'],sort_keys=False).strip()) +if __name__=='__main__':main() diff --git a/history/FIAM_v0.2_Draft6/tools/security_evidence_coverage_lens.py b/history/FIAM_v0.2_Draft6/tools/security_evidence_coverage_lens.py new file mode 100755 index 0000000..7272519 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/security_evidence_coverage_lens.py @@ -0,0 +1,22 @@ +#!/usr/bin/env python3 +"""Declared security vs runtime security-evidence coverage, preserving unknown.""" +from __future__ import annotations +import argparse,json,sqlite3 +from pathlib import Path +import yaml + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('db',type=Path);ap.add_argument('--population',required=True);ap.add_argument('--since',required=True);ap.add_argument('--until',required=True);ap.add_argument('-o','--output',type=Path,required=True);a=ap.parse_args();c=sqlite3.connect(a.db);c.row_factory=sqlite3.Row + # Current contract->operation membership from the indexed entities. + contract_ops={} + for r in c.execute("SELECT entity_id,json FROM entities WHERE kind='interface-contract'").fetchall(): + o=json.loads(r['json']);contract_ops[r['entity_id']]=[x.get('id') for x in o.get('operations',[]) or [] if isinstance(x,dict) and x.get('id')] + observed={r['operation_ref'] for r in c.execute('SELECT DISTINCT operation_ref FROM runtime_aggregates WHERE population_id=? AND last_seen>=? AND first_seen<=?',(a.population,a.since,a.until)).fetchall() if r['operation_ref']} + rows=[] + for r in c.execute("SELECT entity_id,json FROM entities WHERE kind='security-profile' ORDER BY entity_id").fetchall(): + o=json.loads(r['json']);target=o.get('applies_to');targets=contract_ops.get(target,[target] if target else []) + for op in targets: + obs=op in observed + rows.append({'profile_ref':r['entity_id'],'declared_at':target,'operation_ref':op,'authentication':o.get('authentication'),'operation_observed_in_window':obs,'runtime_security_evidence':'unknown','interpretation':'declared-security-runtime-evidence-unknown' if obs else 'declared-security-operation-not-observed'}) + out={'lens_id':'fiam.lens.security-evidence-coverage','population_id':a.population,'window':{'since':a.since,'until':a.until},'summary':{'declared_profile_operation_pairs':len(rows),'observed_operations_with_security_unknown':len({r['operation_ref'] for r in rows if r['operation_observed_in_window']})},'profiles':rows,'note':'Generic OTLP does not prove authentication presence or absence. Unknown is preserved.'};a.output.write_text(yaml.safe_dump(out,sort_keys=False)) +if __name__=='__main__':main() diff --git a/history/FIAM_v0.2_Draft6/tools/validate_authority_policy.py b/history/FIAM_v0.2_Draft6/tools/validate_authority_policy.py new file mode 100755 index 0000000..7a91dea --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/validate_authority_policy.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python3 +from __future__ import annotations +import argparse,json +from pathlib import Path +import yaml,jsonschema +ROOT=Path(__file__).resolve().parents[1] +def main(): + ap=argparse.ArgumentParser();ap.add_argument('policy',type=Path);ap.add_argument('--schema',type=Path,default=ROOT/'schemas/FIAM-SnapshotAuthorityPolicy-v0.2.schema.json');a=ap.parse_args();p=yaml.safe_load(a.policy.read_text());s=json.loads(a.schema.read_text());errs=[e.message for e in jsonschema.Draft202012Validator(s).iter_errors(p)] + owners={};layered={x.get('observation_scope'):set(x.get('precedence') or []) for x in p.get('layered_scopes') or []} + for sid,cfg in (p.get('sources') or {}).items():owners.setdefault(cfg.get('observation_scope'),[]).append(sid) + for scope,srcs in owners.items(): + if len(srcs)>1 and not set(srcs).issubset(layered.get(scope,set())):errs.append(f'observation_scope {scope} has multiple source owners without explicit layered precedence: {srcs}') + if errs:print('\n'.join(errs));return 1 + print('PASS');return 0 +if __name__=='__main__':raise SystemExit(main()) diff --git a/history/FIAM_v0.2_Draft6/tools/validate_fiam.py b/history/FIAM_v0.2_Draft6/tools/validate_fiam.py new file mode 100755 index 0000000..841f369 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/validate_fiam.py @@ -0,0 +1,385 @@ +#!/usr/bin/env python3 +from __future__ import annotations +import argparse, glob, json, re +from pathlib import Path +import yaml +from jsonschema import Draft202012Validator +ROOT=Path(__file__).resolve().parents[1] +CORE=ROOT/'schemas/FIAM-Core-v0.2.schema.json' +CANON=ROOT/'canon/FIAM-Canon-v0.2.yaml' +SECTIONS=['participants','nodes','ports','contracts','endpoints','bindings','channels','information_resources','information_shapes','interactions','interaction_flows','artifacts','zones','security','assertions'] +KINDS={'participants':'participant','nodes':'system-node','ports':'port','contracts':'interface-contract','endpoints':'endpoint','bindings':'binding','channels':'channel','information_resources':'information-resource','information_shapes':'information-shape','interactions':'interaction','interaction_flows':'interaction-flow','artifacts':'artifact','zones':'zone','security':'security-profile','assertions':'assertion'} +REF_FIELDS={'owner','contract','provider_port','channel','operation','binding','interaction','from','via','to','applies_to','describes','implements','subject','object_ref'} +REF_LIST_FIELDS={'consumer_ports','operations','endpoints','participants','supersedes','conflicts_with'} +IDENTITY_SAME_KIND={'fiam.relation.same-entity-as','fiam.relation.alias-of','fiam.relation.version-of','fiam.relation.observationally-equivalent-to'} +SHAPE_PART={'fiam.relation.accepts-shape','fiam.relation.produces-shape','fiam.relation.errors-with-shape'} + +def collect(doc): + objs={}; objmap={}; assertions=set() + for section in SECTIONS: + for o in doc.get(section,[]) or []: + if isinstance(o,dict) and 'id' in o: + kind=o.get('kind') or KINDS.get(section); objs[o['id']]=kind; objmap[o['id']]=o + if section=='assertions': assertions.add(o['id']) + if section=='contracts' and isinstance(o,dict): + for op in o.get('operations',[]) or []: + if isinstance(op,dict) and 'id' in op: objs[op['id']]='operation'; objmap[op['id']]=op + return objs,objmap,assertions + +def iter_term_refs(x,path=()): + if isinstance(x,dict): + for k,v in x.items(): yield from iter_term_refs(v,path+(k,)) + elif isinstance(x,list): + for i,v in enumerate(x): yield from iter_term_refs(v,path+(i,)) + elif isinstance(x,str) and x.startswith('fiam.'): + yield path,x + +def path_values(doc,path): + vals=[doc] + for raw in path.split('.'): + arr=raw.endswith('[]'); key=raw[:-2] if arr else raw + nxt=[] + for v in vals: + if not isinstance(v,dict) or key not in v: continue + x=v[key] + if arr: + if isinstance(x,list): nxt.extend(x) + else: nxt.append(x) + else: nxt.append(x) + vals=nxt + return vals + +def entity_refs(doc,objs,assertions): + err=[] + def walk(o,path=()): + if isinstance(o,dict): + for k,v in o.items(): + p=path+(k,) + if k in REF_FIELDS: + vals=v if isinstance(v,list) else [v] + for r in vals: + if isinstance(r,str) and r not in objs: err.append(f"{'.'.join(map(str,p))}: unresolved entity ref {r}") + elif k in REF_LIST_FIELDS and isinstance(v,list): + target=assertions if k in {'supersedes','conflicts_with'} else objs + for r in v: + if isinstance(r,str) and r not in target: err.append(f"{'.'.join(map(str,p))}: unresolved ref {r}") + elif k=='participations' and isinstance(v,list): + for j,part in enumerate(v): + c=part.get('contract') if isinstance(part,dict) else None + if c and c not in objs: err.append(f"{'.'.join(map(str,p+(j,'contract')))}: unresolved contract {c}") + elif k=='participants' and isinstance(v,dict): + for rk,rv in v.items(): + vals=rv if isinstance(rv,list) else [rv] + for r in vals: + if isinstance(r,str) and r not in objs: err.append(f"{'.'.join(map(str,p+(rk,)))}: unresolved participant {r}") + walk(v,p) + elif isinstance(o,list): + for i,v in enumerate(o): walk(v,path+(i,)) + walk(doc); return err + +def participation_checks(doc): + errors=[]; ports={p['id']:p for p in doc.get('ports',[]) or [] if 'id' in p} + def has(pid,c,mode): + parts=ports.get(pid,{}).get('participations') + if not parts: return None + return any(x.get('contract')==c and x.get('mode')==mode for x in parts) + for b in doc.get('bindings',[]) or []: + c=b.get('contract'); pp=b.get('provider_port') + if c and pp and has(pp,c,'offers') is False: errors.append(f"binding {b['id']}: provider {pp} does not offer {c}") + for cp in b.get('consumer_ports',[]) or []: + if c and has(cp,c,'requires') is False: errors.append(f"binding {b['id']}: consumer {cp} does not require {c}") + return errors + +def value_type_ok(value, typ): + if typ=='boolean': return isinstance(value,bool) + if typ=='string': return isinstance(value,str) + if typ=='number': return isinstance(value,(int,float)) and not isinstance(value,bool) + if typ=='integer': return isinstance(value,int) and not isinstance(value,bool) + return True + +def subset(expected,actual): + if isinstance(expected,dict): return isinstance(actual,dict) and all(k in actual and subset(v,actual[k]) for k,v in expected.items()) + if isinstance(expected,list): return isinstance(actual,list) and all(any(subset(e,a) for a in actual) for e in expected) + return expected==actual + +def execute_check(check,doc,objs,objmap,terms,deprecated): + k=check['kind'] + if k=='all-assertions-have-evidence': + missing=[a.get('id') for a in doc.get('assertions',[]) or [] if not a.get('evidence')] + return None if not missing else f"assertions without evidence: {missing}" + if k=='no-deprecated-terms': + used=[t for _,t in iter_term_refs(doc) if t in deprecated] + return None if not used else f"deprecated terms used: {sorted(set(used))}" + if k=='no-legacy-representations': + refs=[] + for c in doc.get('contracts',[]) or []: + if 'representations' in c: refs.append(c.get('id')) + for op in c.get('operations',[]) or []: + if 'representations' in op: refs.append(op.get('id')) + return None if not refs else f"legacy representations fields on {refs}" + if k=='entity-exists': + r=check.get('ref'); ek=check.get('entity_kind') + if r not in objs: return f"entity {r} does not exist" + if ek and objs[r]!=ek: return f"entity {r} is {objs[r]}, expected {ek}" + return None + if k in {'relation-exists','relation-absent'}: + matches=[] + for a in doc.get('assertions',[]) or []: + if a.get('assertion_kind')=='relation' and a.get('polarity')=='asserted' and a.get('subject')==check.get('subject') and a.get('predicate')==check.get('predicate') and a.get('object_ref')==check.get('object_ref'): + if check.get('facets') is None or subset(check['facets'],a.get('facets',{})): matches.append(a) + exists=bool(matches) + if k=='relation-exists' and not exists: return f"expected relation not found: {check.get('subject')} {check.get('predicate')} {check.get('object_ref')} facets={check.get('facets')}" + if k=='relation-absent' and exists: return f"forbidden relation exists: {check.get('subject')} {check.get('predicate')} {check.get('object_ref')}" + return None + if k in {'field-equals','field-absent','field-contains'}: + r=check.get('ref'); field=check.get('field'); obj=objmap.get(r) + if obj is None: return f"entity {r} not found" + if k=='field-absent': return None if field not in obj else f"field {field} unexpectedly present on {r}" + if field not in obj: return f"field {field} missing on {r}" + if k=='field-equals': return None if obj[field]==check.get('value') else f"{r}.{field}={obj[field]!r}, expected {check.get('value')!r}" + v=obj[field]; wanted=check.get('value') + ok=(wanted in v) if isinstance(v,list) else (isinstance(v,dict) and wanted in v) or v==wanted + return None if ok else f"{r}.{field} does not contain {wanted!r}" + return f"unknown semantic check kind {k}" + + + +def evidence_has_mode(evidence, mode): + records=evidence if isinstance(evidence,list) else [evidence] + return any(isinstance(r,dict) and r.get('mode')==mode for r in records) + +def asserted_relations(doc, predicate=None): + out=[] + for a in doc.get('assertions',[]) or []: + if a.get('assertion_kind')!='relation' or a.get('polarity')!='asserted': continue + if predicate and a.get('predicate')!=predicate: continue + out.append(a) + return out + +def equivalence_map(doc, predicate='fiam.relation.same-entity-as'): + parent={} + def find(x): + parent.setdefault(x,x) + if parent[x]!=x: parent[x]=find(parent[x]) + return parent[x] + def union(a,b): + ra,rb=find(a),find(b) + if ra!=rb: parent[rb]=ra + for a in asserted_relations(doc,predicate): + if a.get('subject') and a.get('object_ref'): union(a['subject'],a['object_ref']) + return find + +def relation_reaches(doc, child, parent, predicates): + if child==parent: return True + same=equivalence_map(doc) + if same(child)==same(parent): return True + graph={} + for a in asserted_relations(doc): + if a.get('predicate') in predicates: + graph.setdefault(a.get('subject'),set()).add(a.get('object_ref')) + seen=set(); stack=[child] + while stack: + x=stack.pop() + if x in seen: continue + seen.add(x) + for y in graph.get(x,set()): + if y==parent or same(y)==same(parent): return True + stack.append(y) + return False + +def shape_coherence_checks(doc, objs, objmap, canon): + err=[]; pol=canon.get('semantic_policies',{}).get('resource_shape',{}) + collection_kind=pol.get('collection_shape_kind','fiam.information-shape.collection') + collection_resources=set(pol.get('collection_resource_kinds',[])) + collection_scopes={'fiam.resource-scope.concrete-collection','fiam.resource-scope.logical-selection'} + for a in asserted_relations(doc): + pred=a.get('predicate'); subj=a.get('subject'); obj=a.get('object_ref') + if pred=='fiam.relation.conforms-to-shape' and objs.get(subj)=='information-resource' and objs.get(obj)=='information-shape': + rk=objmap.get(subj,{}).get('resource_kind') + if rk in collection_resources and objmap.get(obj,{}).get('shape_kind')!=collection_kind: + err.append(f"assertion {a.get('id')}: collection-like resource {subj} ({rk}) conforms-to non-collection shape {obj} ({objmap.get(obj,{}).get('shape_kind')})") + if pred=='fiam.relation.element-shape': + sk=objs.get(subj) + if sk=='information-shape' and objmap.get(subj,{}).get('shape_kind')!=collection_kind: + err.append(f"assertion {a.get('id')}: element-shape subject {subj} must have shape_kind {collection_kind}") + elif sk=='information-resource': + so=objmap.get(subj,{}) + if so.get('resource_kind') not in collection_resources and so.get('resource_scope') not in collection_scopes: + err.append(f"assertion {a.get('id')}: element-shape resource subject {subj} is not collection-like") + return err + +def shape_refinement_checks(doc, objs, objmap, canon, contract_ops): + err=[]; policy=canon.get('semantic_policies',{}).get('shape_participation',{}) + refine=set(policy.get('refinement_relations',['fiam.relation.projection-of','fiam.relation.version-of'])) + # Shape participations indexed by subject/predicate. + rels=[a for a in asserted_relations(doc) if a.get('predicate') in SHAPE_PART] + by_subject_pred={} + for a in rels: by_subject_pred.setdefault((a.get('subject'),a.get('predicate')),[]).append(a) + bindings={b.get('id'):b for b in doc.get('bindings',[]) or []} + interactions={i.get('id'):i for i in doc.get('interactions',[]) or []} + # Binding -> Operation default. + for a in rels: + if objs.get(a.get('subject'))!='binding': continue + b=bindings.get(a['subject'],{}); ops=b.get('operations') or contract_ops.get(b.get('contract'),[]) or [] + opref=(a.get('facets') or {}).get('operation_ref') + if not opref and len(ops)==1: opref=ops[0] + if not opref: continue + parents=[x.get('object_ref') for x in by_subject_pred.get((opref,a['predicate']),[])] + if parents and not any(relation_reaches(doc,a.get('object_ref'),p,refine) for p in parents): + err.append(f"assertion {a.get('id')}: binding shape {a.get('object_ref')} does not refine Operation {opref} {a['predicate']} shape(s) {parents}") + # Interaction -> most specific Binding default, otherwise Operation default. + for a in rels: + iid=a.get('subject') + if objs.get(iid)!='interaction': continue + inter=interactions.get(iid,{}); opref=inter.get('operation'); bid=inter.get('binding') + parents=[] + if bid: + for br in by_subject_pred.get((bid,a['predicate']),[]): + bref=(br.get('facets') or {}).get('operation_ref') + if not bref or bref==opref: parents.append(br.get('object_ref')) + if not parents and opref: parents=[x.get('object_ref') for x in by_subject_pred.get((opref,a['predicate']),[])] + if parents and not any(relation_reaches(doc,a.get('object_ref'),p,refine) for p in parents): + err.append(f"assertion {a.get('id')}: interaction shape {a.get('object_ref')} does not refine parent {a['predicate']} shape(s) {parents}") + return err + +def family_cache_checks(doc): + err=[] + assertions=doc.get('assertions',[]) or [] + for c in doc.get('contracts',[]) or []: + for label in c.get('family_labels',[]) or []: + ok=False + for a in assertions: + if a.get('assertion_kind')=='property' and a.get('polarity')=='asserted' and a.get('subject')==c.get('id') and a.get('predicate')=='fiam.property.family-label' and a.get('value')==label and evidence_has_mode(a.get('evidence'),'fiam.evidence.inferred'): + ok=True; break + if not ok: err.append(f"contract {c.get('id')}: cached family label {label} lacks backing inferred fiam.property.family-label assertion") + return err + +def validate(path,schema,canon): + doc=yaml.safe_load(open(path)); err=[]; warn=[] + for e in Draft202012Validator(schema).iter_errors(doc): err.append(f"schema {list(e.absolute_path)}: {e.message}") + terms={t['id']:t for t in canon['terms']}; schemes={s['id']:s for s in canon['schemes']}; deprecated={i for i,t in terms.items() if t.get('status')=='deprecated'} + objs,objmap,assertion_ids=collect(doc); err+=entity_refs(doc,objs,assertion_ids); err+=participation_checks(doc); err+=family_cache_checks(doc) + # all fiam.* references must exist + for p,t in iter_term_refs(doc): + if t not in terms: err.append(f"{'.'.join(map(str,p))}: unknown Canon term {t}") + elif t in deprecated: warn.append(f"{'.'.join(map(str,p))}: deprecated Canon term {t}") + # Canon path/scheme constraints + for c in canon.get('term_usage_constraints',[]): + allowed=set(c['schemes']) + for v in path_values(doc,c['path']): + vals=v if isinstance(v,list) else [v] + for t in vals: + if isinstance(t,str) and t.startswith('fiam.') and t in terms and terms[t].get('scheme') not in allowed: + err.append(f"{c['path']}: term {t} from {terms[t].get('scheme')} not allowed; expected {sorted(allowed)}") + # Operation/Binding consistency. Direct operations should belong to the Binding contract. + # Embedded contracts are allowed when an evidence-backed embedded-in assertion links the nested contract + # to an operation of the Binding's contract (e.g. runtime MCP tools carried through tools/call). + op_contract={} + contract_ops={} + for cobj in doc.get('contracts',[]) or []: + ops=[op.get('id') for op in cobj.get('operations',[]) or [] if isinstance(op,dict) and op.get('id')] + contract_ops[cobj.get('id')]=ops + for oid in ops: op_contract[oid]=cobj.get('id') + embedded_contract_targets=set() + for a0 in doc.get('assertions',[]) or []: + if a0.get('assertion_kind')=='relation' and a0.get('polarity')=='asserted' and a0.get('predicate')=='fiam.relation.embedded-in': + subj=a0.get('subject'); target=a0.get('object_ref') + if objs.get(subj)=='interface-contract' and objs.get(target)=='operation': embedded_contract_targets.add((subj,target)) + bindings={b.get('id'):b for b in doc.get('bindings',[]) or []} + for inter in doc.get('interactions',[]) or []: + oid=inter.get('operation'); bid=inter.get('binding') + if not oid or not bid or bid not in bindings: continue + b=bindings[bid]; bc=b.get('contract'); oc=op_contract.get(oid) + if bc and oc and bc!=oc: + allowed=any(ec==oc and target in contract_ops.get(bc,[]) for ec,target in embedded_contract_targets) + if not allowed: err.append(f"interaction {inter.get('id')}: operation {oid} belongs to {oc}, but binding {bid} realizes {bc} and no embedded-in relation explains the indirection") + + # Canon property and relation semantics + pred_constraints={x['predicate']:x for x in canon.get('assertion_predicate_constraints',[])} + facet_rules={p:r for r in canon.get('relation_facet_constraints',[]) for p in r.get('predicates',[])} + for i,a in enumerate(doc.get('assertions',[]) or []): + pred=a.get('predicate'); kind=a.get('assertion_kind'); pol=a.get('polarity'); pt=terms.get(pred,{}) + expected='fiam.scheme.relation' if kind=='relation' else 'fiam.scheme.property' + if pt and pt.get('scheme')!=expected: err.append(f"assertions.{i}.predicate: {kind} requires {expected}, got {pt.get('scheme')}") + if not a.get('evidence'): err.append(f"assertions.{i}: evidence required") + if a.get('id') in (a.get('supersedes') or []): err.append(f"assertion {a.get('id')}: cannot supersede itself") + if a.get('id') in (a.get('conflicts_with') or []): err.append(f"assertion {a.get('id')}: cannot conflict with itself") + if kind=='property' and pol=='asserted' and pred in pred_constraints: + c=pred_constraints[pred]; val=a.get('value') + if c.get('value_type') and not value_type_ok(val,c['value_type']): err.append(f"assertions.{i}: {pred} requires {c['value_type']}") + if c.get('value_schemes') and isinstance(val,str) and val in terms and terms[val].get('scheme') not in c['value_schemes']: err.append(f"assertions.{i}: {pred} value {val} not from {c['value_schemes']}") + if kind=='relation' and pol=='asserted': + sk=objs.get(a.get('subject')); ok=objs.get(a.get('object_ref')); dom=pt.get('domain_kinds'); ran=pt.get('range_kinds') + if dom and sk not in dom: err.append(f"assertions.{i}: {pred} subject kind {sk} not in {dom}") + if ran and ok not in ran: err.append(f"assertions.{i}: {pred} object kind {ok} not in {ran}") + if pred in IDENTITY_SAME_KIND: + if a.get('subject')==a.get('object_ref'): err.append(f"assertions.{i}: {pred} cannot relate entity to itself") + elif sk and ok and sk!=ok: err.append(f"assertions.{i}: {pred} requires same entity kind, got {sk}->{ok}") + # Operational identity promotion policy: same-entity-as is query equivalence, not a merge. + # A declared/governed assertion may establish it directly. Purely inferred promotion + # requires the Canon threshold and multiple independent evidence signals. + if pred=='fiam.relation.same-entity-as': + policy=canon.get('semantic_policies',{}).get('identity_relations',{}) + records=a.get('evidence') if isinstance(a.get('evidence'),list) else [a.get('evidence')] + records=[r for r in records if isinstance(r,dict)] + if not any(r.get('mode')=='fiam.evidence.declared' for r in records): + threshold=float(policy.get('default_reconciliation_threshold',0.98)) + need=int(policy.get('required_independent_signals_for_inferred_promotion',2)) + inferred=[r for r in records if r.get('mode')=='fiam.evidence.inferred' and float(r.get('confidence',0))>=threshold] + sigs=set() + for r in inferred: + src=r.get('source') + if isinstance(src,dict): sigs.add((src.get('type'),src.get('ref'),src.get('locator'))) + else: sigs.add(('source',str(src),None)) + if len(inferred)= {need} independent evidence signals at confidence >= {threshold}; use corresponds-to until governed promotion") + # Relation facet constraints + rule=facet_rules.get(pred); facets=a.get('facets') or {} + if rule: + allowed=rule.get('allowed_facets',{}) + for fk,fv in facets.items(): + if fk not in allowed: err.append(f"assertions.{i}: facet {fk} not allowed on {pred}"); continue + spec=allowed[fk] + if spec.get('type') and not value_type_ok(fv,spec['type']): err.append(f"assertions.{i}.facets.{fk}: expected {spec['type']}") + if spec.get('scheme') and isinstance(fv,str) and fv in terms and terms[fv].get('scheme')!=spec['scheme']: err.append(f"assertions.{i}.facets.{fk}: {fv} not from {spec['scheme']}") + if spec.get('entity_kind'): + if not isinstance(fv,str) or objs.get(fv)!=spec['entity_kind']: err.append(f"assertions.{i}.facets.{fk}: expected ref to {spec['entity_kind']}") + # Multi-operation Binding shape relation must disambiguate. + if pred in SHAPE_PART and sk=='binding': + b=objmap.get(a['subject'],{}); ops=b.get('operations') or contract_ops.get(b.get('contract'),[]) or [] + if len(ops)>1 and not (a.get('facets') or {}).get('operation_ref'): err.append(f"assertions.{i}: Binding shape participation with multiple operations requires facets.operation_ref") + opref=(a.get('facets') or {}).get('operation_ref') + if opref and ops and opref not in ops: err.append(f"assertions.{i}: operation_ref {opref} not realized by binding {a['subject']}") + # Cross-assertion semantic invariants from Canon policies. + err+=shape_coherence_checks(doc,objs,objmap,canon) + err+=shape_refinement_checks(doc,objs,objmap,canon,contract_ops) + + # Legacy non-authoritative representations should warn (green corpus uses none). + for c in doc.get('contracts',[]) or []: + if 'representations' in c: warn.append(f"contract {c.get('id')}: legacy representations field is non-authoritative") + for op in c.get('operations',[]) or []: + if 'representations' in op: warn.append(f"operation {op.get('id')}: legacy representations field is non-authoritative") + # Executable expectations are mandatory for specimen fixtures, not for ordinary ingested models. + tests=doc.get('tests') or {} + checks=tests.get('expected_properties') or [] + if doc.get('instance',{}).get('kind')=='specimen' and not checks: + err.append('specimen tests.expected_properties must contain executable semantic checks') + for j,c in enumerate(checks): + msg=execute_check(c,doc,objs,objmap,terms,deprecated) + if msg: err.append(f"tests.expected_properties.{j} ({c.get('id')}): {msg}") + return err,warn + +def main(): + ap=argparse.ArgumentParser(); ap.add_argument('paths',nargs='*'); args=ap.parse_args() + schema=json.load(open(CORE)); Draft202012Validator.check_schema(schema); canon=yaml.safe_load(open(CANON)) + paths=args.paths or sorted(glob.glob(str(ROOT/'specimens/**/*.yaml'),recursive=True)) + failures=0; total_e=total_w=0 + for p in paths: + e,w=validate(p,schema,canon); total_e+=len(e); total_w+=len(w); failures+=bool(e) + pp=Path(p); label=pp.relative_to(ROOT) if ROOT in pp.parents else pp + print(f"{label}: {'PASS' if not e else 'FAIL'} ({len(e)} errors, {len(w)} warnings)") + for x in e: print(' ERROR:',x) + for x in w: print(' WARN: ',x) + print(f"SUMMARY: {len(paths)} files, {failures} failing, {total_e} errors, {total_w} warnings") + return 1 if failures else 0 +if __name__=='__main__': raise SystemExit(main()) diff --git a/history/FIAM_v0.2_Draft6/tools/validate_runtime_extensions.py b/history/FIAM_v0.2_Draft6/tools/validate_runtime_extensions.py new file mode 100755 index 0000000..4525ed4 --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/validate_runtime_extensions.py @@ -0,0 +1,13 @@ +#!/usr/bin/env python3 +import argparse,json +from pathlib import Path +import yaml +from jsonschema import Draft202012Validator +ROOT=Path(__file__).resolve().parents[1] +def main(): + ap=argparse.ArgumentParser();ap.add_argument('model',type=Path);args=ap.parse_args();m=yaml.safe_load(args.model.read_text());s=json.loads((ROOT/'schemas/FIAM-RuntimeCatalogExtension-v0.2.schema.json').read_text());errs=sorted(Draft202012Validator(s).iter_errors(m.get('extensions',{})),key=lambda e:list(e.path)); + if errs: + for e in errs:print('ERROR', '.'.join(map(str,e.path)), e.message) + raise SystemExit(1) + print('runtime extensions: PASS') +if __name__=='__main__':main() diff --git a/history/FIAM_v0.2_Draft6/tools/working_set_view.py b/history/FIAM_v0.2_Draft6/tools/working_set_view.py new file mode 100755 index 0000000..cc1ad1c --- /dev/null +++ b/history/FIAM_v0.2_Draft6/tools/working_set_view.py @@ -0,0 +1,48 @@ +#!/usr/bin/env python3 +"""Build a non-destructive FIAM working-set projection. + +Declared records are preferred for navigation when high-confidence observed->declared +`corresponds-to` assertions exist. This is a projection only: no source id is merged, +deleted, or rewritten, and all attachments/evidence remain inspectable. +""" +from __future__ import annotations +import argparse +from pathlib import Path +import yaml + + +def evidence_records(a): + e=a.get('evidence'); return [e] if isinstance(e,dict) else [x for x in (e or []) if isinstance(x,dict)] + +def conf(a):return max([float(e.get('confidence',0)) for e in evidence_records(a)] or [0]) + +def index(doc): + out={};k={} + for sec,kind in [('nodes','system-node'),('ports','port'),('contracts','interface-contract'),('endpoints','endpoint'),('bindings','binding'),('channels','channel'),('information_resources','information-resource'),('information_shapes','information-shape'),('interactions','interaction'),('interaction_flows','interaction-flow'),('artifacts','artifact'),('zones','zone'),('security','security-profile')]: + for x in doc.get(sec,[]) or []: + if x.get('id'):out[x['id']]=x;k[x['id']]=kind + if sec=='contracts': + for o in x.get('operations',[]) or []: + if o.get('id'):out[o['id']]=o;k[o['id']]='operation' + return out,k + +def execute(doc,threshold=.90): + obj,kinds=index(doc); by_obs={} + for a in doc.get('assertions',[]) or []: + if a.get('assertion_kind')!='relation' or a.get('polarity')!='asserted' or a.get('predicate')!='fiam.relation.corresponds-to':continue + s,o=a.get('subject'),a.get('object_ref') + if s not in obj or o not in obj or kinds.get(s)!=kinds.get(o):continue + by_obs.setdefault(s,[]).append((o,conf(a),a.get('id'))) + preferred={};attachments=[];ambiguous=[] + for obs,cands in sorted(by_obs.items()): + cands=sorted(cands,key=lambda x:(-x[1],x[0]));top=cands[0];ties=[x for x in cands if abs(x[1]-top[1])<.02] + if top[1]>=threshold and len(ties)==1: + preferred[obs]=top[0];attachments.append({'observed_ref':obs,'preferred_ref':top[0],'confidence':top[1],'assertion_id':top[2],'merged':False}) + else:ambiguous.append({'observed_ref':obs,'candidates':[{'ref':x[0],'confidence':x[1],'assertion_id':x[2]} for x in cands]}) + # same-entity-as remains an equivalence view, but correspondence projection does not assert identity. + return {'model':doc.get('instance',{}).get('id'),'policy':{'preference':'declared-preferred-through-high-confidence-correspondence','threshold':threshold,'destructive_merge':False},'preferred_ref_by_observed':preferred,'attachments':attachments,'ambiguous':ambiguous} + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('model',type=Path);ap.add_argument('-o','--output',type=Path,required=True);ap.add_argument('--threshold',type=float,default=.90) + args=ap.parse_args();doc=yaml.safe_load(args.model.read_text());r=execute(doc,args.threshold);args.output.parent.mkdir(parents=True,exist_ok=True);args.output.write_text(yaml.safe_dump(r,sort_keys=False,allow_unicode=True,width=120));print(f"working-set: {len(r['attachments'])} projected attachments, {len(r['ambiguous'])} ambiguous") +if __name__=='__main__':main() diff --git a/workplans/FIAM-WP-0001-statehub-bootstrap-and-baseline.md b/workplans/FIAM-WP-0001-statehub-bootstrap-and-baseline.md new file mode 100644 index 0000000..b011920 --- /dev/null +++ b/workplans/FIAM-WP-0001-statehub-bootstrap-and-baseline.md @@ -0,0 +1,105 @@ +--- +id: FIAM-WP-0001 +type: workplan +title: "Bootstrap FIAM repository governance and baseline" +domain: infotech +repo: facetted-interfaces +status: finished +owner: codex +topic_slug: infotech +created: "2026-09-09" +updated: "2026-09-09" +spec_refs: + - INTENT.md + - README.md + - history/FIAM_v0.2_Draft6/CONFORMANCE.txt +state_hub_workstream_id: "df6dc111-064b-5154-964b-6683190a79f6" +--- + +# FIAM-WP-0001 — State Hub Bootstrap and Baseline + +## Goal + +Establish this repository as the maintained home of FIAM, register its +identity and initial workstream with State Hub, and turn the archived Draft 6 +reference material into a verified baseline for subsequent standard work. + +## Task Breakdown + +## T01 — Establish repository intent and workplan + +```task +id: FIAM-WP-0001-T01 +status: done +priority: high +state_hub_task_id: "f4948d92-7947-5a86-9420-c62f0de191d4" +``` + +Add the repository-specific `INTENT.md` and this initial workplan. Confirm the +scope, ownership boundary, current baseline, and completion condition. + +## T02 — Register repository with State Hub + +```task +id: FIAM-WP-0001-T02 +status: done +priority: high +depends_on: [T01] +state_hub_task_id: "ab0919d3-f925-5fb5-a350-afae89092d37" +``` + +Register `facetted-interfaces` with domain `infotech`, topic `canon`, and +workplan prefix `FIAM-WP`. Registration completed with repository id +`92b98d54-fb03-44b6-998a-f4afff77038f` and workstream id +`df6dc111-064b-5154-964b-6683190a79f6`; the local projection reconciled. + +## T03 — Verify and document the Draft 6 baseline + +```task +id: FIAM-WP-0001-T03 +status: done +priority: high +depends_on: [T01] +state_hub_task_id: "e49c82ce-ac3b-5b23-9b08-f08948588565" +``` + +Run the existing Draft 6 conformance and validation checks. Record what passes, +what is incomplete, and which artifacts are normative, informative, generated, +or historical. Add a short baseline note or update the README with the +developer verification path. The suite passes all listed checks, including 26 +semantic specimens and the adversarial suite. The runner now uses the active +Python interpreter, so the Make target is reproducible on this host. + +## T04 — Plan the maintained FIAM release layout + +```task +id: FIAM-WP-0001-T04 +status: done +priority: medium +depends_on: [T03] +state_hub_task_id: "19518be4-8c35-56b3-808a-732c8f919f63" +``` + +Propose the repository layout and release policy for the next maintained FIAM +version, including where normative specifications, schemas, fixtures, tools, +and historical drafts live. Identify migration and compatibility work needed +before promoting Draft 6 into that structure. The proposal is recorded in the +root README: versioned maintained releases at the top level, with superseded +material retained under `history/`. + +## T05 — Close out the bootstrap + +```task +id: FIAM-WP-0001-T05 +status: done +priority: high +depends_on: [T02, T03, T04] +state_hub_task_id: "e85b9157-8487-50d7-92f0-678495facd97" +``` + +Re-run State Hub consistency checks and the baseline validation suite. Update +the workplan with evidence and create follow-up workplans for release +engineering or standard changes rather than leaving implementation tasks +implicit. State Hub consistency and the baseline validation suite are complete; +follow-up release engineering and standard-change work will use subsequent +workplans.