@studion/infra-code-blocks/dist/otel/index.d.ts

Studion common infra components

import * as pulumi from '@pulumi/pulumi';
import { EcsService } from '../components/ecs-service';
import { OTLPReceiver } from './otlp-receiver';
import { BatchProcessor } from './batch-processor';
import { MemoryLimiterProcessor } from './memory-limiter-processor';
import { PrometheusRemoteWriteExporter } from './prometheus-remote-write-exporter';
export declare namespace OtelCollector {
    type Receiver = {
        otlp?: OTLPReceiver.Config;
    };
    type ReceiverType = keyof Receiver;
    type Processor = {
        batch?: BatchProcessor.Config;
        memory_limiter?: MemoryLimiterProcessor.Config;
    } & {
        [name: string]: BatchProcessor.Config;
    };
    type ProcessorType = keyof Processor;
    type AwsXRayExporterConfig = {
        region: string;
        endpoint?: string;
    };
    type AwsCloudWatchLogsExporterConfig = {
        region: string;
        log_group_name: pulumi.Input<string>;
        log_stream_name: pulumi.Input<string>;
        log_retention: pulumi.Input<number | undefined>;
    };
    type DebugExportedConfig = {
        verbosity: string;
    };
    type Exporter = {
        prometheusremotewrite?: PrometheusRemoteWriteExporter.Config;
        awsxray?: AwsXRayExporterConfig;
        debug?: DebugExportedConfig;
        awscloudwatchlogs?: AwsCloudWatchLogsExporterConfig;
    };
    type ExporterType = keyof Exporter;
    type SigV4AuthExtensionConfig = {
        region: string;
        service: string;
    };
    type HealthCheckExtensionConfig = {
        endpoint: string;
    };
    type PprofExtensionConfig = {
        endpoint: string;
    };
    type Extension = {
        sigv4auth?: SigV4AuthExtensionConfig;
        health_check?: HealthCheckExtensionConfig;
        pprof?: PprofExtensionConfig;
    };
    type ExtensionType = keyof Extension;
    type PipelineConfig = {
        receivers: ReceiverType[];
        processors: ProcessorType[];
        exporters: ExporterType[];
    };
    type TelemetryConfig = {
        logs?: {
            level: string;
        };
        metrics?: {
            level: string;
        };
    };
    type Service = {
        pipelines: {
            metrics?: PipelineConfig;
            traces?: PipelineConfig;
            logs?: PipelineConfig;
        };
        extensions?: ExtensionType[];
        telemetry?: TelemetryConfig;
    };
    type Config = {
        receivers: Receiver;
        processors: Processor;
        exporters: Exporter;
        extensions: Extension;
        service: Service;
    };
    type Opts = {
        containerName?: pulumi.Input<string>;
        configVolumeName?: pulumi.Input<string>;
        taskRoleInlinePolicies?: pulumi.Input<pulumi.Input<EcsService.RoleInlinePolicy>[]>;
    };
}
export declare class OtelCollector {
    config: pulumi.Output<OtelCollector.Config>;
    configVolume: pulumi.Output<string>;
    container: pulumi.Output<EcsService.Container>;
    configContainer: EcsService.Container;
    taskRoleInlinePolicies: OtelCollector.Opts['taskRoleInlinePolicies'];
    constructor(serviceName: pulumi.Input<string>, env: pulumi.Input<string>, config: pulumi.Input<OtelCollector.Config>, opts?: OtelCollector.Opts);
    private createContainer;
    private getCollectorEnvironment;
    private getCollectorPortMappings;
    private createConfigWriterCommand;
    private createConfigContainer;
}
//# sourceMappingURL=index.d.ts.map