import * as apprunner from "@distilled.cloud/aws/apprunner";
import { Unowned } from "alchemy/AdoptPolicy";
import { isResolved } from "alchemy/Diff";
import { createPhysicalName } from "alchemy/PhysicalName";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import { createInternalTags, hasAlchemyTags } from "alchemy/Tags";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";
import * as Stream from "effect/Stream";
import type { Providers } from "../Providers.ts";
import { isActiveStatus, readAppRunnerTags, syncAppRunnerTags, toWireTags } from "./internal.ts";
export class ObservabilityConfigurationUnexpectedResponse extends Data.TaggedError(
"ObservabilityConfigurationUnexpectedResponse",
)<{
readonly message: string;
readonly cause?: unknown;
}> {}
/**
* Tracing configuration for an observability configuration.
*/
export interface ObservabilityTraceConfiguration {
/**
* The tracing vendor. `AWSXRAY` is the only supported vendor.
*/
vendor: "AWSXRAY";
}
export interface ObservabilityConfigurationProps {
/**
* Name of the observability configuration. Must be 4-32 characters
* (letters, digits, hyphens, underscores). If omitted, a deterministic
* physical name is generated. Changing the name replaces the
* configuration (all revisions of the old name are deleted).
*/
observabilityConfigurationName?: string;
/**
* Tracing configuration. Omit to create a configuration with tracing
* disabled (services referencing it emit no traces).
*/
traceConfiguration?: ObservabilityTraceConfiguration;
/**
* User-defined tags for the configuration.
*/
tags?: Record<string, string>;
}
export interface ObservabilityConfiguration extends Resource<
"AWS.AppRunner.ObservabilityConfiguration",
ObservabilityConfigurationProps,
{
/**
* Name of the observability configuration.
*/
observabilityConfigurationName: string;
/**
* ARN of this observability configuration revision.
*/
observabilityConfigurationArn: string;
/**
* Revision number of the configuration (revisions are immutable).
*/
observabilityConfigurationRevision: number;
/**
* The configured tracing vendor, if tracing is enabled.
*/
traceVendor: string | undefined;
},
never,
Providers
> {}
/**
* An AWS App Runner observability configuration — enables AWS X-Ray tracing
* for the App Runner services that reference it.
*
* Observability configurations are immutable revisions: changing
* `traceConfiguration` creates a new revision under the same name (the ARN
* and revision attributes change). A configuration can be shared across
* multiple App Runner services.
* ### Creating an Observability Configuration
* **Example:** X-Ray Tracing Configuration
* ```typescript
* const observability = yield* AppRunner.ObservabilityConfiguration("Tracing", {
* traceConfiguration: { vendor: "AWSXRAY" },
* });
* ```
*
* ### Using with an App Runner Service
* **Example:** Attach to a Service
* ```typescript
* const service = yield* AppRunner.Service("Api", {
* imageRepository: {
* imageIdentifier: "public.ecr.aws/aws-containers/hello-app-runner:latest",
* imageRepositoryType: "ECR_PUBLIC",
* port: "8000",
* },
* observabilityConfiguration: {
* observabilityEnabled: true,
* observabilityConfigurationArn:
* observability.observabilityConfigurationArn,
* },
* });
* ```
*
* @resource
*/
export const ObservabilityConfiguration = Resource<ObservabilityConfiguration>(
"AWS.AppRunner.ObservabilityConfiguration",
);
export const ObservabilityConfigurationProvider = () =>
Provider.effect(
ObservabilityConfiguration,
Effect.gen(function* () {
const toName = (id: string, props: ObservabilityConfigurationProps) =>
props.observabilityConfigurationName
? Effect.succeed(props.observabilityConfigurationName)
: createPhysicalName({ id, maxLength: 32 });
/** Find the latest ACTIVE revision of a configuration by name. */
const findLatest = Effect.fn(function* (name: string) {
const page = yield* apprunner.listObservabilityConfigurations({
ObservabilityConfigurationName: name,
LatestOnly: true,
});
const summary = (page.ObservabilityConfigurationSummaryList ?? []).find(
(s) =>
s.ObservabilityConfigurationName === name &&
s.ObservabilityConfigurationArn !== undefined,
);
if (!summary?.ObservabilityConfigurationArn) return undefined;
const described = yield* apprunner
.describeObservabilityConfiguration({
ObservabilityConfigurationArn: summary.ObservabilityConfigurationArn,
})
.pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));
const config = described?.ObservabilityConfiguration;
return config !== undefined && isActiveStatus(config.Status) ? config : undefined;
});
const toAttrs = Effect.fn(function* (config: apprunner.ObservabilityConfiguration) {
if (
!config.ObservabilityConfigurationName ||
!config.ObservabilityConfigurationArn ||
config.ObservabilityConfigurationRevision === undefined
) {
return yield* new ObservabilityConfigurationUnexpectedResponse({
message: "App Runner observability configuration is missing its name, ARN, or revision",
});
}
return {
observabilityConfigurationName: config.ObservabilityConfigurationName,
observabilityConfigurationArn: config.ObservabilityConfigurationArn,
observabilityConfigurationRevision: config.ObservabilityConfigurationRevision,
traceVendor: config.TraceConfiguration?.Vendor,
};
});
/**
* Delete every ACTIVE revision that shares the configuration name.
* `DeleteObservabilityConfiguration` has no `DeleteAllRevisions`
* flag (unlike auto scaling configurations), so enumerate and delete
* each revision. A revision still referenced by a service rejects
* with InvalidRequestException — retry through that window (bounded).
*/
const deleteAllRevisions = Effect.fn(function* (name: string) {
const pages = yield* apprunner.listObservabilityConfigurations
.pages({
ObservabilityConfigurationName: name,
LatestOnly: false,
})
.pipe(Stream.runCollect);
const arns = Array.from(pages).flatMap((page) =>
(page.ObservabilityConfigurationSummaryList ?? [])
.filter((s) => s.ObservabilityConfigurationName === name)
.flatMap((s) =>
s.ObservabilityConfigurationArn !== undefined
? [s.ObservabilityConfigurationArn]
: [],
),
);
for (const arn of arns) {
yield* apprunner
.deleteObservabilityConfiguration({
ObservabilityConfigurationArn: arn,
})
.pipe(
Effect.catchTag("ResourceNotFoundException", () => Effect.void),
Effect.retry({
while: (e) => e._tag === "InvalidRequestException",
schedule: Schedule.max([Schedule.fixed("5 seconds"), Schedule.recurs(24)]),
}),
);
}
});
return {
stables: ["observabilityConfigurationName"],
diff: Effect.fn(function* ({ id, olds, news }) {
if (!isResolved(news)) return undefined;
if ((yield* toName(id, olds ?? {})) !== (yield* toName(id, news ?? {}))) {
return { action: "replace" } as const;
}
}),
read: Effect.fn(function* ({ id, olds, output }) {
const name = output?.observabilityConfigurationName ?? (yield* toName(id, olds ?? {}));
const config = yield* findLatest(name);
if (config === undefined) return undefined;
const attrs = yield* toAttrs(config);
const tags = yield* readAppRunnerTags(attrs.observabilityConfigurationArn);
return (yield* hasAlchemyTags(id, tags)) ? attrs : Unowned(attrs);
}),
reconcile: Effect.fn(function* ({ id, news = {}, output, session }) {
const name = output?.observabilityConfigurationName ?? (yield* toName(id, news));
const internalTags = yield* createInternalTags(id);
const desiredTags = { ...internalTags, ...news.tags };
// 1. Observe — the latest ACTIVE revision is authoritative.
let observed = yield* findLatest(name);
// 2/3. Ensure + sync — trace settings live on immutable
// revisions, so a drift on the user-specified vendor is converged
// by creating a new revision under the same name. Only compare
// what the user actually specified.
const drifted =
observed !== undefined &&
news.traceConfiguration !== undefined &&
news.traceConfiguration.vendor !== observed.TraceConfiguration?.Vendor;
if (observed === undefined || drifted) {
const created = yield* apprunner.createObservabilityConfiguration({
ObservabilityConfigurationName: name,
TraceConfiguration: news.traceConfiguration
? { Vendor: news.traceConfiguration.vendor }
: undefined,
Tags: toWireTags(desiredTags),
});
observed = created.ObservabilityConfiguration;
}
// 3b. Sync tags on the latest revision ARN — diff against
// OBSERVED cloud tags.
if (observed.ObservabilityConfigurationArn) {
yield* syncAppRunnerTags(observed.ObservabilityConfigurationArn, desiredTags);
}
// 4. Return fresh attributes.
yield* session.note(name);
return yield* toAttrs(observed);
}),
delete: Effect.fn(function* ({ output }) {
yield* deleteAllRevisions(output.observabilityConfigurationName);
}),
list: () =>
apprunner.listObservabilityConfigurations.pages({ LatestOnly: true }).pipe(
Stream.runCollect,
Effect.map((chunk) =>
Array.from(chunk).flatMap((page) =>
(page.ObservabilityConfigurationSummaryList ?? []).flatMap((s) =>
s.ObservabilityConfigurationArn !== undefined &&
// App Runner ships an AWS-managed `DefaultConfiguration`
// revision that always exists and can never be deleted
// — keep it out of enumeration for account-wide
// teardown (nuke).
s.ObservabilityConfigurationName !== "DefaultConfiguration"
? [s.ObservabilityConfigurationArn]
: [],
),
),
),
Effect.flatMap(
Effect.forEach(
(arn) =>
apprunner
.describeObservabilityConfiguration({
ObservabilityConfigurationArn: arn,
})
.pipe(
Effect.flatMap((r) =>
isActiveStatus(r.ObservabilityConfiguration.Status)
? Effect.map(
toAttrs(r.ObservabilityConfiguration),
(attrs) =>
attrs as ObservabilityConfiguration["Attributes"] | undefined,
)
: Effect.undefined,
),
// Tolerate a delete race — drop the item.
Effect.catchTag("ResourceNotFoundException", () => Effect.undefined),
),
{ concurrency: 4 },
),
),
Effect.map((items) => items.filter((item) => item !== undefined)),
),
};
}),
);