@kensio/yulin 1.21.0 → 1.21.2

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/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;

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

@@ -0,0 +1,81 @@
+import { simLogsEmbeddedMetricDocument, } from "./sim-logs-embedded-metric-document.js";
+import { embeddedMetricDimensions, embeddedMetricValues, } from "./sim-logs-embedded-metric-values.js";
+const nothingRead = {
+    datapoints: [],
+    skipped: [],
+};
+/**
+ * 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 function simLogsEmbeddedMetricReading(message, ingestionTime) {
+    const document = simLogsEmbeddedMetricDocument(message);
+    if (document === undefined) {
+        return nothingRead;
+    }
+    const datapoints = [];
+    const skipped = [];
+    const timestamp = document.timestamp ?? ingestionTime;
+    for (const directive of document.directives) {
+        const read = readDirective(document, directive, timestamp);
+        datapoints.push(...read.datapoints);
+        skipped.push(...read.skipped);
+    }
+    return { datapoints, skipped };
+}
+/**
+ * Why a directive that asked for dimensions can publish none of its metrics.
+ */
+function unusableDimensions(directive, dimensionSets) {
+    return directive.declaresDimensions && dimensionSets.length === 0
+        ? `The document declares dimensions for ${directive.namespace} and ` +
+            `carries no usable set of them, so there is no identity to publish ` +
+            `under.`
+        : undefined;
+}
+function readDirective(document, directive, timestamp) {
+    const datapoints = [];
+    const skipped = [];
+    const resolved = directive.dimensionSets
+        .map((keys) => embeddedMetricDimensions(document, keys))
+        .filter((dimensions) => dimensions !== undefined);
+    // A directive asking for no dimensions publishes undimensioned. One that
+    // asked and got nothing usable publishes nothing at all.
+    const dimensionSets = directive.declaresDimensions ? resolved : [[]];
+    const noIdentity = unusableDimensions(directive, dimensionSets);
+    const skip = (metricName, reason) => {
+        skipped.push({
+            metricNamespace: directive.namespace,
+            metricName,
+            reason,
+        });
+    };
+    for (const metric of directive.metrics) {
+        const values = embeddedMetricValues(document, metric);
+        if (typeof values === "string") {
+            skip(metric.name, values);
+            continue;
+        }
+        if (noIdentity !== undefined) {
+            skip(metric.name, noIdentity);
+            continue;
+        }
+        for (const dimensions of dimensionSets) {
+            for (const value of values) {
+                datapoints.push({
+                    namespace: directive.namespace,
+                    metricName: metric.name,
+                    value,
+                    timestamp,
+                    unit: metric.unit,
+                    dimensions,
+                });
+            }
+        }
+    }
+    return { datapoints, skipped };
+}

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

@@ -0,0 +1,57 @@
+/**
+ * The property an Embedded Metric Format document carries its metadata under.
+ *
+ * A log event without it is an ordinary line, and the great majority of lines
+ * in a log group are. Looking for this before parsing anything is what keeps
+ * the check on the write path cheap.
+ */
+export declare const embeddedMetricMetadataKey = "_aws";
+/**
+ * One metric an EMF document declares.
+ */
+export interface SimLogsEmbeddedMetricDeclaration {
+    readonly name: string;
+    readonly unit: string | undefined;
+    readonly storageResolution: number | undefined;
+}
+/**
+ * One namespace's worth of an EMF document's metadata.
+ *
+ * `dimensionSets` is a list of dimension key lists, and each inner list is one
+ * whole dimension set. A document declaring two sets publishes each of its
+ * metrics once per set.
+ */
+export interface SimLogsEmbeddedMetricDirective {
+    readonly namespace: string;
+    /**
+     * Whether the directive asked for dimensions at all.
+     *
+     * A directive that asked for none publishes undimensioned. One that asked
+     * and whose sets all turn out to be unusable publishes nothing, because
+     * falling back to no dimensions would put the datapoint on a metric the
+     * document never named.
+     */
+    readonly declaresDimensions: boolean;
+    readonly dimensionSets: readonly (readonly string[])[];
+    readonly metrics: readonly SimLogsEmbeddedMetricDeclaration[];
+}
+/**
+ * An Embedded Metric Format document read out of one log event.
+ *
+ * `values` is every top-level property of the document, which is where both
+ * the metric values and the dimension values live. The metadata names them,
+ * and the document body carries them.
+ */
+export interface SimLogsEmbeddedMetricDocument {
+    readonly timestamp: number | undefined;
+    readonly directives: readonly SimLogsEmbeddedMetricDirective[];
+    readonly values: ReadonlyMap<string, unknown>;
+}
+/**
+ * Read a log event's message as an EMF document, or answer undefined.
+ *
+ * Anything that is not JSON, is not an object, or carries no usable `_aws`
+ * metadata is an ordinary log line. It is stored and left alone rather than
+ * refused, because a log group is full of lines that were never metrics.
+ */
+export declare function simLogsEmbeddedMetricDocument(message: string): SimLogsEmbeddedMetricDocument | undefined;