Inflow.aiDocs

Optional technical reference. This material is for developers, integration specialists and platform administrators. For the consultant lesson, read the practical guide.

Preserved from source baseline d4587c7c0e073e58c2d430342f65ac55dd701bf4; source/static examples retain their stated scope. They are not new runtime verification or required consultant setup steps.

API Management

Follow the consumer from rule to registry to key

A machine consumer does not receive general Studio access. A published API maps a strict public path to an exposed business rule under one workspace. A managed API key authenticates that machine caller, pins its workspace and limits which path-derived API keys it covers. Rule exposure, registry publication and credential issuance are separate reviewed choices.

Nadia’s example is a read-only leave-search API. The rule’s required input contract and the permitted data/disclosure scope must already be correct before exposure; a managed key must not become a shortcut for a human task decision or arbitrary record query. Administration needs the documented platform permission and workspace ADMIN gate (or an actual authorized platform-management path), not merely a visible page.

Identity/control Use Important consequence
Interactive/user API key User-bound platform contract Not interchangeable with a managed machine key.
Rule Web-API key Exposed-rule execution contract Not automatically a registry-wide API key.
Managed inf_ak_ key Published /api/pub/** paths Server pins workspace; client header cannot redirect it.
ALL_PUBLISHED / API_KEYS Broad/default versus explicit path-derived list Prefer the deliberate narrow list for a dedicated consumer.
PATCH policy Rate/expiry/scope edits Scope narrows only; a secret is not replaced.
Rotate New secret and predecessor revocation Existing scope carries forward; rotation is not scope narrowing.
Suspend / delete registry API Stop or remove the route Same-path republish can restore access to scoped keys still naming that apiKey.

Store the real show-once secret in the admitted credential owner’s protected system, never the manual, a screenshot or a shared log. The examples use placeholders and do not send requests. The detailed reference retains exact error and streaming behavior below.

Worked examples

Example DATA-API-01 — Publish a read-only path and issue a narrowly scoped key

Scenario and inputs. Nadia has an actual exposed leave-search rule with a reviewed input/output/disclosure contract in the intended workspace. She also has API-management authority and the required workspace administration role. The business path hr/leave-search is illustrative but follows the strict registry grammar.

Procedure. 1. Publish the registry entry through POST /api/api-management/published-apis using the first complete request body. 2. Retain the server-returned path-derived apiKey, rather than assuming it is an arbitrary display name. 3. Issue the dedicated managed key through /api/api-management/keys using that actual returned apiKey and a deliberate rate/expiry policy. 4. Transfer the show-once secret only into the owner’s protected credential store. 5. Confirm the consumer needs no unrelated API or Studio permission.

{
  "name": "Leave search",
  "description": "Read-only synthetic training search",
  "path": "hr/leave-search",
  "ruleKey": "leave-search"
}

Second complete issue-body example; choose any expiry through the actual future-time policy:

{
  "name": "Leave search consumer",
  "scope": "API_KEYS",
  "apiKeys": [
    "hr-leave-search"
  ],
  "callsPerMinute": 60
}

Expected result. The registry names an eligible exposed target, while the key covers only the explicit API_KEYS list in its own workspace. The issue response exposes the secret once; subsequent inventory reads are metadata and cannot recover it.

Failure and recovery. A missing workspace ADMIN role, unsupported path or unexposed rule is a setup/admission failure. Correct that exact contract through its owner; do not issue ALL_PUBLISHED merely to avoid identifying the proper apiKey, or expose a mutating rule whose participant/intent rules cannot be satisfied safely.

Sources. AdminManagedApiKeyController.java, AdminPublishedApiController.java, PublishedApiDispatchController.java.

Example DATA-API-02 — Call in the key-pinned workspace and handle a contract refusal

Scenario and inputs. The consumer holds its own admitted managed secret and needs requests for a permitted employee/status. The body below is a complete dispatch request for a rule that actually declares those two TEXT inputs. The path is the published registry path, not the rule’s draft ID, and no actual credential appears here.

Procedure. 1. Call POST /api/pub/hr/leave-search with Authorization: Bearer <managed-secret-from-protected-store> or the supported X-Api-Key form. 2. Supply only the reviewed declared inputs. 3. Inspect the real RuleExecutionResult shape rather than assuming an invented generic success/data envelope. 4. Keep the key’s workspace and scopes authoritative even if a caller sends another X-Workspace-Id. 5. Test a missing required input and an unknown supplied input in an authorized isolated fixture before integrating the consumer.

{
  "inputs": {
    "employeeId": "actual-admitted-employee-id",
    "status": "PENDING"
  }
}

Expected result. The native filter authenticates and pins the workspace; dispatch resolves an eligible registry target and enforces API scope/status plus rule input semantics. Adding a workspace header cannot make the same key query another workspace.

Failure and recovery. An invalid/revoked/expired key, suspended API, out-of-scope path or unavailable exposed target must remain a distinct refusal. Fix the credential/registry/input issue through its owner. Do not retry with another person’s credential, invent a new key in the client, or convert a contract failure into an empty business result.

Sources. AdminManagedApiKeyController.java, AdminPublishedApiController.java, PublishedApiDispatchController.java.

Example DATA-API-03 — Narrow a credential and rotate only when its secret must change

Scenario and inputs. An integration previously covered several published APIs but now needs only the leave-search route and a lower rate limit. Its existing secret may also have been exposed. Nadia must distinguish changing policy from replacing a secret, and preserve concurrent-edit refusal behavior.

Procedure. 1. Read the current key metadata under the proper workspace-admin authority. 2. PATCH /api/api-management/keys/{id} with only supported policy fields, such as the complete narrowing body below. 3. Use a strict subset of the current API_KEYS list, or narrow ALL_PUBLISHED to an explicit list; do not widen an existing key. 4. If the secret is exposed, rotate through the separate native endpoint and transfer the successor’s show-once secret securely. 5. Update the consumer and retire the predecessor according to the actual atomic rotation result, then read back metadata.

{
  "scope": "API_KEYS",
  "apiKeys": [
    "hr-leave-search"
  ],
  "callsPerMinute": 30
}

Expected result. Policy editing retains the secret and writes only the supported policy change. Rotation issues a successor and revokes the predecessor while retaining the chosen scope, so it is not a substitute for removing an unwanted API grant.

Failure and recovery. A concurrent edit/revoke/rotation or no-longer-editable key is a 409-style state problem; reload and reconcile the intended policy instead of blindly resubmitting a stale edit. A scope-widening refusal requires a new deliberately reviewed key, not a changed hidden field. Never place either secret in audit text or documentation.

Sources. AdminManagedApiKeyController.java, AdminManagedApiKeyUpdateRequest.java.

Example DATA-API-04 — Diagnose a failed call with sanitized logs and honest stream scope

Scenario and inputs. The consumer reports that a call was refused or disconnected. The operator can read request-log metadata for the exact workspace but must not inspect secret/request/response bodies through a logging backdoor. A live stream may be attached to one API node in an active-active deployment.

Procedure. 1. Correlate the consumer’s nonsecret call time/path/key metadata with the permitted request-log filters. 2. Separate invalid-key, rate-limit, suspended-route, unavailable-target and actual rule failure outcomes using the native safe codes/status. 3. Inspect whether the shared limiter’s storage is unavailable rather than interpreting a fail-closed 503 as a free rate-limit bypass. 4. Use persisted filtered log history to recover gaps when a live stream disconnects or follows a different node. 5. For a potentially mutating target, reconcile its own native intent/receipt before any retry; a missing stream event does not prove no effect occurred.

Expected result. The log explains the routing/security outcome without exposing raw credentials or business content. Same-node live delivery remains explicitly bounded, while persisted authorized history is the durable diagnostic path.

Failure and recovery. Do not log bearer secrets or full bodies to make troubleshooting easier, widen an API key to evade a scope error, or replay an uncertain business mutation solely because the SSE viewer disconnected. Keep the appropriate credential, registry, limiter or rule owner accountable for the concrete failed boundary.

Sources. AdminApiRequestLogController.java, AdminApiLogStreamController.java, PublishedApiDispatchController.java.

Detailed reference

Document status: Current contract reference with source-reviewed teaching scenarios. These examples are not new runtime, credential or deployment qualification.

The API-management domain governs how external machine consumers reach the platform's published APIs: managed API keys (security), a published-API registry, request logging, and live log streaming. This manual covers the implemented S1 managed-key, S2 registry/dispatch, S3 request-log, and S4 live streaming slices. Limitations are called out where they remain, including the same-node stream boundary in active-active deployments.

Managed API keys

Managed keys (inf_ak_…) authenticate machine callers on the published-API surface /api/pub/**. They complement — not replace — user API keys (identity_api_keys, interactive/user-bound) and rule Web-API keys (inf_rk_…, rule-execution only).

Key properties:

  • Show-once secret. inf_ak_ + 32 url-safe random characters. Storage holds only SHA-256(salt ‖ secret) with a random per-key salt; the plaintext exists only in the issue/rotate response.
  • Workspace-pinned. A verified key pins the request to its own workspace; a caller-supplied X-Workspace-Id is ignored.
  • Scoped. ALL_PUBLISHED (default) covers every published API in the workspace; API_KEYS restricts to an explicit published-API key list.
  • Rate-limited. Per-key token bucket (Bucket4j) backed by PostgreSQL (api_managed_key_buckets), so active-active nodes share one budget. callsPerMinute overrides the platform default (apiManagement.keys.defaultMaxCallsPerMinute, default 600). Exhaustion returns 429; limiter storage failure fails closed with 503. A bucket's configuration is captured at first use, so every call also compares it with the key's current limit and reconfigures the bucket when they differ. A changed callsPerMinute, or a changed platform default, therefore applies from the next call that reads it. Calls already in flight with the old limit are decided under it, but cannot pin it.
  • Expirable and revocable. expiresAt is optional; revocation is immediate. Rotation issues a successor with identical name/scope/limits and revokes the predecessor in one operation.

Admin REST surface

All endpoints require platform permissions (API_MANAGEMENT_VIEW / API_MANAGEMENT_MANAGE, seeded to platform-administrators by migration 121) and workspace ADMIN at the service layer. The surface is deliberately mounted outside /api/admin/** so WorkspaceContextFilter applies: send X-Workspace-Id — keys are managed per workspace.

GET    /api/api-management/keys
POST   /api/api-management/keys
POST   /api/api-management/keys/{id}/rotate
PATCH  /api/api-management/keys/{id}
DELETE /api/api-management/keys/{id}

Issue body:

{
  "name": "billing-integration",
  "scope": "API_KEYS",
  "apiKeys": ["invoices"],
  "callsPerMinute": 300,
  "expiresAt": "2027-01-01T00:00:00Z"
}

Change body (SCRUM-145) — any subset of the policy fields; an absent field is unchanged, null clears it (platform default rate limit, no expiry):

{
  "callsPerMinute": 120,
  "expiresAt": "2027-06-01T00:00:00Z",
  "scope": "API_KEYS",
  "apiKeys": ["invoices"]
}

A change keeps the secret; rotate to replace it. Only these four fields are accepted (anything else is 400 API_KEY_UPDATE_FIELD_UNSUPPORTED). The scope can only narrow: ALL_PUBLISHED may become an API_KEYS list, and an API_KEYS list may become a subset of itself; widening is 403 API_KEY_SCOPE_WIDENING (issue a new key for wider access). A new expiry must be in the future (API_KEY_EXPIRY_INVALID); there is no maximum lifetime, as on issue. A revoked or expired key cannot be changed (409 API_KEY_NOT_EDITABLE), and an edit that loses to a concurrent edit, revoke or rotate is 409 API_KEY_CONCURRENT_UPDATE, as is a key that expired after it was read. A changed callsPerMinute evicts the key's bucket after the commit, and the limiter reconciles any bucket still built with the old limit on the next call, so the new limit holds even under concurrent traffic. Extending or clearing an expiry prolongs the secret that is already in callers' hands; rotate when that secret may be exposed. Changing a key needs workspace ADMIN and the platform API_MANAGEMENT_MANAGE; without both, Studio shows no key-changing control. In Studio, the key row's Edit action offers the same narrowing-only choice.

The issue/rotate response carries secret exactly once. Every lifecycle mutation writes audit evidence (MANAGED_API_KEY_ISSUED / _ROTATED / _REVOKED) with prefix/scope metadata only — never secret material. A change writes MANAGED_API_KEY_UPDATED with the old and new scope, API list, rate limit and expiry (no secret); a refused or no-op change writes nothing.

Calling a published API

POST /api/pub/invoices
Authorization: Bearer inf_ak_...

or equivalently X-Api-Key: inf_ak_.... Failures: 401 API_KEY_INVALID (unknown/revoked/expired), 429 API_KEY_RATE_LIMITED, 503 API_KEY_RATE_LIMIT_UNAVAILABLE.

Published APIs

A published API (slice S2) binds a public path under /api/pub/** to an exposed rule version inside one workspace. Publishing mints the machine apiKey server-side from the path (segments joined with -), which is what API_KEYS-scoped managed keys list.

Registry properties:

  • Strict paths. Lowercase segments of [a-z0-9-] separated by /, unique per workspace (UNIQUE(workspace_id, path)).
  • Exposed targets only. The rule key must resolve to an exposed Web-API version at publish time; unknown or unexposed rules are rejected with PUBLISHED_API_RULE_NOT_EXPOSED and never reach the registry.
  • Suspend is the kill switch. SUSPENDED APIs refuse dispatch with 403 PUBLISHED_API_SUSPENDED without touching the rule; resume re-enables.
  • Audited. Publish/suspend/resume/delete write PUBLISHED_API_PUBLISHED / _SUSPENDED / _RESUMED / _DELETED.
  • Delete is a hard delete — and re-publish re-grants. Because the apiKey is derived from the path, republishing the same path mints the same apiKey again. Any existing API_KEYS-scoped managed key that lists that apiKey silently regains access to the re-published API. If that is not intended, revoke those keys and issue replacements with the correct scope — rotation is NOT a mitigation here, because rotation carries the predecessor's scope list forward unchanged. Narrowing the key with PATCH /api/api-management/keys/{id} (drop that apiKey) is.

Admin REST surface

Same mounting rule as keys (outside /api/admin/**, so WorkspaceContextFilter applies — send X-Workspace-Id), same permissions (API_MANAGEMENT_VIEW / API_MANAGEMENT_MANAGE), workspace ADMIN at the service layer.

GET    /api/api-management/published-apis
POST   /api/api-management/published-apis
POST   /api/api-management/published-apis/{apiKey}/suspend
POST   /api/api-management/published-apis/{apiKey}/resume
DELETE /api/api-management/published-apis/{apiKey}
GET    /api/api-management/published-apis/{apiKey}/openapi

Publish body:

{
  "name": "Invoice search",
  "description": "Find invoices by status",
  "path": "billing/invoices",
  "ruleKey": "invoice-search"
}

The openapi endpoint returns an OpenAPI 3.1 document for the single public path (/api/pub/{path}) with the rule's declared input contract as the request schema and the inf_ak_ managed key as the security scheme (Bearer or X-Api-Key).

Dispatch semantics

POST /api/pub/billing/invoices
Authorization: Bearer inf_ak_...

{"inputs": {"status": "OPEN"}}

Dispatch resolves the registry row by (workspace, path) — the key pins the workspace — then enforces, in order: the key covers the apiKey (403 API_KEY_OUT_OF_SCOPE), status ACTIVE (403 PUBLISHED_API_SUSPENDED), the rule still has an exposed version (404 PUBLISHED_API_TARGET_UNAVAILABLE), and the body satisfies the rule's declared input contract (400 RULE_INPUT_*). The rule executes as its latest EXPOSED version — never an unexposed one — with caller tag managed-api-key:<keyId> for audit attribution. Unknown paths return 404 PUBLISHED_API_NOT_FOUND; a request that reaches dispatch without a verified key returns 401 API_KEY_REQUIRED.

Request logs

Every /api/pub/** call writes one structured row to api_request_logs (slice S3) — including filter-level rejections (401/429/503), because the capture filter (ApiRequestLogCaptureFilter) is registered before ManagedApiKeyFilter and writes after the chain completes.

Row content is deliberately narrow: managed key id (never the secret), published-API apiKey (nullable when the path matched no registry row), path, method, status, outcome (SUCCESS iff status < 400 and no chain exception), duration, client (the direct peer address only — X-Forwarded-For is forgeable by any caller and ignored until a trusted-proxy configuration exists), the ApiManagementException code for dispatch failures, and timestamp. No request bodies, response bodies, or header values are ever captured. Capture is fail-open: a logging failure is logged at warn and never breaks dispatch.

Rejections are attributed honestly. A verified key's 429/503 row carries the key id and the key's pinned workspace. A 401 row has no verified key and is pinned to the platform backfill workspace: a caller-supplied X-Workspace-Id is never honored for unauthenticated traffic, because rejected calls never reach the rate limiter and honoring the header would be unbounded cross-workspace log pollution. A chain exception records status 500 (the response status is still 200 before the servlet container's error dispatch). Paths are stored with issued-token literals masked but otherwise intact — the sensitive-substring log rule would blank legitimate paths such as partner/token-exchange.

Admin REST surface

Same mounting rule and permissions as keys/published-apis (X-Workspace-Id required; workspace ADMIN at the service layer for search and retention runs — logs are other callers' traffic).

GET  /api/api-management/logs?apiKey=&keyId=&outcome=&from=&to=&page=0&size=50
GET  /api/api-management/logs/retention/policy
POST /api/api-management/logs/retention?dryRun=true

Search filters are conjunctive; outcome is SUCCESS|FAILED, from/to are ISO-8601 instants, size caps at 200 and page at 10,000 (so page * size cannot overflow into a negative SQL OFFSET). The page envelope is {items, page, size, total}. Retention deletes rows older than apiManagement.logs.retentionDays (default 30) across all workspaces in bounded batches of 5,000 rows (served by the created_at index, migration 124), so one run never locks the whole retention window at once. Because the delete is table-wide, the service decorator is fail-closed — a caller with no actor is denied — and API_MANAGEMENT_MANAGE must stay restricted to platform administrators. dryRun defaults to true and reports matched without deleting. Every retention run writes an API_REQUEST_LOG_RETENTION_RUN audit event with scope=all-workspaces and counts only. Search is not audited.

Studio log viewer filters

The request-log toolbar combines free text, published API, managed API key, outcome and time range (SCRUM-155, SCRUM-161). The key picker lists exactly the keys GET /api/api-management/keys returns for the workspace (revoked keys included, so a leaked key's traffic can still be audited); it has the same API_MANAGEMENT_VIEW + workspace ADMIN gate as the search. A failed key read is treated as an outage: the picker lists no keys, but an applied key filter stays applied (shown as "Selected key") and stays in the URL. Only a successfully loaded list drops a key filter that is not one of its keys. View traffic on an API-key row opens the log filtered to that key, addressable as ?res=request-logs&logKey=<key id>. The time range offers Custom window, whose From/To date-times (the viewer's local time) are sent as from/to instants; either bound may be left open, and a window whose end is not after its start sends no search. Every filter change returns paging to the first page. The live tail applies the published API and outcome on the server and the key filter in the browser; changing a live filter also removes rows already shown that it excludes. It applies no time window.

Live log streaming

Studio tails the request log over Server-Sent Events (slice S4). Because EventSource cannot set headers, the stream endpoint does not use session auth — a one-time stream ticket is the credential:

POST /api/api-management/logs/stream-ticket          → {ticket, expiresAt}
GET  /api/api-management/logs/stream?ticket=…&apiKey=&outcome=
  • POST /stream-ticket uses normal platform auth (API_MANAGEMENT_VIEW, workspace-scoped by WorkspaceContextFilter — send X-Workspace-Id) AND the workspace-ADMIN gate (requireRoleIfActor(GrantRole.ADMIN, null, null)) that SecuredApiRequestLogService.search applies to the same data — request logs are other callers' traffic, so a live view of them is held to the same bar. It mints a 128-bit SecureRandom URL-safe ticket with a 60-second TTL, bound to the issuing workspace AND actor, and stores it in memory. Outstanding (minted-but-unconsumed) tickets are capped at 1024 per node; minting beyond the cap is rejected with 429 (STREAM_TICKET_CAPACITY).
  • GET /stream is permitAll in the security chain and skipped by WorkspaceContextFilter; the controller validates the apiKey/outcome filter params first (a bad filter value never burns a ticket), then validates AND consumes the ticket in one atomic remove — unknown, expired, or replayed tickets get 401 (STREAM_TICKET_INVALID, deny-by-default; the EventSource Accept: text/event-stream header still gets the 401 error body, not a negotiation failure). The emitter is scoped to the ticket's workspace at the hub; the optional apiKey/outcome filter params can only narrow within it.
  • Because the stream outlives the minting request, both mint-time gates are re-run for the ticket's actor on every heartbeat (checkAccess + effectiveAccess resolve by actor id, not request context); a revoked permission or workspace-ADMIN role drops the stream within one heartbeat interval, and a failed re-check denies (fail-closed). The heartbeat thread's effective-access memo is cleared ONCE per beat, so subscriptions sharing an actor+workspace resolve once per beat, not once per subscription.
  • Heartbeat comment every 15 s so proxies keep the connection; one stream lives at most 30 minutes (SseEmitter timeout), then the client re-mints. Completion, timeout, and error all remove the subscription.
  • Publish and heartbeats never write to a client inline: every subscription owns a bounded queue (1,000 events) drained by a small hub-owned pool, so one stalled consumer cannot apply backpressure to /api/pub/** dispatch threads or silence other subscribers' heartbeats. A subscription whose queue overflows is dropped, and a send blocked longer than 60 s is marked and removed by the heartbeat watchdog (the stall sweep runs over all subscriptions BEFORE any re-authorization work each beat, so a slow grant-store lookup cannot delay stall detection). Because ResponseBodyEmitter send/complete share one monitor, every server-side drop completes the emitter on a hub delivery-pool thread — never the publish or heartbeat thread, which could otherwise hang behind a stalled or just-starting write. The drain completes the emitter once any in-flight write returns; an idle subscription completes as soon as a delivery-pool thread is free (its completion task may queue behind other subscribers' blocked writes — never on the publish/heartbeat thread); a write that never returns is bounded by the container's async/write timeout, never by other subscribers' delivery. Subscriptions are capped at 256 per node AND 64 per workspace (one tenant cannot starve the rest), with registration beyond either cap rejected with 429 (STREAM_SUBSCRIPTION_CAPACITY). A capacity rejection restores the already-consumed ticket, so the retryable 429 never burns the single-use credential.
  • Events carry the ApiRequestLog fields only (id, keyId, apiKey, path, method, statusCode, outcome, durationMs, client, errorCode, createdAt) — never bodies or secrets, and not the workspace id. The ticket value itself travels in the query string, and the stream endpoint binds its params as a Map precisely so ServiceLoggingAspect records Map(size=N) instead of values — the one-time credential never appears in the operation logs (regression-tested through the real aspect). LogSanitizer additionally masks any logged value containing the query-shaped ticket=, while STREAM_TICKET_* problem details stay readable.
  • The capture filter publishes each row to the hub AFTER the insert succeeds; hub delivery is fail-open per subscriber (a failed send removes that subscriber and never affects capture).

Same-node limitation (active-active): the ticket store and the subscription hub are in-memory per node. A ticket minted on node A is unknown on node B, and a stream only sees rows captured by the node serving it — there is deliberately no cross-node broadcast in this slice. Pin the viewer to one node (or accept per-node visibility) until a broadcast slice lands.

The Studio viewer (/workspaces/:workspaceKey/api-management, linked from the workspace Monitor tab) mints a fresh ticket for every connect and reconnect (tickets are single-use, never reused), and falls back to polling the paged search endpoint when EventSource cannot connect at all.

Architecture notes

  • Domain module platform-api-management holds the key model, ports, service decorators (default → secured → audited, mirroring the rule Web-API key stack), the JDBC adapter, and the admin controller.
  • The authentication filter (ManagedApiKeyFilter) and the Bucket4j PostgreSQL limiter live monolith-side in api/security, registered before PlatformAuthenticationFilter, following the RuleApiKeyFilter precedent.
  • The published-API registry reuses the same module shape: PublishedApi domain, service port with default → secured → audited decorators, JDBC adapter, admin controller. The rule-target validator port (PublishedApiTargetValidator) keeps the module free of rule-domain dependencies; the monolith adapter (api/apimgmt/ RulePublishedApiTargetValidator) binds it to the rule catalog, and the monolith PublishedApiDispatchController owns /api/pub/** dispatch and the per-API OpenAPI document (both need rule types).
  • The request-log stack reuses the module shape: ApiRequestLog domain, service port with default → secured → audited decorators, JDBC adapter, admin controller. The capture filter (api/logging/ApiRequestLogCaptureFilter) lives monolith-side and is ordered before ManagedApiKeyFilter; the dispatch controller exposes two request attributes (PUBLISHED_API_LOG_ATTRIBUTE, PUBLISHED_API_ERROR_CODE_ATTRIBUTE) so the filter can attribute rows without parsing response bodies.
  • The live-stream stack (S4) is HTTP-concern and stays monolith-side: api/apimgmt/ApiLogStreamTicketStore (one-time tickets), api/apimgmt/ApiLogStreamHub (same-node subscriptions), and api/controller/AdminApiLogStreamController. The capture filter publishes each persisted row to the hub; the module keeps its foundation+kernel-only dependency set.
  • Tables: api_managed_keys, api_managed_key_buckets (migration 124), api_published_apis (migration 125), api_request_logs (migration 126).

Try “document generation”, “integrations” or “first form”.