The best way to control Claude Code, Codex and more from any computer or phone

main
ts 307 lines 11.9 KB
Raw
1 import * as apprunner from "@distilled.cloud/aws/apprunner";
2 import { Unowned } from "alchemy/AdoptPolicy";
3 import { isResolved } from "alchemy/Diff";
4 import { createPhysicalName } from "alchemy/PhysicalName";
5 import * as Provider from "alchemy/Provider";
6 import { Resource } from "alchemy/Resource";
7 import { createInternalTags, hasAlchemyTags } from "alchemy/Tags";
8 import * as Data from "effect/Data";
9 import * as Effect from "effect/Effect";
10 import * as Schedule from "effect/Schedule";
11 import * as Stream from "effect/Stream";
12 import type { Providers } from "../Providers.ts";
13 import { isActiveStatus, readAppRunnerTags, syncAppRunnerTags, toWireTags } from "./internal.ts";
14
15 export class ObservabilityConfigurationUnexpectedResponse extends Data.TaggedError(
16 "ObservabilityConfigurationUnexpectedResponse",
17 )<{
18 readonly message: string;
19 readonly cause?: unknown;
20 }> {}
21
22 /**
23 * Tracing configuration for an observability configuration.
24 */
25 export interface ObservabilityTraceConfiguration {
26 /**
27 * The tracing vendor. `AWSXRAY` is the only supported vendor.
28 */
29 vendor: "AWSXRAY";
30 }
31
32 export interface ObservabilityConfigurationProps {
33 /**
34 * Name of the observability configuration. Must be 4-32 characters
35 * (letters, digits, hyphens, underscores). If omitted, a deterministic
36 * physical name is generated. Changing the name replaces the
37 * configuration (all revisions of the old name are deleted).
38 */
39 observabilityConfigurationName?: string;
40 /**
41 * Tracing configuration. Omit to create a configuration with tracing
42 * disabled (services referencing it emit no traces).
43 */
44 traceConfiguration?: ObservabilityTraceConfiguration;
45 /**
46 * User-defined tags for the configuration.
47 */
48 tags?: Record<string, string>;
49 }
50
51 export interface ObservabilityConfiguration extends Resource<
52 "AWS.AppRunner.ObservabilityConfiguration",
53 ObservabilityConfigurationProps,
54 {
55 /**
56 * Name of the observability configuration.
57 */
58 observabilityConfigurationName: string;
59 /**
60 * ARN of this observability configuration revision.
61 */
62 observabilityConfigurationArn: string;
63 /**
64 * Revision number of the configuration (revisions are immutable).
65 */
66 observabilityConfigurationRevision: number;
67 /**
68 * The configured tracing vendor, if tracing is enabled.
69 */
70 traceVendor: string | undefined;
71 },
72 never,
73 Providers
74 > {}
75
76 /**
77 * An AWS App Runner observability configuration — enables AWS X-Ray tracing
78 * for the App Runner services that reference it.
79 *
80 * Observability configurations are immutable revisions: changing
81 * `traceConfiguration` creates a new revision under the same name (the ARN
82 * and revision attributes change). A configuration can be shared across
83 * multiple App Runner services.
84 * ### Creating an Observability Configuration
85 * **Example:** X-Ray Tracing Configuration
86 * ```typescript
87 * const observability = yield* AppRunner.ObservabilityConfiguration("Tracing", {
88 * traceConfiguration: { vendor: "AWSXRAY" },
89 * });
90 * ```
91 *
92 * ### Using with an App Runner Service
93 * **Example:** Attach to a Service
94 * ```typescript
95 * const service = yield* AppRunner.Service("Api", {
96 * imageRepository: {
97 * imageIdentifier: "public.ecr.aws/aws-containers/hello-app-runner:latest",
98 * imageRepositoryType: "ECR_PUBLIC",
99 * port: "8000",
100 * },
101 * observabilityConfiguration: {
102 * observabilityEnabled: true,
103 * observabilityConfigurationArn:
104 * observability.observabilityConfigurationArn,
105 * },
106 * });
107 * ```
108 *
109 * @resource
110 */
111 export const ObservabilityConfiguration = Resource<ObservabilityConfiguration>(
112 "AWS.AppRunner.ObservabilityConfiguration",
113 );
114
115 export const ObservabilityConfigurationProvider = () =>
116 Provider.effect(
117 ObservabilityConfiguration,
118 Effect.gen(function* () {
119 const toName = (id: string, props: ObservabilityConfigurationProps) =>
120 props.observabilityConfigurationName
121 ? Effect.succeed(props.observabilityConfigurationName)
122 : createPhysicalName({ id, maxLength: 32 });
123
124 /** Find the latest ACTIVE revision of a configuration by name. */
125 const findLatest = Effect.fn(function* (name: string) {
126 const page = yield* apprunner.listObservabilityConfigurations({
127 ObservabilityConfigurationName: name,
128 LatestOnly: true,
129 });
130 const summary = (page.ObservabilityConfigurationSummaryList ?? []).find(
131 (s) =>
132 s.ObservabilityConfigurationName === name &&
133 s.ObservabilityConfigurationArn !== undefined,
134 );
135 if (!summary?.ObservabilityConfigurationArn) return undefined;
136 const described = yield* apprunner
137 .describeObservabilityConfiguration({
138 ObservabilityConfigurationArn: summary.ObservabilityConfigurationArn,
139 })
140 .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));
141 const config = described?.ObservabilityConfiguration;
142 return config !== undefined && isActiveStatus(config.Status) ? config : undefined;
143 });
144
145 const toAttrs = Effect.fn(function* (config: apprunner.ObservabilityConfiguration) {
146 if (
147 !config.ObservabilityConfigurationName ||
148 !config.ObservabilityConfigurationArn ||
149 config.ObservabilityConfigurationRevision === undefined
150 ) {
151 return yield* new ObservabilityConfigurationUnexpectedResponse({
152 message: "App Runner observability configuration is missing its name, ARN, or revision",
153 });
154 }
155 return {
156 observabilityConfigurationName: config.ObservabilityConfigurationName,
157 observabilityConfigurationArn: config.ObservabilityConfigurationArn,
158 observabilityConfigurationRevision: config.ObservabilityConfigurationRevision,
159 traceVendor: config.TraceConfiguration?.Vendor,
160 };
161 });
162
163 /**
164 * Delete every ACTIVE revision that shares the configuration name.
165 * `DeleteObservabilityConfiguration` has no `DeleteAllRevisions`
166 * flag (unlike auto scaling configurations), so enumerate and delete
167 * each revision. A revision still referenced by a service rejects
168 * with InvalidRequestException — retry through that window (bounded).
169 */
170 const deleteAllRevisions = Effect.fn(function* (name: string) {
171 const pages = yield* apprunner.listObservabilityConfigurations
172 .pages({
173 ObservabilityConfigurationName: name,
174 LatestOnly: false,
175 })
176 .pipe(Stream.runCollect);
177 const arns = Array.from(pages).flatMap((page) =>
178 (page.ObservabilityConfigurationSummaryList ?? [])
179 .filter((s) => s.ObservabilityConfigurationName === name)
180 .flatMap((s) =>
181 s.ObservabilityConfigurationArn !== undefined
182 ? [s.ObservabilityConfigurationArn]
183 : [],
184 ),
185 );
186 for (const arn of arns) {
187 yield* apprunner
188 .deleteObservabilityConfiguration({
189 ObservabilityConfigurationArn: arn,
190 })
191 .pipe(
192 Effect.catchTag("ResourceNotFoundException", () => Effect.void),
193 Effect.retry({
194 while: (e) => e._tag === "InvalidRequestException",
195 schedule: Schedule.max([Schedule.fixed("5 seconds"), Schedule.recurs(24)]),
196 }),
197 );
198 }
199 });
200
201 return {
202 stables: ["observabilityConfigurationName"],
203
204 diff: Effect.fn(function* ({ id, olds, news }) {
205 if (!isResolved(news)) return undefined;
206 if ((yield* toName(id, olds ?? {})) !== (yield* toName(id, news ?? {}))) {
207 return { action: "replace" } as const;
208 }
209 }),
210
211 read: Effect.fn(function* ({ id, olds, output }) {
212 const name = output?.observabilityConfigurationName ?? (yield* toName(id, olds ?? {}));
213 const config = yield* findLatest(name);
214 if (config === undefined) return undefined;
215 const attrs = yield* toAttrs(config);
216 const tags = yield* readAppRunnerTags(attrs.observabilityConfigurationArn);
217 return (yield* hasAlchemyTags(id, tags)) ? attrs : Unowned(attrs);
218 }),
219
220 reconcile: Effect.fn(function* ({ id, news = {}, output, session }) {
221 const name = output?.observabilityConfigurationName ?? (yield* toName(id, news));
222 const internalTags = yield* createInternalTags(id);
223 const desiredTags = { ...internalTags, ...news.tags };
224
225 // 1. Observe — the latest ACTIVE revision is authoritative.
226 let observed = yield* findLatest(name);
227
228 // 2/3. Ensure + sync — trace settings live on immutable
229 // revisions, so a drift on the user-specified vendor is converged
230 // by creating a new revision under the same name. Only compare
231 // what the user actually specified.
232 const drifted =
233 observed !== undefined &&
234 news.traceConfiguration !== undefined &&
235 news.traceConfiguration.vendor !== observed.TraceConfiguration?.Vendor;
236
237 if (observed === undefined || drifted) {
238 const created = yield* apprunner.createObservabilityConfiguration({
239 ObservabilityConfigurationName: name,
240 TraceConfiguration: news.traceConfiguration
241 ? { Vendor: news.traceConfiguration.vendor }
242 : undefined,
243 Tags: toWireTags(desiredTags),
244 });
245 observed = created.ObservabilityConfiguration;
246 }
247
248 // 3b. Sync tags on the latest revision ARN — diff against
249 // OBSERVED cloud tags.
250 if (observed.ObservabilityConfigurationArn) {
251 yield* syncAppRunnerTags(observed.ObservabilityConfigurationArn, desiredTags);
252 }
253
254 // 4. Return fresh attributes.
255 yield* session.note(name);
256 return yield* toAttrs(observed);
257 }),
258
259 delete: Effect.fn(function* ({ output }) {
260 yield* deleteAllRevisions(output.observabilityConfigurationName);
261 }),
262
263 list: () =>
264 apprunner.listObservabilityConfigurations.pages({ LatestOnly: true }).pipe(
265 Stream.runCollect,
266 Effect.map((chunk) =>
267 Array.from(chunk).flatMap((page) =>
268 (page.ObservabilityConfigurationSummaryList ?? []).flatMap((s) =>
269 s.ObservabilityConfigurationArn !== undefined &&
270 // App Runner ships an AWS-managed `DefaultConfiguration`
271 // revision that always exists and can never be deleted
272 // — keep it out of enumeration for account-wide
273 // teardown (nuke).
274 s.ObservabilityConfigurationName !== "DefaultConfiguration"
275 ? [s.ObservabilityConfigurationArn]
276 : [],
277 ),
278 ),
279 ),
280 Effect.flatMap(
281 Effect.forEach(
282 (arn) =>
283 apprunner
284 .describeObservabilityConfiguration({
285 ObservabilityConfigurationArn: arn,
286 })
287 .pipe(
288 Effect.flatMap((r) =>
289 isActiveStatus(r.ObservabilityConfiguration.Status)
290 ? Effect.map(
291 toAttrs(r.ObservabilityConfiguration),
292 (attrs) =>
293 attrs as ObservabilityConfiguration["Attributes"] | undefined,
294 )
295 : Effect.undefined,
296 ),
297 // Tolerate a delete race — drop the item.
298 Effect.catchTag("ResourceNotFoundException", () => Effect.undefined),
299 ),
300 { concurrency: 4 },
301 ),
302 ),
303 Effect.map((items) => items.filter((item) => item !== undefined)),
304 ),
305 };
306 }),
307 );