@ts-cloud/core 0.2.3 → 0.2.4

package/dist/observability/logs.d.ts

@@ -0,0 +1,213 @@
+/**
+ * Log Aggregation
+ * Centralized logging across services with CloudWatch Logs
+ */
+export interface LogGroup {
+    id: string;
+    name: string;
+    retentionDays?: number;
+    kmsKeyId?: string;
+    logStreams?: LogStream[];
+    metricFilters?: MetricFilter[];
+    subscriptionFilters?: SubscriptionFilter[];
+}
+export interface LogStream {
+    id: string;
+    name: string;
+    logGroupName: string;
+    creationTime: Date;
+    lastEventTime?: Date;
+}
+export interface MetricFilter {
+    id: string;
+    name: string;
+    filterPattern: string;
+    metricTransformations: MetricTransformation[];
+}
+export interface MetricTransformation {
+    metricName: string;
+    metricNamespace: string;
+    metricValue: string;
+    defaultValue?: number;
+    unit?: string;
+    dimensions?: Record<string, string>;
+}
+export interface SubscriptionFilter {
+    id: string;
+    name: string;
+    logGroupName: string;
+    filterPattern: string;
+    destinationArn: string;
+    roleArn?: string;
+    distribution?: 'Random' | 'ByLogStream';
+}
+export interface LogQuery {
+    id: string;
+    name: string;
+    queryString: string;
+    logGroupNames: string[];
+    startTime?: Date;
+    endTime?: Date;
+}
+export interface LogInsightsQuery {
+    id: string;
+    name: string;
+    description?: string;
+    query: string;
+    logGroupNames: string[];
+    schedule?: string;
+}
+/**
+ * Logs manager
+ */
+export declare class LogsManager {
+    private logGroups;
+    private queries;
+    private insightsQueries;
+    private logGroupCounter;
+    private filterCounter;
+    private queryCounter;
+    /**
+     * Create log group
+     */
+    createLogGroup(group: Omit<LogGroup, 'id'>): LogGroup;
+    /**
+     * Create Lambda log group
+     */
+    createLambdaLogGroup(functionName: string, retentionDays?: number): LogGroup;
+    /**
+     * Create ECS log group
+     */
+    createECSLogGroup(options: {
+        clusterName: string;
+        serviceName: string;
+        retentionDays?: number;
+    }): LogGroup;
+    /**
+     * Create API Gateway log group
+     */
+    createAPIGatewayLogGroup(apiName: string, stage: string, retentionDays?: number): LogGroup;
+    /**
+     * Create application log group
+     */
+    createApplicationLogGroup(options: {
+        appName: string;
+        environment: string;
+        retentionDays?: number;
+        kmsKeyId?: string;
+    }): LogGroup;
+    /**
+     * Create metric filter
+     */
+    createMetricFilter(logGroupId: string, filter: Omit<MetricFilter, 'id'>): MetricFilter;
+    /**
+     * Create error count metric filter
+     */
+    createErrorCountFilter(logGroupId: string, namespace: string): MetricFilter;
+    /**
+     * Create latency metric filter
+     */
+    createLatencyFilter(logGroupId: string, namespace: string): MetricFilter;
+    /**
+     * Create custom pattern filter
+     */
+    createCustomPatternFilter(options: {
+        logGroupId: string;
+        name: string;
+        pattern: string;
+        metricName: string;
+        namespace: string;
+    }): MetricFilter;
+    /**
+     * Create subscription filter
+     */
+    createSubscriptionFilter(logGroupId: string, filter: Omit<SubscriptionFilter, 'id'>): SubscriptionFilter;
+    /**
+     * Create Kinesis subscription (for real-time log processing)
+     */
+    createKinesisSubscription(options: {
+        logGroupId: string;
+        kinesisStreamArn: string;
+        roleArn: string;
+        filterPattern?: string;
+    }): SubscriptionFilter;
+    /**
+     * Create Lambda subscription (for log processing)
+     */
+    createLambdaSubscription(options: {
+        logGroupId: string;
+        lambdaFunctionArn: string;
+        filterPattern?: string;
+    }): SubscriptionFilter;
+    /**
+     * Create Log Insights query
+     */
+    createInsightsQuery(query: Omit<LogInsightsQuery, 'id'>): LogInsightsQuery;
+    /**
+     * Create error analysis query
+     */
+    createErrorAnalysisQuery(logGroupNames: string[]): LogInsightsQuery;
+    /**
+     * Create latency analysis query
+     */
+    createLatencyAnalysisQuery(logGroupNames: string[]): LogInsightsQuery;
+    /**
+     * Create top errors query
+     */
+    createTopErrorsQuery(logGroupNames: string[]): LogInsightsQuery;
+    /**
+     * Get log group
+     */
+    getLogGroup(id: string): LogGroup | undefined;
+    /**
+     * List log groups
+     */
+    listLogGroups(): LogGroup[];
+    /**
+     * Get insights query
+     */
+    getInsightsQuery(id: string): LogInsightsQuery | undefined;
+    /**
+     * List insights queries
+     */
+    listInsightsQueries(): LogInsightsQuery[];
+    /**
+     * Generate CloudFormation for log group
+     */
+    generateLogGroupCF(group: LogGroup): any;
+    /**
+     * Generate CloudFormation for metric filter
+     */
+    generateMetricFilterCF(logGroup: LogGroup, filter: MetricFilter): any;
+    /**
+     * Generate CloudFormation for subscription filter
+     */
+    generateSubscriptionFilterCF(filter: SubscriptionFilter): any;
+    /**
+     * Generate CloudFormation for Log Insights query definition
+     */
+    generateQueryDefinitionCF(query: LogInsightsQuery): any;
+    /**
+     * Create log aggregation with multiple filters
+     */
+    createLogAggregation(logGroup: string, filters: Array<{
+        pattern: string;
+        metric: string;
+    }>, retention?: number): {
+        id: string;
+        logGroup: string;
+        filters: Array<{
+            pattern: string;
+            metric: string;
+        }>;
+        retention: number;
+    };
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global logs manager instance
+ */
+export declare const logsManager: LogsManager;

package/dist/observability/metrics.d.ts

@@ -0,0 +1,187 @@
+/**
+ * Custom CloudWatch Metrics
+ * Application and business metrics collection
+ */
+export interface MetricNamespace {
+    id: string;
+    name: string;
+    description?: string;
+    metrics: CustomMetric[];
+}
+export interface CustomMetric {
+    id: string;
+    name: string;
+    namespace: string;
+    unit: MetricUnit;
+    dimensions?: MetricDimension[];
+    statisticValues?: MetricStatistic[];
+    alarms?: MetricAlarm[];
+}
+export type MetricUnit = 'Seconds' | 'Microseconds' | 'Milliseconds' | 'Bytes' | 'Kilobytes' | 'Megabytes' | 'Gigabytes' | 'Terabytes' | 'Bits' | 'Kilobits' | 'Megabits' | 'Gigabits' | 'Terabits' | 'Percent' | 'Count' | 'Bytes/Second' | 'Kilobytes/Second' | 'Megabytes/Second' | 'Gigabytes/Second' | 'Terabytes/Second' | 'Bits/Second' | 'Kilobits/Second' | 'Megabits/Second' | 'Gigabits/Second' | 'Terabits/Second' | 'Count/Second' | 'None';
+export interface MetricDimension {
+    name: string;
+    value: string;
+}
+export interface MetricStatistic {
+    sampleCount: number;
+    sum: number;
+    minimum: number;
+    maximum: number;
+    timestamp: Date;
+}
+export interface MetricAlarm {
+    id: string;
+    name: string;
+    description?: string;
+    comparisonOperator: 'GreaterThanThreshold' | 'GreaterThanOrEqualToThreshold' | 'LessThanThreshold' | 'LessThanOrEqualToThreshold';
+    evaluationPeriods: number;
+    threshold: number;
+    period: number;
+    statistic: 'Average' | 'Sum' | 'Minimum' | 'Maximum' | 'SampleCount';
+    treatMissingData?: 'notBreaching' | 'breaching' | 'ignore' | 'missing';
+    actionsEnabled?: boolean;
+    alarmActions?: string[];
+    okActions?: string[];
+    insufficientDataActions?: string[];
+}
+/**
+ * Metrics manager
+ */
+export declare class MetricsManager {
+    private namespaces;
+    private metrics;
+    private namespaceCounter;
+    private metricCounter;
+    private alarmCounter;
+    /**
+     * Create metric namespace
+     */
+    createNamespace(namespace: Omit<MetricNamespace, 'id'>): MetricNamespace;
+    /**
+     * Create custom metric
+     */
+    createMetric(metric: Omit<CustomMetric, 'id'>): CustomMetric;
+    /**
+     * Create business metric (e.g., orders, signups, revenue)
+     */
+    createBusinessMetric(options: {
+        name: string;
+        namespace: string;
+        unit: MetricUnit;
+        description?: string;
+    }): CustomMetric;
+    /**
+     * Create application metric (e.g., cache hits, queue depth)
+     */
+    createApplicationMetric(options: {
+        name: string;
+        namespace: string;
+        unit: MetricUnit;
+        serviceName: string;
+    }): CustomMetric;
+    /**
+     * Create performance metric
+     */
+    createPerformanceMetric(options: {
+        name: string;
+        namespace: string;
+        operation: string;
+    }): CustomMetric;
+    /**
+     * Create error metric
+     */
+    createErrorMetric(options: {
+        name: string;
+        namespace: string;
+        errorType: string;
+    }): CustomMetric;
+    /**
+     * Create metric alarm
+     */
+    createAlarm(metricId: string, alarm: Omit<MetricAlarm, 'id'>): MetricAlarm;
+    /**
+     * Create high error rate alarm
+     */
+    createErrorRateAlarm(options: {
+        metricId: string;
+        name: string;
+        threshold: number;
+        snsTopicArn?: string;
+    }): MetricAlarm;
+    /**
+     * Create latency alarm
+     */
+    createLatencyAlarm(options: {
+        metricId: string;
+        name: string;
+        thresholdMs: number;
+        snsTopicArn?: string;
+    }): MetricAlarm;
+    /**
+     * Create throughput alarm
+     */
+    createThroughputAlarm(options: {
+        metricId: string;
+        name: string;
+        minimumThreshold: number;
+        snsTopicArn?: string;
+    }): MetricAlarm;
+    /**
+     * Create composite alarm (multiple conditions)
+     */
+    createCompositeAlarm(options: {
+        name: string;
+        description?: string;
+        alarmRule: string;
+        actionsEnabled?: boolean;
+        alarmActions?: string[];
+    }): any;
+    /**
+     * Get namespace
+     */
+    getNamespace(id: string): MetricNamespace | undefined;
+    /**
+     * List namespaces
+     */
+    listNamespaces(): MetricNamespace[];
+    /**
+     * Get metric
+     */
+    getMetric(id: string): CustomMetric | undefined;
+    /**
+     * List metrics
+     */
+    listMetrics(): CustomMetric[];
+    /**
+     * Generate CloudFormation for metric alarm
+     */
+    generateAlarmCF(metric: CustomMetric, alarm: MetricAlarm): any;
+    /**
+     * Generate CloudFormation for composite alarm
+     */
+    generateCompositeAlarmCF(alarm: any): any;
+    /**
+     * Generate dashboard widget for metric
+     */
+    generateDashboardWidget(metric: CustomMetric): any;
+    /**
+     * Publish a custom metric value directly
+     */
+    publishCustomMetric(namespace: string, name: string, value: number, dimensions?: Record<string, string>, unit?: string): {
+        id: string;
+        namespace: string;
+        name: string;
+        dimensions: Record<string, string>;
+        value: number;
+        unit: string;
+        timestamp: Date;
+    };
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global metrics manager instance
+ */
+export declare const metricsManager: MetricsManager;

package/dist/observability/observability.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/observability/synthetics.d.ts

@@ -0,0 +1,189 @@
+/**
+ * Synthetic Monitoring
+ * CloudWatch Synthetics Canaries for proactive monitoring
+ */
+export interface SyntheticCanary {
+    id: string;
+    name: string;
+    description?: string;
+    runtimeVersion: string;
+    handler: string;
+    code: CanaryCode;
+    schedule: CanarySchedule;
+    runConfig?: CanaryRunConfig;
+    vpcConfig?: VpcConfig;
+    artifactS3Location: string;
+    successRetentionPeriod?: number;
+    failureRetentionPeriod?: number;
+    alarms?: CanaryAlarm[];
+}
+export interface CanaryCode {
+    type: 'script' | 's3';
+    script?: string;
+    s3Bucket?: string;
+    s3Key?: string;
+    s3Version?: string;
+}
+export interface CanarySchedule {
+    expression: string;
+    durationInSeconds?: number;
+}
+export interface CanaryRunConfig {
+    timeoutInSeconds: number;
+    memoryInMB: number;
+    environmentVariables?: Record<string, string>;
+    activeTracing?: boolean;
+}
+export interface VpcConfig {
+    subnetIds: string[];
+    securityGroupIds: string[];
+}
+export interface CanaryAlarm {
+    id: string;
+    name: string;
+    metric: 'SuccessPercent' | 'Duration' | 'Failed';
+    threshold: number;
+    evaluationPeriods: number;
+    snsTopicArn?: string;
+}
+export interface HeartbeatMonitor {
+    id: string;
+    name: string;
+    url: string;
+    interval: number;
+    timeout: number;
+    expectedStatus?: number;
+}
+export interface ApiMonitor {
+    id: string;
+    name: string;
+    baseUrl: string;
+    endpoints: ApiEndpoint[];
+    headers?: Record<string, string>;
+    interval: number;
+}
+export interface ApiEndpoint {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    expectedStatus: number;
+    body?: any;
+    assertions?: ApiAssertion[];
+}
+export interface ApiAssertion {
+    type: 'status' | 'header' | 'body' | 'latency';
+    field?: string;
+    operator: 'equals' | 'contains' | 'lessThan' | 'greaterThan';
+    value: any;
+}
+/**
+ * Synthetics manager
+ */
+export declare class SyntheticsManager {
+    private canaries;
+    private heartbeats;
+    private apiMonitors;
+    private canaryCounter;
+    private heartbeatCounter;
+    private apiMonitorCounter;
+    private alarmCounter;
+    /**
+     * Latest runtime versions
+     */
+    static readonly RuntimeVersions: {
+        NODEJS_PUPPETEER_3_9: string;
+        NODEJS_PUPPETEER_4_0: string;
+        PYTHON_SELENIUM_1_3: string;
+    };
+    /**
+     * Create synthetic canary
+     */
+    createCanary(canary: Omit<SyntheticCanary, 'id'>): SyntheticCanary;
+    /**
+     * Create heartbeat canary
+     */
+    createHeartbeatCanary(options: {
+        name: string;
+        url: string;
+        interval: number;
+        s3Bucket: string;
+    }): SyntheticCanary;
+    /**
+     * Create API monitoring canary
+     */
+    createAPICanary(options: {
+        name: string;
+        baseUrl: string;
+        endpoints: ApiEndpoint[];
+        interval: number;
+        s3Bucket: string;
+    }): SyntheticCanary;
+    /**
+     * Create visual regression canary
+     */
+    createVisualRegressionCanary(options: {
+        name: string;
+        url: string;
+        screenshotName: string;
+        interval: number;
+        s3Bucket: string;
+    }): SyntheticCanary;
+    /**
+     * Create workflow canary (multi-step user journey)
+     */
+    createWorkflowCanary(options: {
+        name: string;
+        description: string;
+        steps: WorkflowStep[];
+        interval: number;
+        s3Bucket: string;
+    }): SyntheticCanary;
+    /**
+     * Generate action script for workflow steps
+     */
+    private generateActionScript;
+    /**
+     * Create canary alarm
+     */
+    createAlarm(canaryId: string, alarm: Omit<CanaryAlarm, 'id'>): CanaryAlarm;
+    /**
+     * Get canary
+     */
+    getCanary(id: string): SyntheticCanary | undefined;
+    /**
+     * List canaries
+     */
+    listCanaries(): SyntheticCanary[];
+    /**
+     * Generate CloudFormation for canary
+     */
+    generateCanaryCF(canary: SyntheticCanary): any;
+    /**
+     * Generate CloudFormation for canary execution role
+     */
+    generateCanaryRoleCF(): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Workflow step interface
+ */
+export interface WorkflowStep {
+    description: string;
+    url: string;
+    actions?: WorkflowAction[];
+}
+/**
+ * Workflow action interface
+ */
+export interface WorkflowAction {
+    type: 'click' | 'type' | 'wait' | 'waitForSelector';
+    selector?: string;
+    value?: string;
+    duration?: number;
+}
+/**
+ * Global synthetics manager instance
+ */
+export declare const syntheticsManager: SyntheticsManager;