@kensio/yulin 1.20.17 → 1.21.1

package/dist/service/logs/command/metric/metric-filter.command.d.ts

@@ -0,0 +1,79 @@
+import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+/**
+ * One metric transformation as the API takes and reports it.
+ *
+ * `dimensions` is a map of dimension name to value, which is the shape the SDK
+ * uses. The CloudFormation Resource carries the same thing as a list of
+ * Key/Value pairs.
+ */
+export interface SimLogsMetricTransformationInput {
+    readonly metricName?: string | undefined;
+    readonly metricNamespace?: string | undefined;
+    readonly metricValue?: string | undefined;
+    readonly defaultValue?: number | undefined;
+    readonly dimensions?: Readonly<Record<string, string>> | undefined;
+    readonly unit?: string | undefined;
+}
+/**
+ * Minimal structural sim CloudWatch Logs PutMetricFilter command.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/PutMetricFilterCommand/
+ */
+export interface SimPutMetricFilterCommand {
+    readonly input: SimPutMetricFilterCommandInput;
+}
+export interface SimPutMetricFilterCommandInput {
+    readonly logGroupName?: string | undefined;
+    readonly filterName?: string | undefined;
+    readonly filterPattern?: string | undefined;
+    readonly metricTransformations?: readonly SimLogsMetricTransformationInput[] | undefined;
+}
+export interface SimPutMetricFilterCommandOutput {
+    readonly $metadata: SimResponseMetadata;
+}
+/**
+ * Minimal structural sim CloudWatch Logs DescribeMetricFilters command.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/DescribeMetricFiltersCommand/
+ */
+export interface SimDescribeMetricFiltersCommand {
+    readonly input: SimDescribeMetricFiltersCommandInput;
+}
+export interface SimDescribeMetricFiltersCommandInput {
+    readonly logGroupName?: string | undefined;
+    readonly filterNamePrefix?: string | undefined;
+    readonly metricName?: string | undefined;
+    readonly metricNamespace?: string | undefined;
+    readonly limit?: number | undefined;
+    readonly nextToken?: string | undefined;
+}
+export interface SimDescribeMetricFiltersCommandOutput {
+    readonly metricFilters?: readonly SimLogsMetricFilterDetail[] | undefined;
+    readonly nextToken?: string | undefined;
+    readonly $metadata: SimResponseMetadata;
+}
+/**
+ * What DescribeMetricFilters reports about one filter.
+ */
+export interface SimLogsMetricFilterDetail {
+    readonly filterName: string;
+    readonly logGroupName: string;
+    readonly filterPattern: string;
+    readonly metricTransformations: readonly SimLogsMetricTransformationInput[];
+    readonly creationTime: number;
+}
+/**
+ * Minimal structural sim CloudWatch Logs DeleteMetricFilter command.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/DeleteMetricFilterCommand/
+ */
+export interface SimDeleteMetricFilterCommand {
+    readonly input: SimDeleteMetricFilterCommandInput;
+}
+export interface SimDeleteMetricFilterCommandInput {
+    readonly logGroupName?: string | undefined;
+    readonly filterName?: string | undefined;
+}
+export interface SimDeleteMetricFilterCommandOutput {
+    readonly $metadata: SimResponseMetadata;
+}

package/dist/service/logs/command/metric/metric-filter.command.js

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

package/dist/service/logs/command/metric/sim-logs-metric-filter-commands.d.ts

@@ -0,0 +1,48 @@
+import type { SimClock } from "../../../../util/clock/sim-clock.js";
+import type { SimLogsLogGroupStore } from "../../group/sim-logs-log-group-store.js";
+import type { SimLogsMetricFanOut } from "../../metric/sim-logs-metric-fan-out.js";
+import type { SimLogsAuthorizer } from "../authorize/sim-logs-authorizer.js";
+import type { SimLogsRequestOptions } from "../sim-logs-request-options.js";
+import type { SimDeleteMetricFilterCommand, SimDeleteMetricFilterCommandOutput, SimDescribeMetricFiltersCommand, SimDescribeMetricFiltersCommandOutput, SimPutMetricFilterCommand, SimPutMetricFilterCommandOutput } from "./metric-filter.command.js";
+interface SimLogsMetricFilterCommandsProperties {
+    readonly groups: SimLogsLogGroupStore;
+    readonly authorizer: SimLogsAuthorizer;
+    readonly fanOut: SimLogsMetricFanOut;
+    readonly clock: SimClock;
+}
+/**
+ * The commands that put, describe and remove metric filters.
+ */
+export declare class SimLogsMetricFilterCommands {
+    #private;
+    constructor(properties: SimLogsMetricFilterCommandsProperties);
+    /**
+     * Put a metric filter on a log group.
+     *
+     * Whether the datapoints could go anywhere is checked here, the way
+     * `PutSubscriptionFilter` checks its destination. A filter that takes its
+     * configuration and publishes nothing is worse than a failure, because the
+     * alarm over its metric then reports healthy for ever.
+     */
+    putMetricFilter(command: SimPutMetricFilterCommand, options?: SimLogsRequestOptions): SimPutMetricFilterCommandOutput;
+    /**
+     * Describe metric filters, on one log group or across them all.
+     *
+     * Real CloudWatch Logs takes `logGroupName` as optional here, unlike
+     * `DescribeSubscriptionFilters`. Leaving it off is how a caller finds every
+     * filter writing to a metric it has an alarm on.
+     */
+    describeMetricFilters(command: SimDescribeMetricFiltersCommand, options?: SimLogsRequestOptions): SimDescribeMetricFiltersCommandOutput;
+    /**
+     * Remove a metric filter from a log group.
+     */
+    deleteMetricFilter(command: SimDeleteMetricFilterCommand, options?: SimLogsRequestOptions): SimDeleteMetricFilterCommandOutput;
+    /**
+     * The filters one describe request selects, authorized for what it reaches.
+     *
+     * A request naming no log group reaches every one in the scope, so it is
+     * authorized against them all rather than against any single group.
+     */
+    private selected;
+}
+export {};

package/dist/service/logs/command/metric/sim-logs-metric-filter-commands.js

@@ -0,0 +1,95 @@
+import { requiredSimLogsLogGroupName } from "../../group/sim-logs-log-group-name.js";
+import { SimLogsMetricFilter } from "../../metric/sim-logs-metric-filter.js";
+import { simLogsSelectedMetricFilters } from "../../metric/sim-logs-metric-filter-selection.js";
+import { SimLogsPage } from "../sim-logs-page.js";
+import { requiredSimLogsFilterName } from "../subscription/sim-logs-subscription-input.js";
+import { requiredSimLogsMetricTransformations, simLogsMetricFilterDetail, } from "./sim-logs-metric-filter-input.js";
+const maximumDescribeLimit = 50;
+/**
+ * The commands that put, describe and remove metric filters.
+ */
+export class SimLogsMetricFilterCommands {
+    #groups;
+    #authorizer;
+    #fanOut;
+    #clock;
+    constructor(properties) {
+        this.#groups = properties.groups;
+        this.#authorizer = properties.authorizer;
+        this.#fanOut = properties.fanOut;
+        this.#clock = properties.clock;
+    }
+    /**
+     * Put a metric filter on a log group.
+     *
+     * Whether the datapoints could go anywhere is checked here, the way
+     * `PutSubscriptionFilter` checks its destination. A filter that takes its
+     * configuration and publishes nothing is worse than a failure, because the
+     * alarm over its metric then reports healthy for ever.
+     */
+    putMetricFilter(command, options) {
+        const input = command.input;
+        const logGroupName = requiredSimLogsLogGroupName(input.logGroupName);
+        const filterName = requiredSimLogsFilterName(input.filterName);
+        const transformations = requiredSimLogsMetricTransformations(input.metricTransformations);
+        this.#authorizer.authorizeLogGroup("logs:PutMetricFilter", logGroupName, options?.caller);
+        const group = this.#groups.require(logGroupName);
+        this.#fanOut.checkPublishable();
+        group.metricFilters.put(new SimLogsMetricFilter({
+            filterName,
+            logGroupName,
+            filterPattern: input.filterPattern,
+            transformations,
+            creationTime: this.#clock.now().getTime(),
+        }));
+        return { $metadata: {} };
+    }
+    /**
+     * Describe metric filters, on one log group or across them all.
+     *
+     * Real CloudWatch Logs takes `logGroupName` as optional here, unlike
+     * `DescribeSubscriptionFilters`. Leaving it off is how a caller finds every
+     * filter writing to a metric it has an alarm on.
+     */
+    describeMetricFilters(command, options) {
+        const input = command.input;
+        const page = new SimLogsPage({
+            listed: this.selected(input, options),
+            limit: input.limit,
+            nextToken: input.nextToken,
+            maximumLimit: maximumDescribeLimit,
+        });
+        return {
+            $metadata: {},
+            metricFilters: page.items.map((filter) => simLogsMetricFilterDetail(filter)),
+            nextToken: page.nextToken,
+        };
+    }
+    /**
+     * Remove a metric filter from a log group.
+     */
+    deleteMetricFilter(command, options) {
+        const input = command.input;
+        const logGroupName = requiredSimLogsLogGroupName(input.logGroupName);
+        const filterName = requiredSimLogsFilterName(input.filterName);
+        this.#authorizer.authorizeLogGroup("logs:DeleteMetricFilter", logGroupName, options?.caller);
+        this.#groups.require(logGroupName).metricFilters.delete(filterName);
+        return { $metadata: {} };
+    }
+    /**
+     * The filters one describe request selects, authorized for what it reaches.
+     *
+     * A request naming no log group reaches every one in the scope, so it is
+     * authorized against them all rather than against any single group.
+     */
+    selected(input, options) {
+        const action = "logs:DescribeMetricFilters";
+        if (input.logGroupName === undefined) {
+            this.#authorizer.authorizeAnyLogGroup(action, options?.caller);
+            return this.#groups.all.flatMap((group) => simLogsSelectedMetricFilters(group.metricFilters.all, input));
+        }
+        const logGroupName = requiredSimLogsLogGroupName(input.logGroupName);
+        this.#authorizer.authorizeLogGroup(action, logGroupName, options?.caller);
+        return simLogsSelectedMetricFilters(this.#groups.require(logGroupName).metricFilters.all, input);
+    }
+}

package/dist/service/logs/command/metric/sim-logs-metric-filter-input.d.ts

@@ -0,0 +1,11 @@
+import type { SimLogsMetricFilter } from "../../metric/sim-logs-metric-filter.js";
+import { SimLogsMetricTransformation } from "../../metric/sim-logs-metric-transformation.js";
+import type { SimLogsMetricFilterDetail, SimLogsMetricTransformationInput } from "./metric-filter.command.js";
+/**
+ * Read the transformations a metric filter publishes through.
+ */
+export declare function requiredSimLogsMetricTransformations(transformations?: readonly SimLogsMetricTransformationInput[]): readonly SimLogsMetricTransformation[];
+/**
+ * What DescribeMetricFilters reports about one filter.
+ */
+export declare function simLogsMetricFilterDetail(filter: SimLogsMetricFilter): SimLogsMetricFilterDetail;

package/dist/service/logs/command/metric/sim-logs-metric-filter-input.js

@@ -0,0 +1,79 @@
+import { SimLogsInvalidParameterException } from "../../error/sim-logs.error.js";
+import { SimLogsMetricTransformation } from "../../metric/sim-logs-metric-transformation.js";
+/**
+ * How many transformations real CloudWatch Logs allows on one metric filter.
+ *
+ * One. The field is a list because the API has always shaped it that way, and
+ * an account refuses a second entry.
+ */
+const maximumTransformations = 1;
+/**
+ * Read the transformations a metric filter publishes through.
+ */
+export function requiredSimLogsMetricTransformations(transformations) {
+    if (transformations === undefined || transformations.length === 0) {
+        throw new SimLogsInvalidParameterException("1 validation error detected: Value at 'metricTransformations' failed " +
+            "to satisfy constraint: Member must not be null");
+    }
+    if (transformations.length > maximumTransformations) {
+        throw new SimLogsInvalidParameterException(`1 validation error detected: Value at 'metricTransformations' failed ` +
+            `to satisfy constraint: Member must have length less than or equal ` +
+            `to ${maximumTransformations}`);
+    }
+    return transformations.map((transformation) => metricTransformation(transformation));
+}
+/**
+ * Read one transformation, refusing what real CloudWatch Logs refuses.
+ */
+function metricTransformation(input) {
+    return new SimLogsMetricTransformation({
+        metricNamespace: requiredTransformationField("metricNamespace", input.metricNamespace),
+        metricName: requiredTransformationField("metricName", input.metricName),
+        metricValue: requiredTransformationField("metricValue", input.metricValue),
+        defaultValue: input.defaultValue,
+        unit: input.unit,
+        dimensions: metricDimensions(input.dimensions),
+    });
+}
+/**
+ * Read a transformation field the API requires.
+ */
+function requiredTransformationField(name, value) {
+    if (value === undefined || value.length === 0) {
+        throw new SimLogsInvalidParameterException(`1 validation error detected: Value at ` +
+            `'metricTransformations.member.${name}' failed to satisfy ` +
+            `constraint: Member must not be null`);
+    }
+    return value;
+}
+/**
+ * Read a transformation's dimensions from the map the SDK carries them in.
+ */
+function metricDimensions(dimensions) {
+    return Object.entries(dimensions ?? {}).map(([name, value]) => ({
+        name,
+        value,
+    }));
+}
+/**
+ * What DescribeMetricFilters reports about one filter.
+ */
+export function simLogsMetricFilterDetail(filter) {
+    return {
+        filterName: filter.filterName,
+        logGroupName: filter.logGroupName,
+        filterPattern: filter.filterPatternText,
+        metricTransformations: filter.transformations.map((transformation) => ({
+            metricName: transformation.metricName,
+            metricNamespace: transformation.metricNamespace,
+            metricValue: transformation.metricValue,
+            defaultValue: transformation.defaultValue,
+            unit: transformation.unit,
+            dimensions: Object.fromEntries(transformation.dimensions.map((dimension) => [
+                dimension.name,
+                dimension.value,
+            ])),
+        })),
+        creationTime: filter.creationTime,
+    };
+}

package/dist/service/logs/command/sim-logs-command.types.d.ts

@@ -4,6 +4,7 @@
 export type { SimCreateLogGroupCommand, SimCreateLogGroupCommandInput, SimCreateLogGroupCommandOutput, SimDeleteLogGroupCommand, SimDeleteLogGroupCommandInput, SimDeleteLogGroupCommandOutput, SimDeleteRetentionPolicyCommand, SimDeleteRetentionPolicyCommandInput, SimDeleteRetentionPolicyCommandOutput, SimDescribeLogGroupsCommand, SimDescribeLogGroupsCommandInput, SimDescribeLogGroupsCommandOutput, SimLogsLogGroupDetail, SimPutRetentionPolicyCommand, SimPutRetentionPolicyCommandInput, SimPutRetentionPolicyCommandOutput, } from "./group/group.command.js";
 export type { SimCreateLogStreamCommand, SimCreateLogStreamCommandInput, SimCreateLogStreamCommandOutput, SimDescribeLogStreamsCommand, SimDescribeLogStreamsCommandInput, SimDescribeLogStreamsCommandOutput, SimLogsLogStreamDetail, } from "./stream/stream.command.js";
 export type { SimFilterLogEventsCommand, SimFilterLogEventsCommandInput, SimFilterLogEventsCommandOutput, SimGetLogEventsCommand, SimGetLogEventsCommandInput, SimGetLogEventsCommandOutput, SimLogsFilteredLogEvent, SimLogsInputLogEvent, SimLogsOutputLogEvent, SimPutLogEventsCommand, SimPutLogEventsCommandInput, SimPutLogEventsCommandOutput, } from "./event/event.command.js";
+export type { SimDeleteMetricFilterCommand, SimDeleteMetricFilterCommandInput, SimDeleteMetricFilterCommandOutput, SimDescribeMetricFiltersCommand, SimDescribeMetricFiltersCommandInput, SimDescribeMetricFiltersCommandOutput, SimLogsMetricFilterDetail, SimLogsMetricTransformationInput, SimPutMetricFilterCommand, SimPutMetricFilterCommandInput, SimPutMetricFilterCommandOutput, } from "./metric/metric-filter.command.js";
 export type { SimDeleteSubscriptionFilterCommand, SimDeleteSubscriptionFilterCommandInput, SimDeleteSubscriptionFilterCommandOutput, SimDescribeSubscriptionFiltersCommand, SimDescribeSubscriptionFiltersCommandInput, SimDescribeSubscriptionFiltersCommandOutput, SimLogsSubscriptionFilterDetail, SimPutSubscriptionFilterCommand, SimPutSubscriptionFilterCommandInput, SimPutSubscriptionFilterCommandOutput, } from "./subscription/subscription.command.js";
 export type { SimDeleteDeliverySourceCommand, SimDeleteDeliverySourceCommandInput, SimDeleteDeliverySourceCommandOutput, SimDescribeDeliverySourcesCommand, SimDescribeDeliverySourcesCommandInput, SimDescribeDeliverySourcesCommandOutput, SimLogsDeliverySourceDetail, SimPutDeliverySourceCommand, SimPutDeliverySourceCommandInput, SimPutDeliverySourceCommandOutput, } from "./delivery/delivery-source.command.js";
 export type { SimDeleteDeliveryDestinationCommand, SimDeleteDeliveryDestinationCommandInput, SimDeleteDeliveryDestinationCommandOutput, SimDescribeDeliveryDestinationsCommand, SimDescribeDeliveryDestinationsCommandInput, SimDescribeDeliveryDestinationsCommandOutput, SimLogsDeliveryDestinationConfiguration, SimLogsDeliveryDestinationDetail, SimPutDeliveryDestinationCommand, SimPutDeliveryDestinationCommandInput, SimPutDeliveryDestinationCommandOutput, } from "./delivery/delivery-destination.command.js";

package/dist/service/logs/delivery/cloudfront/sim-logs-vended-log-delivery.d.ts

@@ -0,0 +1,23 @@
+import type { SimAwsCaller } from "../../../aws/caller/sim-aws-caller.js";
+import type { SimLogsAuthorizer } from "../../command/authorize/sim-logs-authorizer.js";
+interface SimLogsVendedLogDeliveryAuthorization {
+    readonly authorizer: SimLogsAuthorizer;
+    readonly service: string;
+    readonly resourceArn: string;
+    readonly caller?: SimAwsCaller | undefined;
+}
+/**
+ * Authorize delivering the logs of the resource a delivery source names.
+ *
+ * Creating a delivery source calls CloudWatch Logs, and CloudWatch Logs then
+ * checks the caller against the service that owns the resource being logged.
+ * A policy is usually written by asking which service owns the resource type,
+ * and that question gives the wrong answer here. A caller allowed every
+ * `logs:` action and denied CloudFront outright is refused.
+ *
+ * CloudFront is the one delivered service checked, because it is the one the
+ * simulation can name a resource of. A source over an ARN of any other service
+ * carries on as it always did.
+ */
+export declare function authorizeSimLogsVendedLogDelivery(properties: SimLogsVendedLogDeliveryAuthorization): void;
+export {};

package/dist/service/logs/delivery/cloudfront/sim-logs-vended-log-delivery.js

@@ -0,0 +1,28 @@
+import { simLogsCloudFrontDeliveryService } from "../sim-logs-delivery-source-service.js";
+/**
+ * The CloudFront action a delivery source over a distribution is checked for.
+ *
+ * CloudFront names it and nobody calls it. It exists so that setting up
+ * delivery from a distribution is a permission of its own, held apart from
+ * everything else a caller may do to that distribution.
+ */
+const simLogsVendedLogDeliveryAction = "cloudfront:AllowVendedLogDeliveryForResource";
+/**
+ * Authorize delivering the logs of the resource a delivery source names.
+ *
+ * Creating a delivery source calls CloudWatch Logs, and CloudWatch Logs then
+ * checks the caller against the service that owns the resource being logged.
+ * A policy is usually written by asking which service owns the resource type,
+ * and that question gives the wrong answer here. A caller allowed every
+ * `logs:` action and denied CloudFront outright is refused.
+ *
+ * CloudFront is the one delivered service checked, because it is the one the
+ * simulation can name a resource of. A source over an ARN of any other service
+ * carries on as it always did.
+ */
+export function authorizeSimLogsVendedLogDelivery(properties) {
+    if (properties.service !== simLogsCloudFrontDeliveryService) {
+        return;
+    }
+    properties.authorizer.authorizeResource(simLogsVendedLogDeliveryAction, properties.resourceArn, properties.caller);
+}

package/dist/service/logs/group/sim-logs-log-group.d.ts

@@ -1,5 +1,6 @@
 import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
 import type { SimLogsLogStream } from "../stream/sim-logs-log-stream.js";
+import { SimLogsMetricFilterStore } from "../metric/sim-logs-metric-filter-store.js";
 import { SimLogsSubscriptionFilterStore } from "../subscription/sim-logs-subscription-filter-store.js";
 interface SimLogsLogGroupProperties {
     readonly logGroupName: string;
@@ -25,6 +26,11 @@ export declare class SimLogsLogGroup {
      * written to it onward.
      */
     readonly subscriptionFilters: SimLogsSubscriptionFilterStore;
+    /**
+     * The metric filters watching this group, which turn what is written to it
+     * into CloudWatch metric datapoints.
+     */
+    readonly metricFilters: SimLogsMetricFilterStore;
     constructor(properties: SimLogsLogGroupProperties);
     /**
      * How long events in this group are kept, or undefined where nothing has set

package/dist/service/logs/group/sim-logs-log-group.js

@@ -1,4 +1,5 @@
 import { SimLogsLogStreamStore } from "../stream/sim-logs-log-stream-store.js";
+import { SimLogsMetricFilterStore } from "../metric/sim-logs-metric-filter-store.js";
 import { SimLogsSubscriptionFilterStore } from "../subscription/sim-logs-subscription-filter-store.js";
 import { simLogsLogGroupArn, simLogsLogGroupWildcardArn, simLogsLogStreamArn, } from "./sim-logs-arn.js";
 /**
@@ -19,6 +20,11 @@ export class SimLogsLogGroup {
      * written to it onward.
      */
     subscriptionFilters = new SimLogsSubscriptionFilterStore();
+    /**
+     * The metric filters watching this group, which turn what is written to it
+     * into CloudWatch metric datapoints.
+     */
+    metricFilters = new SimLogsMetricFilterStore();
     #streams;
     #retentionInDays;
     constructor(properties) {

package/dist/service/logs/index.d.ts

@@ -10,6 +10,12 @@ export { requiredSimLogsLogStreamName } from "./stream/sim-logs-log-stream-name.
 export { compareSimLogsEvents, simLogsEventOverheadBytes, simLogsEventSizeBytes, type SimLogsStoredEvent, } from "./event/sim-logs-event.js";
 export { SimLogsEventIds } from "./event/sim-logs-event-ids.js";
 export { SimLogsFilterPattern } from "./event/sim-logs-filter-pattern.js";
+export { SimLogsMetricFilter } from "./metric/sim-logs-metric-filter.js";
+export { SimLogsMetricFilterStore } from "./metric/sim-logs-metric-filter-store.js";
+export { SimLogsMetricTransformation, simLogsMaximumMetricDimensions, } from "./metric/sim-logs-metric-transformation.js";
+export type { SimLogsMetricDatapoint, SimLogsMetricDimension, } from "./metric/sim-logs-metric-datapoint.js";
+export { metricFilterSource, simLogsEmbeddedMetricSource, type SimLogsMetricPublicationFailure, type SimLogsMetricPublicationSource, } from "./metric/sim-logs-metric-publication-failure.js";
+export type { SimLogsMetricPublications } from "./metric/sim-logs-metric-publications.js";
 export { simLogsStandardLogGroupClass } from "./command/group/sim-logs-unsimulated-group-input.js";
 export { SimLogsDeliverySource } from "./delivery/sim-logs-delivery-source.js";
 export { SimLogsDeliveryDestination } from "./delivery/sim-logs-delivery-destination.js";

package/dist/service/logs/index.js

@@ -9,6 +9,10 @@ export { requiredSimLogsLogStreamName } from "./stream/sim-logs-log-stream-name.
 export { compareSimLogsEvents, simLogsEventOverheadBytes, simLogsEventSizeBytes, } from "./event/sim-logs-event.js";
 export { SimLogsEventIds } from "./event/sim-logs-event-ids.js";
 export { SimLogsFilterPattern } from "./event/sim-logs-filter-pattern.js";
+export { SimLogsMetricFilter } from "./metric/sim-logs-metric-filter.js";
+export { SimLogsMetricFilterStore } from "./metric/sim-logs-metric-filter-store.js";
+export { SimLogsMetricTransformation, simLogsMaximumMetricDimensions, } from "./metric/sim-logs-metric-transformation.js";
+export { metricFilterSource, simLogsEmbeddedMetricSource, } from "./metric/sim-logs-metric-publication-failure.js";
 export { simLogsStandardLogGroupClass } from "./command/group/sim-logs-unsimulated-group-input.js";
 export { SimLogsDeliverySource } from "./delivery/sim-logs-delivery-source.js";
 export { SimLogsDeliveryDestination } from "./delivery/sim-logs-delivery-destination.js";

package/dist/service/logs/metric/cloudwatch/sim-aws-logs-metric-filter-metrics.d.ts

@@ -0,0 +1,40 @@
+import type { SimAwsAccountRegionScope } from "../../../aws/sim-aws-account-region-scope.js";
+import type { SimAws } from "../../../aws/sim-aws.js";
+import type { SimLogsMetricDatapoint } from "../sim-logs-metric-datapoint.js";
+import type { SimLogsMetricPublications } from "../sim-logs-metric-publications.js";
+interface SimAwsLogsMetricFilterMetricsProperties {
+    readonly simAws: SimAws;
+    readonly accountRegionScope: SimAwsAccountRegionScope;
+}
+/**
+ * The simulated CloudWatch a metric filter's datapoints are published into.
+ *
+ * Real CloudWatch Logs publishes a filter's metric in the Account and Region
+ * of the log group, and there is no way to point one at another Region, so
+ * this scope's own CloudWatch is the one to write to.
+ *
+ * Publication goes through the ordinary `PutMetricData` path, which keeps one
+ * route into the metric store rather than a private one. A filter naming a
+ * reserved `AWS/` namespace is therefore refused exactly as a caller putting
+ * into one is.
+ *
+ * The Account root is named as the caller rather than left to be resolved.
+ * Real CloudWatch Logs publishes a filter's datapoint itself, and no policy
+ * anybody writes gates it. Leaving the caller off would pick up the ambient
+ * one, so a filter over a Lambda function's log group would publish as that
+ * function's execution role and be denied for a metric the role has no reason
+ * to name.
+ */
+export declare class SimAwsLogsMetricFilterMetrics implements SimLogsMetricPublications {
+    #private;
+    constructor(properties: SimAwsLogsMetricFilterMetricsProperties);
+    /**
+     * Publish the datapoints one log event produced.
+     *
+     * `PutMetricData` carries one namespace per request, so datapoints are
+     * grouped by the namespace they were published under. One batch writing into
+     * two namespaces is two requests, as it is on real AWS.
+     */
+    publish(datapoints: readonly SimLogsMetricDatapoint[]): Promise<void>;
+}
+export {};

package/dist/service/logs/metric/cloudwatch/sim-aws-logs-metric-filter-metrics.js

@@ -0,0 +1,78 @@
+import { makeSimAwsAccountRootPrincipal } from "../../../aws/caller/sim-aws-account-root-principal.js";
+/**
+ * The simulated CloudWatch a metric filter's datapoints are published into.
+ *
+ * Real CloudWatch Logs publishes a filter's metric in the Account and Region
+ * of the log group, and there is no way to point one at another Region, so
+ * this scope's own CloudWatch is the one to write to.
+ *
+ * Publication goes through the ordinary `PutMetricData` path, which keeps one
+ * route into the metric store rather than a private one. A filter naming a
+ * reserved `AWS/` namespace is therefore refused exactly as a caller putting
+ * into one is.
+ *
+ * The Account root is named as the caller rather than left to be resolved.
+ * Real CloudWatch Logs publishes a filter's datapoint itself, and no policy
+ * anybody writes gates it. Leaving the caller off would pick up the ambient
+ * one, so a filter over a Lambda function's log group would publish as that
+ * function's execution role and be denied for a metric the role has no reason
+ * to name.
+ */
+export class SimAwsLogsMetricFilterMetrics {
+    #simAws;
+    #accountRegionScope;
+    constructor(properties) {
+        this.#simAws = properties.simAws;
+        this.#accountRegionScope = properties.accountRegionScope;
+    }
+    /**
+     * Publish the datapoints one log event produced.
+     *
+     * `PutMetricData` carries one namespace per request, so datapoints are
+     * grouped by the namespace they were published under. One batch writing into
+     * two namespaces is two requests, as it is on real AWS.
+     */
+    async publish(datapoints) {
+        const scope = this.#accountRegionScope;
+        const cloudWatch = this.#simAws
+            .accountRegionScope(scope.accountId, scope.regionName)
+            .cloudWatch();
+        const caller = makeSimAwsAccountRootPrincipal(scope.accountId);
+        for (const [namespace, data] of byNamespace(datapoints)) {
+            // oxlint-disable-next-line no-await-in-loop -- one request per namespace, in order
+            await cloudWatch.putMetricData({ input: { Namespace: namespace, MetricData: data } }, { caller });
+        }
+    }
+}
+/**
+ * The datapoints grouped into one PutMetricData request per namespace.
+ */
+function byNamespace(datapoints) {
+    const grouped = new Map();
+    for (const datapoint of datapoints) {
+        const data = grouped.get(datapoint.namespace) ?? [];
+        data.push(metricDatum(datapoint));
+        grouped.set(datapoint.namespace, data);
+    }
+    return grouped;
+}
+/**
+ * One datapoint as PutMetricData takes it.
+ *
+ * The timestamp is the instant CloudWatch Logs took the event, rather than the
+ * instant this runs. Publication happens on the background scheduler, and a
+ * clock that moved in between would otherwise file the datapoint under a later
+ * period than the log line it counts.
+ */
+function metricDatum(datapoint) {
+    return {
+        MetricName: datapoint.metricName,
+        Value: datapoint.value,
+        Timestamp: new Date(datapoint.timestamp),
+        Unit: datapoint.unit,
+        Dimensions: datapoint.dimensions.map((dimension) => ({
+            Name: dimension.name,
+            Value: dimension.value,
+        })),
+    };
+}

package/dist/service/logs/metric/emf/sim-logs-embedded-metric-datapoints.d.ts

@@ -0,0 +1,25 @@
+import type { SimLogsMetricDatapoint } from "../sim-logs-metric-datapoint.js";
+/**
+ * One metric an EMF document declared and this could not publish.
+ */
+export interface SimLogsEmbeddedMetricSkip {
+    readonly metricNamespace: string;
+    readonly metricName: string;
+    readonly reason: string;
+}
+/**
+ * What one log event's EMF document produced.
+ */
+export interface SimLogsEmbeddedMetricReading {
+    readonly datapoints: readonly SimLogsMetricDatapoint[];
+    readonly skipped: readonly SimLogsEmbeddedMetricSkip[];
+}
+/**
+ * Read the metrics one log event's message publishes as EMF.
+ *
+ * A message that is not an EMF document reads as nothing at all. The timestamp
+ * comes from the document where it carries one, because a Powertools handler
+ * stamps its own document, and from the instant CloudWatch Logs took the event
+ * where it does not.
+ */
+export declare function simLogsEmbeddedMetricReading(message: string, ingestionTime: number): SimLogsEmbeddedMetricReading;