@studion/infra-code-blocks 0.6.12 → 0.8.0-next.0

package/dist/v2/components/web-server/index.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebServer = void 0;
+const pulumi = require("@pulumi/pulumi");
+const aws = require("@pulumi/aws");
+const constants_1 = require("../../../constants");
+const acm_certificate_1 = require("../../../components/acm-certificate");
+const ecs_service_1 = require("../ecs-service");
+const load_balancer_1 = require("./load-balancer");
+class WebServer extends pulumi.ComponentResource {
+    constructor(name, args, opts = {}) {
+        var _a;
+        super('studion:WebServer', name, args, opts);
+        const { vpc, domain, hostedZoneId } = args;
+        if (domain && !hostedZoneId) {
+            throw new Error('WebServer:hostedZoneId must be provided when the domain is specified');
+        }
+        const hasCustomDomain = !!domain && !!hostedZoneId;
+        if (hasCustomDomain) {
+            this.certificate = this.createTlsCertificate({ domain, hostedZoneId });
+        }
+        this.name = name;
+        this.lb = new load_balancer_1.WebServerLoadBalancer(`${this.name}-lb`, {
+            vpc,
+            port: args.port,
+            certificate: (_a = this.certificate) === null || _a === void 0 ? void 0 : _a.certificate,
+            healthCheckPath: args.healthCheckPath
+        });
+        this.serviceSecurityGroup = this.createSecurityGroup(vpc);
+        this.initContainers = this.getInitContainers(args);
+        this.sidecarContainers = this.getSidecarContainers(args);
+        this.container = this.createWebServerContainer(args);
+        this.ecsConfig = this.createEcsConfig(args);
+        this.volumes = this.getVolumes(args);
+        // TODO: Move output mapping to createEcsService
+        this.service = pulumi.all([
+            this.initContainers,
+            this.sidecarContainers,
+        ]).apply(([initContainers, sidecarContainers,]) => {
+            return this.createEcsService(this.container, this.lb, this.ecsConfig, this.volumes, [...initContainers, ...sidecarContainers]);
+        });
+        if (hasCustomDomain) {
+            this.dnsRecord = this.createDnsRecord({ domain, hostedZoneId });
+        }
+        this.registerOutputs();
+    }
+    getVolumes(args) {
+        return pulumi.all([
+            pulumi.output(args.volumes),
+            args.otelCollector
+        ]).apply(([passedVolumes, otelCollector]) => {
+            const volumes = [];
+            if (passedVolumes)
+                volumes.push(...passedVolumes);
+            if (otelCollector)
+                volumes.push({ name: otelCollector.configVolume });
+            return volumes;
+        });
+    }
+    getInitContainers(args) {
+        return pulumi.all([
+            pulumi.output(args.initContainers),
+            args.otelCollector
+        ]).apply(([passedInits, otelCollector]) => {
+            const containers = [];
+            if (passedInits)
+                containers.push(...passedInits);
+            if (otelCollector)
+                containers.push(otelCollector.configContainer);
+            return containers.map(container => (Object.assign(Object.assign({}, container), { essential: false })));
+        });
+    }
+    getSidecarContainers(args) {
+        return pulumi.all([
+            pulumi.output(args.sidecarContainers),
+            args.otelCollector
+        ]).apply(([passedSidecars, otelCollector]) => {
+            const containers = [];
+            if (passedSidecars)
+                containers.push(...passedSidecars);
+            if (otelCollector)
+                containers.push(otelCollector.container);
+            return containers.map(container => (Object.assign(Object.assign({}, container), { essential: true })));
+        });
+    }
+    getTaskRoleInlinePolicies(args) {
+        return pulumi.all([
+            pulumi.output(args.taskExecutionRoleInlinePolicies),
+            args.otelCollector
+        ]).apply(([passedTaskRoleInlinePolicies, otelCollector]) => {
+            const inlinePolicies = [];
+            if (passedTaskRoleInlinePolicies)
+                inlinePolicies.push(...passedTaskRoleInlinePolicies);
+            if (otelCollector && otelCollector.taskRoleInlinePolicies) {
+                inlinePolicies.push(...otelCollector.taskRoleInlinePolicies);
+            }
+            return inlinePolicies;
+        });
+    }
+    createEcsConfig(args) {
+        return {
+            vpc: args.vpc,
+            cluster: args.cluster,
+            desiredCount: args.desiredCount,
+            autoscaling: args.autoscaling,
+            size: args.size,
+            taskExecutionRoleInlinePolicies: args.taskExecutionRoleInlinePolicies,
+            taskRoleInlinePolicies: this.getTaskRoleInlinePolicies(args),
+            tags: args.tags,
+        };
+    }
+    createWebServerContainer(args) {
+        return {
+            image: args.image,
+            mountPoints: args.mountPoints,
+            environment: args.environment,
+            secrets: args.secrets,
+            port: args.port
+        };
+    }
+    createTlsCertificate({ domain, hostedZoneId, }) {
+        return new acm_certificate_1.AcmCertificate(`${domain}-acm-certificate`, {
+            domain,
+            hostedZoneId,
+        }, { parent: this });
+    }
+    createSecurityGroup(vpc) {
+        const vpcId = pulumi.output(vpc).vpcId;
+        return new aws.ec2.SecurityGroup(`${this.name}-security-group`, {
+            vpcId,
+            ingress: [{
+                    fromPort: 0,
+                    toPort: 0,
+                    protocol: '-1',
+                    securityGroups: [this.lb.securityGroup.id],
+                }],
+            egress: [{
+                    fromPort: 0,
+                    toPort: 0,
+                    protocol: '-1',
+                    cidrBlocks: ['0.0.0.0/0'],
+                }],
+            tags: constants_1.commonTags,
+        }, { parent: this });
+    }
+    createEcsService(webServerContainer, lb, ecsConfig, volumes, containers) {
+        return new ecs_service_1.EcsService(`${this.name}-ecs`, Object.assign(Object.assign({}, ecsConfig), { volumes, containers: [Object.assign(Object.assign({}, webServerContainer), { name: this.name, portMappings: [ecs_service_1.EcsService.createTcpPortMapping(webServerContainer.port)], essential: true }), ...(containers || [])], enableServiceAutoDiscovery: false, loadBalancers: [{
+                    containerName: this.name,
+                    containerPort: webServerContainer.port,
+                    targetGroupArn: lb.targetGroup.arn,
+                }], assignPublicIp: true, securityGroup: this.serviceSecurityGroup }), {
+            parent: this,
+            dependsOn: [lb, lb.targetGroup],
+        });
+    }
+    createDnsRecord({ domain, hostedZoneId, }) {
+        return new aws.route53.Record(`${this.name}-route53-record`, {
+            type: 'A',
+            name: domain,
+            zoneId: hostedZoneId,
+            aliases: [{
+                    name: this.lb.lb.dnsName,
+                    zoneId: this.lb.lb.zoneId,
+                    evaluateTargetHealth: true,
+                }],
+        }, { parent: this });
+    }
+}
+exports.WebServer = WebServer;

package/dist/v2/components/web-server/load-balancer.d.ts

@@ -0,0 +1,25 @@
+import * as pulumi from '@pulumi/pulumi';
+import * as aws from '@pulumi/aws';
+import * as awsx from '@pulumi/awsx';
+export declare namespace WebServerLoadBalancer {
+    type Args = {
+        vpc: pulumi.Input<awsx.ec2.Vpc>;
+        port: pulumi.Input<number>;
+        certificate?: aws.acm.Certificate;
+        healthCheckPath?: pulumi.Input<string>;
+    };
+}
+export declare class WebServerLoadBalancer extends pulumi.ComponentResource {
+    name: string;
+    lb: aws.lb.LoadBalancer;
+    targetGroup: aws.lb.TargetGroup;
+    httpListener: aws.lb.Listener;
+    tlsListener: aws.lb.Listener | undefined;
+    securityGroup: aws.ec2.SecurityGroup;
+    constructor(name: string, args: WebServerLoadBalancer.Args, opts?: pulumi.ComponentResourceOptions);
+    private createLbTlsListener;
+    private createLbHttpListener;
+    private createLbTargetGroup;
+    private createLbSecurityGroup;
+}
+//# sourceMappingURL=load-balancer.d.ts.map

package/dist/v2/components/web-server/load-balancer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-balancer.d.ts","sourceRoot":"","sources":["../../../../src/v2/components/web-server/load-balancer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,gBAAgB,CAAC;AACzC,OAAO,KAAK,GAAG,MAAM,aAAa,CAAC;AACnC,OAAO,KAAK,IAAI,MAAM,cAAc,CAAC;AAGrC,yBAAiB,qBAAqB,CAAC;IACrC,KAAY,IAAI,GAAG;QACjB,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC3B,WAAW,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,WAAW,CAAC;QAClC,eAAe,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;KACxC,CAAC;CACH;AA0BD,qBAAa,qBAAsB,SAAQ,MAAM,CAAC,iBAAiB;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,GAAG,CAAC,EAAE,CAAC,YAAY,CAAC;IACxB,WAAW,EAAE,GAAG,CAAC,EAAE,CAAC,WAAW,CAAC;IAChC,YAAY,EAAE,GAAG,CAAC,EAAE,CAAC,QAAQ,CAAC;IAC9B,WAAW,EAAE,GAAG,CAAC,EAAE,CAAC,QAAQ,GAAG,SAAS,CAAC;IACzC,aAAa,EAAE,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC;gBAGnC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,qBAAqB,CAAC,IAAI,EAChC,IAAI,GAAE,MAAM,CAAC,wBAA6B;IAoC5C,OAAO,CAAC,mBAAmB;IAmB3B,OAAO,CAAC,oBAAoB;IA0B5B,OAAO,CAAC,mBAAmB;IAsB3B,OAAO,CAAC,qBAAqB;CAS9B"}

package/dist/v2/components/web-server/load-balancer.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebServerLoadBalancer = void 0;
+const pulumi = require("@pulumi/pulumi");
+const aws = require("@pulumi/aws");
+const constants_1 = require("../../../constants");
+const webServerLoadBalancerNetworkConfig = {
+    ingress: [{
+            protocol: 'tcp',
+            fromPort: 80,
+            toPort: 80,
+            cidrBlocks: ['0.0.0.0/0'],
+        }, {
+            protocol: 'tcp',
+            fromPort: 443,
+            toPort: 443,
+            cidrBlocks: ['0.0.0.0/0'],
+        }],
+    egress: [{
+            fromPort: 0,
+            toPort: 0,
+            protocol: '-1',
+            cidrBlocks: ['0.0.0.0/0'],
+        }]
+};
+const defaults = {
+    healthCheckPath: '/healthcheck',
+};
+class WebServerLoadBalancer extends pulumi.ComponentResource {
+    constructor(name, args, opts = {}) {
+        super('studion:WebServerLoadBalancer', name, args, opts);
+        this.name = name;
+        const vpc = pulumi.output(args.vpc);
+        const { port, certificate, healthCheckPath } = args;
+        this.securityGroup = this.createLbSecurityGroup(vpc.vpcId);
+        this.lb = new aws.lb.LoadBalancer(this.name, {
+            namePrefix: 'lb-',
+            loadBalancerType: 'application',
+            subnets: vpc.publicSubnetIds,
+            securityGroups: [this.securityGroup.id],
+            internal: false,
+            ipAddressType: 'ipv4',
+            tags: Object.assign(Object.assign({}, constants_1.commonTags), { Name: name }),
+        }, { parent: this });
+        this.targetGroup = this.createLbTargetGroup(port, vpc.vpcId, healthCheckPath);
+        this.httpListener = this.createLbHttpListener(this.lb, this.targetGroup, !!certificate);
+        this.tlsListener = certificate &&
+            this.createLbTlsListener(this.lb, this.targetGroup, certificate);
+        this.registerOutputs();
+    }
+    createLbTlsListener(lb, lbTargetGroup, certificate) {
+        return new aws.lb.Listener(`${this.name}-listener-443`, {
+            loadBalancerArn: lb.arn,
+            port: 443,
+            protocol: 'HTTPS',
+            sslPolicy: 'ELBSecurityPolicy-2016-08',
+            certificateArn: certificate.arn,
+            defaultActions: [{
+                    type: 'forward',
+                    targetGroupArn: lbTargetGroup.arn,
+                }],
+            tags: constants_1.commonTags,
+        }, { parent: this, dependsOn: [certificate] });
+    }
+    createLbHttpListener(lb, lbTargetGroup, redirectToHttps) {
+        const httpsRedirectAction = {
+            type: 'redirect',
+            redirect: {
+                port: '443',
+                protocol: 'HTTPS',
+                statusCode: 'HTTP_301',
+            },
+        };
+        const defaultAction = redirectToHttps ? httpsRedirectAction : {
+            type: 'forward',
+            targetGroupArn: lbTargetGroup.arn,
+        };
+        return new aws.lb.Listener(`${this.name}-listener-80`, {
+            loadBalancerArn: lb.arn,
+            port: 80,
+            defaultActions: [defaultAction],
+            tags: constants_1.commonTags,
+        }, { parent: this });
+    }
+    createLbTargetGroup(port, vpcId, healthCheckPath) {
+        return new aws.lb.TargetGroup(`${this.name}-tg`, {
+            namePrefix: 'lb-tg-',
+            port,
+            protocol: 'HTTP',
+            targetType: 'ip',
+            vpcId,
+            healthCheck: {
+                healthyThreshold: 3,
+                unhealthyThreshold: 2,
+                interval: 60,
+                timeout: 5,
+                path: healthCheckPath || defaults.healthCheckPath,
+            },
+            tags: Object.assign(Object.assign({}, constants_1.commonTags), { Name: `${this.name}-target-group` }),
+        }, { parent: this, dependsOn: [this.lb] });
+    }
+    createLbSecurityGroup(vpcId) {
+        return new aws.ec2.SecurityGroup(`${this.name}-security-group`, Object.assign(Object.assign({}, webServerLoadBalancerNetworkConfig), { vpcId, tags: constants_1.commonTags }), { parent: this });
+    }
+}
+exports.WebServerLoadBalancer = WebServerLoadBalancer;

package/dist/v2/index.d.ts

@@ -0,0 +1,13 @@
+export { EcsService } from './components/ecs-service';
+export { WebServer } from './components/web-server';
+export { WebServerBuilder } from './components/web-server/builder';
+export { WebServerLoadBalancer } from './components/web-server/load-balancer';
+import { OtelCollectorBuilder } from './otel/builder';
+import { OtelCollector } from './otel';
+export declare const openTelemetry: {
+    OtelCollector: typeof OtelCollector;
+    OtelCollectorBuilder: typeof OtelCollectorBuilder;
+};
+export * as grafana from './components/grafana';
+export * as prometheus from './components/prometheus';
+//# sourceMappingURL=index.d.ts.map

package/dist/v2/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/v2/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAE9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AACvC,eAAO,MAAM,aAAa;;;CAA0C,CAAC;AAErE,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAC;AAChD,OAAO,KAAK,UAAU,MAAM,yBAAyB,CAAC"}

package/dist/v2/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prometheus = exports.grafana = exports.openTelemetry = exports.WebServerLoadBalancer = exports.WebServerBuilder = exports.WebServer = exports.EcsService = void 0;
+var ecs_service_1 = require("./components/ecs-service");
+Object.defineProperty(exports, "EcsService", { enumerable: true, get: function () { return ecs_service_1.EcsService; } });
+var web_server_1 = require("./components/web-server");
+Object.defineProperty(exports, "WebServer", { enumerable: true, get: function () { return web_server_1.WebServer; } });
+var builder_1 = require("./components/web-server/builder");
+Object.defineProperty(exports, "WebServerBuilder", { enumerable: true, get: function () { return builder_1.WebServerBuilder; } });
+var load_balancer_1 = require("./components/web-server/load-balancer");
+Object.defineProperty(exports, "WebServerLoadBalancer", { enumerable: true, get: function () { return load_balancer_1.WebServerLoadBalancer; } });
+const builder_2 = require("./otel/builder");
+const otel_1 = require("./otel");
+exports.openTelemetry = { OtelCollector: otel_1.OtelCollector, OtelCollectorBuilder: builder_2.OtelCollectorBuilder };
+exports.grafana = require("./components/grafana");
+exports.prometheus = require("./components/prometheus");

package/dist/v2/otel/batch-processor.d.ts

@@ -0,0 +1,14 @@
+export declare namespace BatchProcessor {
+    type Config = {
+        send_batch_size: number;
+        send_batch_max_size: number;
+        timeout: string;
+    };
+}
+export declare const defaults: {
+    name: string;
+    size: number;
+    maxSize: number;
+    timeout: string;
+};
+//# sourceMappingURL=batch-processor.d.ts.map

package/dist/v2/otel/batch-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-processor.d.ts","sourceRoot":"","sources":["../../../src/v2/otel/batch-processor.ts"],"names":[],"mappings":"AAAA,yBAAiB,cAAc,CAAC;IAC9B,KAAY,MAAM,GAAG;QACnB,eAAe,EAAE,MAAM,CAAC;QACxB,mBAAmB,EAAE,MAAM,CAAC;QAC5B,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED,eAAO,MAAM,QAAQ;;;;;CAKpB,CAAC"}

package/dist/v2/otel/batch-processor.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaults = void 0;
+exports.defaults = {
+    name: 'batch',
+    size: 8192,
+    maxSize: 10000,
+    timeout: '5s'
+};

package/dist/v2/otel/builder.d.ts

@@ -0,0 +1,27 @@
+import * as pulumi from '@pulumi/pulumi';
+import * as aws from '@pulumi/aws';
+import { OtelCollector } from '.';
+import { OTLPReceiver } from './otlp-receiver';
+export declare class OtelCollectorBuilder {
+    private readonly _serviceName;
+    private readonly _env;
+    private readonly _configBuilder;
+    private _taskRoleInlinePolicies;
+    constructor(serviceName: pulumi.Input<string>, env: pulumi.Input<string>);
+    withOTLPReceiver(protocols?: OTLPReceiver.Protocol[]): this;
+    withBatchProcessor(name?: string, size?: number, maxSize?: number, timeout?: string): this;
+    withMemoryLimiterProcessor(checkInterval?: string, limitPercentage?: number, spikeLimitPercentage?: number): this;
+    withAWSXRayExporter(region: string): this;
+    withHealthCheckExtension(endpoint?: string): this;
+    withPprofExtension(endpoint?: string): this;
+    withAPS(namespace: pulumi.Input<string>, workspace: aws.amp.Workspace, region: string): this;
+    withDebug(verbosity?: 'normal' | 'basic' | 'detailed'): this;
+    withTelemetry(logLevel?: 'debug' | 'warn' | 'error', metricsVerbosity?: 'basic' | 'normal' | 'detailed'): this;
+    withMetricsPipeline(receivers: OtelCollector.ReceiverType[], processors: OtelCollector.ProcessorType[], exporters: OtelCollector.ExporterType[]): this;
+    withTracesPipeline(receivers: OtelCollector.ReceiverType[], processors: OtelCollector.ProcessorType[], exporters: OtelCollector.ExporterType[]): this;
+    withDefault(prometheusNamespace: pulumi.Input<string>, prometheusWorkspace: aws.amp.Workspace, awsRegion: string): this;
+    build(): OtelCollector;
+    private createAPSInlinePolicy;
+    private createAWSXRayPolicy;
+}
+//# sourceMappingURL=builder.d.ts.map

package/dist/v2/otel/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../src/v2/otel/builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,gBAAgB,CAAC;AACzC,OAAO,KAAK,GAAG,MAAM,aAAa,CAAC;AAGnC,OAAO,EAAE,aAAa,EAAE,MAAM,GAAG,CAAC;AAGlC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAwB;IACrD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAwB;IAC7C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6B;IAC5D,OAAO,CAAC,uBAAuB,CAAoD;gBAGjF,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EACjC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC;IAO3B,gBAAgB,CACd,SAAS,GAAE,YAAY,CAAC,QAAQ,EAAa,GAC5C,IAAI;IAMP,kBAAkB,CAChB,IAAI,SAA+B,EACnC,IAAI,SAA+B,EACnC,OAAO,SAAkC,EACzC,OAAO,SAAkC,GACxC,IAAI;IAMP,0BAA0B,CACxB,aAAa,SAAgD,EAC7D,eAAe,SAAkD,EACjE,oBAAoB,SAAuD,GAC1E,IAAI;IAUP,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAOzC,wBAAwB,CAAC,QAAQ,SAAkB,GAAG,IAAI;IAM1D,kBAAkB,CAAC,QAAQ,SAAiB,GAAG,IAAI;IAMnD,OAAO,CACL,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAC/B,SAAS,EAAE,GAAG,CAAC,GAAG,CAAC,SAAS,EAC5B,MAAM,EAAE,MAAM,GACb,IAAI;IAWP,SAAS,CAAC,SAAS,GAAE,QAAQ,GAAG,OAAO,GAAG,UAAuB,GAAG,IAAI;IAMxE,aAAa,CACX,QAAQ,GAAE,OAAO,GAAG,MAAM,GAAG,OAAiB,EAC9C,gBAAgB,GAAE,OAAO,GAAG,QAAQ,GAAG,UAAoB,GAC1D,IAAI;IAMP,mBAAmB,CACjB,SAAS,EAAE,aAAa,CAAC,YAAY,EAAE,EACvC,UAAU,EAAE,aAAa,CAAC,aAAa,EAAE,EACzC,SAAS,EAAE,aAAa,CAAC,YAAY,EAAE,GACtC,IAAI;IAUP,kBAAkB,CAChB,SAAS,EAAE,aAAa,CAAC,YAAY,EAAE,EACvC,UAAU,EAAE,aAAa,CAAC,aAAa,EAAE,EACzC,SAAS,EAAE,aAAa,CAAC,YAAY,EAAE,GACtC,IAAI;IAUP,WAAW,CACT,mBAAmB,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EACzC,mBAAmB,EAAE,GAAG,CAAC,GAAG,CAAC,SAAS,EACtC,SAAS,EAAE,MAAM,GAChB,IAAI;IAYP,KAAK,IAAI,aAAa;IAStB,OAAO,CAAC,qBAAqB;IAmB7B,OAAO,CAAC,mBAAmB;CAsB5B"}

package/dist/v2/otel/builder.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtelCollectorBuilder = void 0;
+const pulumi = require("@pulumi/pulumi");
+const batchProcessor = require("./batch-processor");
+const memoryLimiterProcessor = require("./memory-limiter-processor");
+const _1 = require(".");
+const config_1 = require("./config");
+class OtelCollectorBuilder {
+    constructor(serviceName, env) {
+        this._taskRoleInlinePolicies = [];
+        this._serviceName = pulumi.output(serviceName);
+        this._env = pulumi.output(env);
+        this._configBuilder = new config_1.OtelCollectorConfigBuilder();
+    }
+    withOTLPReceiver(protocols = ['http']) {
+        this._configBuilder.withOTLPReceiver(protocols);
+        return this;
+    }
+    withBatchProcessor(name = batchProcessor.defaults.name, size = batchProcessor.defaults.size, maxSize = batchProcessor.defaults.maxSize, timeout = batchProcessor.defaults.timeout) {
+        this._configBuilder.withBatchProcessor(name, size, maxSize, timeout);
+        return this;
+    }
+    withMemoryLimiterProcessor(checkInterval = memoryLimiterProcessor.defaults.checkInterval, limitPercentage = memoryLimiterProcessor.defaults.limitPercentage, spikeLimitPercentage = memoryLimiterProcessor.defaults.spikeLimitPercentage) {
+        this._configBuilder.withMemoryLimiterProcessor(checkInterval, limitPercentage, spikeLimitPercentage);
+        return this;
+    }
+    withAWSXRayExporter(region) {
+        this._configBuilder.withAWSXRayExporter(region);
+        this.createAWSXRayPolicy();
+        return this;
+    }
+    withHealthCheckExtension(endpoint = '0.0.0.0:13133') {
+        this._configBuilder.withHealthCheckExtension(endpoint);
+        return this;
+    }
+    withPprofExtension(endpoint = '0.0.0.0:1777') {
+        this._configBuilder.withPprofExtension(endpoint);
+        return this;
+    }
+    withAPS(namespace, workspace, region) {
+        this._configBuilder.withAPS(pulumi.output(namespace), pulumi.interpolate `${workspace.prometheusEndpoint}api/v1/remote_write`, region);
+        this.createAPSInlinePolicy(workspace);
+        return this;
+    }
+    withDebug(verbosity = 'detailed') {
+        this._configBuilder.withDebug(verbosity);
+        return this;
+    }
+    withTelemetry(logLevel = 'error', metricsVerbosity = 'basic') {
+        this._configBuilder.withTelemetry(logLevel, metricsVerbosity);
+        return this;
+    }
+    withMetricsPipeline(receivers, processors, exporters) {
+        this._configBuilder.withMetricsPipeline(receivers, processors, exporters);
+        return this;
+    }
+    withTracesPipeline(receivers, processors, exporters) {
+        this._configBuilder.withTracesPipeline(receivers, processors, exporters);
+        return this;
+    }
+    withDefault(prometheusNamespace, prometheusWorkspace, awsRegion) {
+        this._configBuilder.withDefault(pulumi.output(prometheusNamespace), pulumi.interpolate `${prometheusWorkspace.prometheusEndpoint}api/v1/remote_write`, awsRegion);
+        this.createAPSInlinePolicy(prometheusWorkspace);
+        this.createAWSXRayPolicy();
+        return this;
+    }
+    build() {
+        return new _1.OtelCollector(this._serviceName, this._env, this._configBuilder.build(), { taskRoleInlinePolicies: this._taskRoleInlinePolicies });
+    }
+    createAPSInlinePolicy(workspace) {
+        const policy = pulumi.all(([
+            this._serviceName,
+            workspace.arn
+        ])).apply(([serviceName, workspaceArn]) => ({
+            name: `${serviceName}-task-role-aps-write`,
+            policy: JSON.stringify({
+                Version: '2012-10-17',
+                Statement: [{
+                        Effect: 'Allow',
+                        Action: ['aps:RemoteWrite'],
+                        Resource: workspaceArn,
+                    }],
+            }),
+        }));
+        this._taskRoleInlinePolicies.push(policy);
+    }
+    createAWSXRayPolicy() {
+        const policy = this._serviceName
+            .apply(serviceName => ({
+            name: `${serviceName}-task-role-xray`,
+            policy: JSON.stringify({
+                Version: '2012-10-17',
+                Statement: [{
+                        Effect: 'Allow',
+                        Action: [
+                            'xray:PutTraceSegments',
+                            'xray:PutTelemetryRecords',
+                            'xray:GetSamplingRules',
+                            'xray:GetSamplingTargets',
+                            'xray:GetSamplingStatisticSummaries',
+                        ],
+                        Resource: '*',
+                    }],
+            }),
+        }));
+        this._taskRoleInlinePolicies.push(policy);
+    }
+}
+exports.OtelCollectorBuilder = OtelCollectorBuilder;

package/dist/v2/otel/config.d.ts

@@ -0,0 +1,26 @@
+import * as pulumi from '@pulumi/pulumi';
+import { OTLPReceiver } from './otlp-receiver';
+import type { OtelCollector } from '.';
+export declare class OtelCollectorConfigBuilder {
+    private readonly _receivers;
+    private readonly _processors;
+    private readonly _exporters;
+    private readonly _extensions;
+    private readonly _service;
+    withOTLPReceiver(protocols?: OTLPReceiver.Protocol[]): this;
+    withBatchProcessor(name?: string, size?: number, maxSize?: number, timeout?: string): this;
+    withMemoryLimiterProcessor(checkInterval?: string, limitPercentage?: number, spikeLimitPercentage?: number): this;
+    withAWSXRayExporter(region: string): this;
+    withHealthCheckExtension(endpoint?: string): this;
+    withPprofExtension(endpoint?: string): this;
+    withAPS(namespace: pulumi.Input<string>, endpoint: pulumi.Input<string>, region: string): this;
+    withDebug(verbosity?: 'normal' | 'basic' | 'detailed'): this;
+    withTelemetry(logLevel?: 'debug' | 'warn' | 'error', metricsVerbosity?: 'basic' | 'normal' | 'detailed'): this;
+    withMetricsPipeline(receivers: OtelCollector.ReceiverType[], processors: OtelCollector.ProcessorType[], exporters: OtelCollector.ExporterType[]): this;
+    withTracesPipeline(receivers: OtelCollector.ReceiverType[], processors: OtelCollector.ProcessorType[], exporters: OtelCollector.ExporterType[]): this;
+    withDefault(prometheusNamespace: pulumi.Input<string>, prometheusWriteEndpoint: pulumi.Input<string>, awsRegion: string): this;
+    build(): OtelCollector.Config;
+    private validatePipelineProcessorOrder;
+    private validatePipelineComponents;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/v2/otel/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/v2/otel/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,YAAY,EAAY,MAAM,iBAAiB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,GAAG,CAAC;AAEvC,qBAAa,0BAA0B;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA8B;IACzD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA+B;IAC3D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA8B;IACzD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA+B;IAC3D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAEvB;IAEF,gBAAgB,CACd,SAAS,GAAE,YAAY,CAAC,QAAQ,EAAa,GAC5C,IAAI;IAmBP,kBAAkB,CAChB,IAAI,SAAU,EACd,IAAI,SAAO,EACX,OAAO,SAAQ,EACf,OAAO,SAAO,GACb,IAAI;IAUP,0BAA0B,CACxB,aAAa,SAAO,EACpB,eAAe,SAAK,EACpB,oBAAoB,SAAK,GACxB,IAAI;IAUP,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAMzC,wBAAwB,CAAC,QAAQ,SAAkB,GAAG,IAAI;IAM1D,kBAAkB,CAAC,QAAQ,SAAiB,GAAG,IAAI;IAMnD,OAAO,CACL,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAC/B,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAC9B,MAAM,EAAE,MAAM,GACb,IAAI;IAiBP,SAAS,CAAC,SAAS,GAAE,QAAQ,GAAG,OAAO,GAAG,UAAuB,GAAG,IAAI;IAMxE,aAAa,CACX,QAAQ,GAAE,OAAO,GAAG,MAAM,GAAG,OAAiB,EAC9C,gBAAgB,GAAE,OAAO,GAAG,QAAQ,GAAG,UAAoB,GAC1D,IAAI;IASP,mBAAmB,CACjB,SAAS,EAAE,aAAa,CAAC,YAAY,EAAE,EACvC,UAAU,EAAE,aAAa,CAAC,aAAa,EAAE,EACzC,SAAS,EAAE,aAAa,CAAC,YAAY,EAAE,GACtC,IAAI;IAUP,kBAAkB,CAChB,SAAS,EAAE,aAAa,CAAC,YAAY,EAAE,EACvC,UAAU,EAAE,aAAa,CAAC,aAAa,EAAE,EACzC,SAAS,EAAE,aAAa,CAAC,YAAY,EAAE,GACtC,IAAI;IAUP,WAAW,CACT,mBAAmB,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EACzC,uBAAuB,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAC7C,SAAS,EAAE,MAAM,GAChB,IAAI;IAqBP,KAAK,IAAI,aAAa,CAAC,MAAM;IAwB7B,OAAO,CAAC,8BAA8B;IAYtC,OAAO,CAAC,0BAA0B;CAmBnC"}