import * as amp from "@distilled.cloud/aws/amp";
import { isResolved } from "alchemy/Diff";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";
import type { Providers } from "../Providers.ts";
import { normalizeAmpLogGroupArn } from "./internal.ts";
export interface LoggingConfigurationProps {
/**
* Id of the AMP workspace whose rules/alerting logs are shipped. A
* workspace has at most one logging configuration. Changing the workspace
* replaces the configuration.
*/
workspaceId: string;
/**
* ARN of the CloudWatch Logs log group that receives the workspace's rule
* evaluation and alerting (vended) logs. AMP expects the ARN with a
* trailing `:*` — one is appended automatically when missing.
*/
logGroupArn: string;
}
export interface LoggingConfiguration extends Resource<
"AWS.AMP.LoggingConfiguration",
LoggingConfigurationProps,
{
workspaceId: string;
logGroupArn: string;
status: string;
},
never,
Providers
> {}
/**
* The rules/alerting logging configuration of an Amazon Managed Service for
* Prometheus workspace — ships rule evaluation failures and Alertmanager
* delivery errors to a CloudWatch Logs log group. A workspace has at most
* one.
*
* ### Creating a Logging Configuration
* **Example:** Ship Rule and Alerting Logs to CloudWatch Logs
* ```typescript
* const workspace = yield* AMP.Workspace("Metrics", {});
* const logs = yield* Logs.LogGroup("AmpLogs", {
* logGroupName: "/aws/vendedlogs/prometheus/metrics",
* });
* const logging = yield* AMP.LoggingConfiguration("Logging", {
* workspaceId: workspace.workspaceId,
* logGroupArn: logs.logGroupArn,
* });
* ```
*
* @resource
*/
export const LoggingConfiguration = Resource<LoggingConfiguration>("AWS.AMP.LoggingConfiguration");
export const LoggingConfigurationProvider = () =>
Provider.effect(
LoggingConfiguration,
Effect.gen(function* () {
/** Describe the configuration; typed not-found → undefined. */
const describe = Effect.fn(function* (workspaceId: string) {
const response = yield* amp
.describeLoggingConfiguration({ workspaceId })
.pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));
return response?.loggingConfiguration;
});
/**
* Bounded wait toward ACTIVE. Returns the last observed metadata —
* a still-transitioning configuration converges on a later reconcile.
*/
const waitActive = Effect.fn(function* (workspaceId: string) {
return yield* amp.describeLoggingConfiguration({ workspaceId }).pipe(
Effect.map((r) => r.loggingConfiguration),
Effect.repeat({
schedule: Schedule.max([Schedule.fixed("2 seconds"), Schedule.recurs(20)]),
until: (c) => c.status.statusCode === "ACTIVE",
}),
);
});
const toAttrs = (meta: amp.LoggingConfigurationMetadata) => ({
workspaceId: meta.workspace,
logGroupArn: meta.logGroupArn,
status: meta.status.statusCode,
});
return {
stables: ["workspaceId"],
diff: Effect.fn(function* ({ olds, news }) {
if (!isResolved(news)) return undefined;
if (olds?.workspaceId !== news.workspaceId) {
return { action: "replace" } as const;
}
}),
read: Effect.fn(function* ({ olds, output }) {
const workspaceId = output?.workspaceId ?? olds?.workspaceId;
if (!workspaceId) return undefined;
const meta = yield* describe(workspaceId);
if (meta === undefined) return undefined;
// Logging configurations are not taggable — ownership is implied
// by the owned parent workspace.
return toAttrs(meta);
}),
reconcile: Effect.fn(function* ({ news, session }) {
const workspaceId = news!.workspaceId;
const desiredArn = normalizeAmpLogGroupArn(news!.logGroupArn);
// 1. Observe — the live configuration is authoritative.
const existing = yield* describe(workspaceId);
// 2/3. Ensure + sync — create when absent (tolerating a create
// race), update when the log group drifts.
if (existing === undefined) {
yield* amp
.createLoggingConfiguration({
workspaceId,
logGroupArn: desiredArn,
})
.pipe(
Effect.catchTag("ConflictException", () =>
amp.updateLoggingConfiguration({
workspaceId,
logGroupArn: desiredArn,
}),
),
);
} else if (existing.logGroupArn !== desiredArn) {
yield* amp.updateLoggingConfiguration({
workspaceId,
logGroupArn: desiredArn,
});
}
const fresh = yield* waitActive(workspaceId);
yield* session.note(workspaceId);
return toAttrs(fresh);
}),
delete: Effect.fn(function* ({ output }) {
yield* amp.deleteLoggingConfiguration({ workspaceId: output.workspaceId }).pipe(
Effect.catchTag("ResourceNotFoundException", () => Effect.void),
Effect.retry({
while: (e) => e._tag === "ConflictException",
schedule: Schedule.max([Schedule.fixed("3 seconds"), Schedule.recurs(20)]),
}),
);
}),
// Singleton sub-resource keyed by its parent workspace.
list: () => Effect.succeed([]),
};
}),
);