@kensio/yulin 1.20.17 → 1.21.1

package/dist/service/logs/metric/sim-logs-metric-filter-store.js

@@ -0,0 +1,47 @@
+import { SimLogsResourceNotFoundException } from "../error/sim-logs.error.js";
+/**
+ * The metric filters on one log group.
+ *
+ * They belong to the group the way its subscription filters and its streams
+ * do. A metric filter has no identity outside the group it watches, and
+ * deleting the group takes its filters with it.
+ */
+export class SimLogsMetricFilterStore {
+    #filters = new Map();
+    /**
+     * Every filter on this group, in the order they were put.
+     */
+    get all() {
+        return this.#filters.values().toArray();
+    }
+    /**
+     * How many filters this group has, which is what `DescribeLogGroups` reports
+     * as `metricFilterCount`.
+     */
+    get count() {
+        return this.#filters.size;
+    }
+    /**
+     * Find a filter on this group by name.
+     */
+    find(filterName) {
+        return this.#filters.get(filterName);
+    }
+    /**
+     * Put a filter, replacing one of the same name.
+     *
+     * Putting a filter already there by name is an update rather than a second
+     * filter, which is what makes `PutMetricFilter` the way to change a pattern.
+     */
+    put(filter) {
+        this.#filters.set(filter.filterName, filter);
+    }
+    /**
+     * Remove a filter by name, refusing one that was never there.
+     */
+    delete(filterName) {
+        if (!this.#filters.delete(filterName)) {
+            throw new SimLogsResourceNotFoundException("The specified metric filter does not exist.");
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+import type { SimLogsStoredEvent } from "../event/sim-logs-event.js";
+import type { SimLogsMetricDatapoint } from "./sim-logs-metric-datapoint.js";
+import type { SimLogsMetricTransformation } from "./sim-logs-metric-transformation.js";
+interface SimLogsMetricFilterProperties {
+    readonly filterName: string;
+    readonly logGroupName: string;
+    readonly filterPattern: string | undefined;
+    readonly transformations: readonly SimLogsMetricTransformation[];
+    readonly creationTime: number;
+}
+/**
+ * One metric filter on a log group.
+ *
+ * The pattern is compiled once, when the filter is put, the way a subscription
+ * filter's is. A pattern this simulator cannot read is refused there rather
+ * than on the first event that happens to arrive.
+ */
+export declare class SimLogsMetricFilter {
+    #private;
+    readonly filterName: string;
+    readonly logGroupName: string;
+    readonly filterPatternText: string;
+    readonly transformations: readonly SimLogsMetricTransformation[];
+    readonly creationTime: number;
+    constructor(properties: SimLogsMetricFilterProperties);
+    /**
+     * Whether this filter matches an event's message.
+     */
+    matches(message: string): boolean;
+    /**
+     * The datapoints a batch of log events publishes through this filter.
+     *
+     * A matching event publishes one datapoint per transformation, stamped with
+     * the instant CloudWatch Logs took it.
+     *
+     * A default value is published once for a period that took events and
+     * matched none of them, rather than once per event that missed. That is what
+     * real CloudWatch Logs reports: a minute with two records and one match
+     * counts one, and a minute with two records and no match reports the default
+     * once. Publishing per event would inflate `SampleCount` and change what an
+     * alarm over the metric decides.
+     */
+    datapoints(events: readonly SimLogsStoredEvent[]): readonly SimLogsMetricDatapoint[];
+    /**
+     * What one period of events publishes.
+     */
+    private periodDatapoints;
+}
+export {};

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

@@ -0,0 +1,95 @@
+import { SimLogsFilterPattern } from "../event/sim-logs-filter-pattern.js";
+/**
+ * How long a metric filter's aggregation period is.
+ *
+ * Real CloudWatch Logs aggregates and reports a filter's metric every minute,
+ * and the default value is what it reports for a minute that took log events
+ * and matched none of them.
+ */
+const periodMilliseconds = 60_000;
+/**
+ * One metric filter on a log group.
+ *
+ * The pattern is compiled once, when the filter is put, the way a subscription
+ * filter's is. A pattern this simulator cannot read is refused there rather
+ * than on the first event that happens to arrive.
+ */
+export class SimLogsMetricFilter {
+    filterName;
+    logGroupName;
+    filterPatternText;
+    transformations;
+    creationTime;
+    #pattern;
+    /**
+     * The most recent period this filter matched something in.
+     *
+     * One period is remembered rather than all of them, so a filter cannot grow
+     * without bound over a long run. It is what stops a second write in a minute
+     * a match already landed in from publishing a default value over the top.
+     */
+    #matchedPeriod;
+    constructor(properties) {
+        this.filterName = properties.filterName;
+        this.logGroupName = properties.logGroupName;
+        this.filterPatternText = properties.filterPattern ?? "";
+        this.transformations = properties.transformations;
+        this.creationTime = properties.creationTime;
+        this.#pattern = new SimLogsFilterPattern(properties.filterPattern);
+    }
+    /**
+     * Whether this filter matches an event's message.
+     */
+    matches(message) {
+        return this.#pattern.matches(message);
+    }
+    /**
+     * The datapoints a batch of log events publishes through this filter.
+     *
+     * A matching event publishes one datapoint per transformation, stamped with
+     * the instant CloudWatch Logs took it.
+     *
+     * A default value is published once for a period that took events and
+     * matched none of them, rather than once per event that missed. That is what
+     * real CloudWatch Logs reports: a minute with two records and one match
+     * counts one, and a minute with two records and no match reports the default
+     * once. Publishing per event would inflate `SampleCount` and change what an
+     * alarm over the metric decides.
+     */
+    datapoints(events) {
+        const published = [];
+        for (const [period, inPeriod] of byPeriod(events)) {
+            published.push(...this.periodDatapoints(period, inPeriod));
+        }
+        return published;
+    }
+    /**
+     * What one period of events publishes.
+     */
+    periodDatapoints(period, events) {
+        const matched = events.filter((event) => this.matches(event.message));
+        if (matched.length > 0) {
+            this.#matchedPeriod = period;
+            return matched.flatMap((event) => this.transformations.map((transformation) => transformation.matched(event.ingestionTime)));
+        }
+        if (this.#matchedPeriod === period) {
+            return [];
+        }
+        return this.transformations
+            .map((transformation) => transformation.unmatched(period))
+            .filter((datapoint) => datapoint !== undefined);
+    }
+}
+/**
+ * A batch's events grouped into the aggregation periods they were taken in.
+ */
+function byPeriod(events) {
+    const grouped = new Map();
+    for (const event of events) {
+        const period = Math.floor(event.ingestionTime / periodMilliseconds) * periodMilliseconds;
+        const inPeriod = grouped.get(period) ?? [];
+        inPeriod.push(event);
+        grouped.set(period, inPeriod);
+    }
+    return grouped;
+}

package/dist/service/logs/metric/sim-logs-metric-publication-failure.d.ts

@@ -0,0 +1,31 @@
+/**
+ * What asked for a datapoint the log group could not publish.
+ *
+ * A discriminated pair rather than a name, because a metric filter may be
+ * called anything a caller likes. A filter named after the other kind would
+ * otherwise be indistinguishable from it on the ledger.
+ */
+export type SimLogsMetricPublicationSource = {
+    readonly kind: "metricFilter";
+    readonly filterName: string;
+} | {
+    readonly kind: "embeddedMetricFormat";
+};
+/**
+ * The source of a datapoint an embedded metric document asked for.
+ */
+export declare const simLogsEmbeddedMetricSource: SimLogsMetricPublicationSource;
+/**
+ * The source of a datapoint a metric filter asked for.
+ */
+export declare function metricFilterSource(filterName: string): SimLogsMetricPublicationSource;
+/**
+ * One datapoint a log group could not turn into a metric.
+ */
+export interface SimLogsMetricPublicationFailure {
+    readonly logGroupName: string;
+    readonly source: SimLogsMetricPublicationSource;
+    readonly metricNamespace: string;
+    readonly metricName: string;
+    readonly reason: string;
+}

package/dist/service/logs/metric/sim-logs-metric-publication-failure.js

@@ -0,0 +1,12 @@
+/**
+ * The source of a datapoint an embedded metric document asked for.
+ */
+export const simLogsEmbeddedMetricSource = {
+    kind: "embeddedMetricFormat",
+};
+/**
+ * The source of a datapoint a metric filter asked for.
+ */
+export function metricFilterSource(filterName) {
+    return { kind: "metricFilter", filterName };
+}

package/dist/service/logs/metric/sim-logs-metric-publications.d.ts

@@ -0,0 +1,11 @@
+import type { SimLogsMetricDatapoint } from "./sim-logs-metric-datapoint.js";
+/**
+ * Where a log group's metric datapoints are published.
+ *
+ * A simulated CloudWatch Logs reached through a `SimAws` Account Region scope
+ * has one of these, pointing at that scope's own CloudWatch. One built on its
+ * own has none, and reads no metrics out of what is written to it.
+ */
+export interface SimLogsMetricPublications {
+    publish(datapoints: readonly SimLogsMetricDatapoint[]): Promise<void>;
+}

package/dist/service/logs/metric/sim-logs-metric-publications.js

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

package/dist/service/logs/metric/sim-logs-metric-transformation.d.ts

@@ -0,0 +1,45 @@
+import type { SimLogsMetricDatapoint, SimLogsMetricDimension } from "./sim-logs-metric-datapoint.js";
+/**
+ * How many dimensions real CloudWatch Logs allows on one transformation.
+ */
+export declare const simLogsMaximumMetricDimensions = 3;
+export interface SimLogsMetricTransformationProperties {
+    readonly metricNamespace: string;
+    readonly metricName: string;
+    readonly metricValue: string;
+    readonly defaultValue: number | undefined;
+    readonly unit: string | undefined;
+    readonly dimensions: readonly SimLogsMetricDimension[];
+}
+/**
+ * How one metric filter turns a log event into a metric datapoint.
+ *
+ * The value is read once, when the filter is put, so a value this simulator
+ * cannot produce is refused there rather than on the first event that happens
+ * to match. Real CloudWatch Logs validates a transformation at
+ * `PutMetricFilter` too.
+ */
+export declare class SimLogsMetricTransformation {
+    #private;
+    readonly metricNamespace: string;
+    readonly metricName: string;
+    readonly metricValue: string;
+    readonly defaultValue: number | undefined;
+    readonly unit: string | undefined;
+    readonly dimensions: readonly SimLogsMetricDimension[];
+    constructor(properties: SimLogsMetricTransformationProperties);
+    /**
+     * The datapoint one matching log event publishes.
+     */
+    matched(timestamp: number): SimLogsMetricDatapoint;
+    /**
+     * The datapoint one period that matched nothing publishes, where the
+     * transformation sets a default value.
+     *
+     * A transformation with no default value publishes nothing for a period it
+     * matched nothing in, which is what leaves the metric with no datapoint at
+     * all over a quiet stretch.
+     */
+    unmatched(timestamp: number): SimLogsMetricDatapoint | undefined;
+    private datapoint;
+}

package/dist/service/logs/metric/sim-logs-metric-transformation.js

@@ -0,0 +1,127 @@
+import { SimLogsInvalidParameterException, SimLogsUnsupportedOperationException, } from "../error/sim-logs.error.js";
+/**
+ * The character real CloudWatch Logs reads as naming a field of the log event
+ * rather than as part of a literal.
+ *
+ * `$1` names the first field of a space delimited pattern and `$.level` a JSON
+ * property. Both need the pattern to have been read structurally.
+ */
+const eventFieldPrefix = "$";
+/**
+ * How many dimensions real CloudWatch Logs allows on one transformation.
+ */
+export const simLogsMaximumMetricDimensions = 3;
+/**
+ * How one metric filter turns a log event into a metric datapoint.
+ *
+ * The value is read once, when the filter is put, so a value this simulator
+ * cannot produce is refused there rather than on the first event that happens
+ * to match. Real CloudWatch Logs validates a transformation at
+ * `PutMetricFilter` too.
+ */
+export class SimLogsMetricTransformation {
+    metricNamespace;
+    metricName;
+    metricValue;
+    defaultValue;
+    unit;
+    dimensions;
+    #matchedValue;
+    constructor(properties) {
+        this.metricNamespace = properties.metricNamespace;
+        this.metricName = properties.metricName;
+        this.metricValue = properties.metricValue;
+        this.defaultValue = properties.defaultValue;
+        this.unit = properties.unit;
+        this.dimensions = refuseFieldDimensions(properties.dimensions);
+        this.#matchedValue = literalMetricValue(properties.metricValue);
+        refuseDefaultValueWithDimensions(properties);
+    }
+    /**
+     * The datapoint one matching log event publishes.
+     */
+    matched(timestamp) {
+        return this.datapoint(this.#matchedValue, timestamp);
+    }
+    /**
+     * The datapoint one period that matched nothing publishes, where the
+     * transformation sets a default value.
+     *
+     * A transformation with no default value publishes nothing for a period it
+     * matched nothing in, which is what leaves the metric with no datapoint at
+     * all over a quiet stretch.
+     */
+    unmatched(timestamp) {
+        return this.defaultValue === undefined
+            ? undefined
+            : this.datapoint(this.defaultValue, timestamp);
+    }
+    datapoint(value, timestamp) {
+        return {
+            namespace: this.metricNamespace,
+            metricName: this.metricName,
+            value,
+            timestamp,
+            unit: this.unit,
+            dimensions: this.dimensions,
+        };
+    }
+}
+/**
+ * Read a metric value this simulation can publish.
+ *
+ * Real CloudWatch Logs takes either a number or a reference to a field of the
+ * matched event. A field reference needs the pattern to have been read
+ * structurally, and `SimLogsFilterPattern` refuses both structured syntaxes,
+ * so a filter naming one is refused here rather than publishing a number that
+ * was never in the log line.
+ */
+function literalMetricValue(metricValue) {
+    if (metricValue.startsWith(eventFieldPrefix)) {
+        throw new SimLogsUnsupportedOperationException(`Simulated CloudWatch Logs does not support a metricValue naming a ` +
+            `field of the log event yet: ${metricValue}. Reading one needs a JSON ` +
+            `property or space delimited filter pattern, and neither is ` +
+            `simulated. A literal number publishes.`);
+    }
+    const value = Number(metricValue);
+    if (!Number.isFinite(value)) {
+        throw new SimLogsInvalidParameterException(`Invalid metric value ${metricValue}: a metricValue must be a number or ` +
+            `a reference to a field of the log event.`);
+    }
+    return value;
+}
+/**
+ * Refuse a default value on a transformation that also has dimensions.
+ *
+ * Real CloudWatch Logs allows one or the other. A metric a filter gives
+ * dimensions to cannot have a default value, because the default would have to
+ * be reported against every dimension value the filter has ever seen.
+ */
+function refuseDefaultValueWithDimensions(properties) {
+    if (properties.defaultValue !== undefined &&
+        properties.dimensions.length > 0) {
+        throw new SimLogsInvalidParameterException("A metric filter transformation carrying dimensions cannot also carry " +
+            "a defaultValue. CloudWatch Logs allows one or the other.");
+    }
+}
+/**
+ * Refuse dimensions this simulation cannot fill in.
+ *
+ * A dimension value naming a field of the event has the same problem a metric
+ * value naming one has, and a dimension quietly dropped would put the
+ * datapoint under an identity no alarm is watching.
+ */
+function refuseFieldDimensions(dimensions) {
+    if (dimensions.length > simLogsMaximumMetricDimensions) {
+        throw new SimLogsInvalidParameterException(`A metric filter transformation may have at most ` +
+            `${simLogsMaximumMetricDimensions} dimensions.`);
+    }
+    for (const dimension of dimensions) {
+        if (dimension.value.startsWith(eventFieldPrefix)) {
+            throw new SimLogsUnsupportedOperationException(`Simulated CloudWatch Logs does not support a dimension naming a ` +
+                `field of the log event yet: ${dimension.name} is ` +
+                `${dimension.value}. A literal value publishes.`);
+        }
+    }
+    return dimensions;
+}

package/dist/service/logs/sdk/sim-logs-sdk-command-router.js

@@ -54,6 +54,18 @@ export class SimLogsSdkCommandRouter {
                 "DeleteSubscriptionFilterCommand",
                 async (command, context) => await simLogs.deleteSubscriptionFilter(command, simSdkCallerOptions(context)),
             ],
+            [
+                "PutMetricFilterCommand",
+                async (command, context) => await simLogs.putMetricFilter(command, simSdkCallerOptions(context)),
+            ],
+            [
+                "DescribeMetricFiltersCommand",
+                async (command, context) => await simLogs.describeMetricFilters(command, simSdkCallerOptions(context)),
+            ],
+            [
+                "DeleteMetricFilterCommand",
+                async (command, context) => await simLogs.deleteMetricFilter(command, simSdkCallerOptions(context)),
+            ],
             [
                 "FilterLogEventsCommand",
                 async (command, context) => await simLogs.filterLogEvents(command, simSdkCallerOptions(context)),

package/dist/service/logs/sim-logs-commands.d.ts

@@ -14,10 +14,13 @@ import { SimLogsGetLogEvents } from "./command/event/sim-logs-get-log-events.js"
 import { SimLogsPutLogEvents } from "./command/event/sim-logs-put-log-events.js";
 import { SimLogsLogGroupCommands } from "./command/group/sim-logs-log-group-commands.js";
 import { SimLogsRetentionCommands } from "./command/group/sim-logs-retention-commands.js";
+import { SimLogsMetricFilterCommands } from "./command/metric/sim-logs-metric-filter-commands.js";
 import { SimLogsLogStreamCommands } from "./command/stream/sim-logs-log-stream-commands.js";
 import { SimLogsSubscriptionCommands } from "./command/subscription/sim-logs-subscription-commands.js";
 import { SimLogsLogGroupStore } from "./group/sim-logs-log-group-store.js";
 import { type SimLogsSubscriptionDestinations } from "./subscription/sim-logs-subscription-destinations.js";
+import { SimLogsMetricFanOut } from "./metric/sim-logs-metric-fan-out.js";
+import type { SimLogsMetricPublications } from "./metric/sim-logs-metric-publications.js";
 import { SimLogsSubscriptionFanOut } from "./subscription/sim-logs-subscription-fan-out.js";
 import { SimLogsServiceWriter } from "./write/sim-logs-service-writer.js";
 export interface SimLogsProperties {
@@ -36,6 +39,13 @@ export interface SimLogsProperties {
      * takes any ARN, the way it always did.
      */
     readonly deliverySourceResources?: SimLogsDeliverySourceResources;
+    /**
+     * Where a log group's metric datapoints are published. A SimLogs built on
+     * its own has no simulated CloudWatch to write into. It refuses a metric
+     * filter rather than holding one that publishes nowhere, and it reads no
+     * embedded metrics out of what is written to it.
+     */
+    readonly metricPublications?: SimLogsMetricPublications;
 }
 /**
  * The collaborators one simulated CloudWatch Logs scope is built from.
@@ -58,6 +68,8 @@ export declare class SimLogsCommands {
     readonly subscriptions: SimLogsSubscriptionCommands;
     readonly serviceWriter: SimLogsServiceWriter;
     readonly fanOut: SimLogsSubscriptionFanOut;
+    readonly metricFanOut: SimLogsMetricFanOut;
+    readonly metricFilters: SimLogsMetricFilterCommands;
     readonly deliverySourceStore: SimLogsDeliverySourceStore;
     readonly deliveryDestinationStore: SimLogsDeliveryDestinationStore;
     readonly deliveryStore: SimLogsDeliveryStore;

package/dist/service/logs/sim-logs-commands.js

@@ -14,11 +14,13 @@ import { SimLogsGetLogEvents } from "./command/event/sim-logs-get-log-events.js"
 import { SimLogsPutLogEvents } from "./command/event/sim-logs-put-log-events.js";
 import { SimLogsLogGroupCommands } from "./command/group/sim-logs-log-group-commands.js";
 import { SimLogsRetentionCommands } from "./command/group/sim-logs-retention-commands.js";
+import { SimLogsMetricFilterCommands } from "./command/metric/sim-logs-metric-filter-commands.js";
 import { SimLogsLogStreamCommands } from "./command/stream/sim-logs-log-stream-commands.js";
 import { SimLogsSubscriptionCommands } from "./command/subscription/sim-logs-subscription-commands.js";
 import { SimLogsEventIds } from "./event/sim-logs-event-ids.js";
 import { SimLogsLogGroupStore } from "./group/sim-logs-log-group-store.js";
 import { SimLogsNoSubscriptionDestinations, } from "./subscription/sim-logs-subscription-destinations.js";
+import { SimLogsMetricFanOut } from "./metric/sim-logs-metric-fan-out.js";
 import { SimLogsSubscriptionFanOut } from "./subscription/sim-logs-subscription-fan-out.js";
 import { SimLogsServiceWriter } from "./write/sim-logs-service-writer.js";
 /**
@@ -42,6 +44,8 @@ export class SimLogsCommands {
     subscriptions;
     serviceWriter;
     fanOut;
+    metricFanOut;
+    metricFilters;
     deliverySourceStore;
     deliveryDestinationStore;
     deliveryStore;
@@ -60,11 +64,16 @@ export class SimLogsCommands {
             accountRegionScope,
             background,
         });
+        const metricFanOut = new SimLogsMetricFanOut({
+            publications: properties.metricPublications,
+            background,
+        });
         this.authorizer = authorizer;
         this.accountRegionScope = accountRegionScope;
         this.background = background;
         this.groups = groups;
         this.fanOut = fanOut;
+        this.metricFanOut = metricFanOut;
         this.logGroups = new SimLogsLogGroupCommands({
             groups,
             authorizer,
@@ -82,6 +91,7 @@ export class SimLogsCommands {
             eventIds,
             clock: background,
             fanOut,
+            metricFanOut,
         });
         this.getLogEvents = new SimLogsGetLogEvents({ groups, authorizer });
         this.filterLogEvents = new SimLogsFilterLogEvents({ groups, authorizer });
@@ -91,11 +101,18 @@ export class SimLogsCommands {
             destinations: subscriptionDestinations,
             clock: background,
         });
+        this.metricFilters = new SimLogsMetricFilterCommands({
+            groups,
+            authorizer,
+            fanOut: metricFanOut,
+            clock: background,
+        });
         this.serviceWriter = new SimLogsServiceWriter({
             groups,
             eventIds,
             clock: background,
             fanOut,
+            metricFanOut,
         });
         const deliverySources = new SimLogsDeliverySourceStore();
         const deliveryDestinations = new SimLogsDeliveryDestinationStore();

package/dist/service/logs/sim-logs-metric-operations.d.ts

@@ -0,0 +1,31 @@
+import type * as simLogsCommands from "./command/sim-logs-command.types.js";
+import type { SimLogsRequestOptions } from "./command/sim-logs-request-options.js";
+import type { SimLogsMetricPublicationFailure } from "./metric/sim-logs-metric-publication-failure.js";
+import { SimLogsDeliveryOperations } from "./sim-logs-delivery-operations.js";
+import type { SimLogsCommands } from "./sim-logs-commands.js";
+/**
+ * The metric commands of the simulated CloudWatch Logs facade.
+ *
+ * They sit here for the reason the delivery commands do. SimLogs grows by one
+ * delegating method per simulated operation and is at the length this codebase
+ * allows. These belong together as the half of CloudWatch Logs that turns what
+ * is written into CloudWatch metrics.
+ */
+export declare abstract class SimLogsMetricOperations extends SimLogsDeliveryOperations {
+    protected abstract readonly commands: SimLogsCommands;
+    /**
+     * Every metric publication this scope could not make, whether a metric
+     * filter or an embedded metric document asked for it.
+     *
+     * A failed publication is invisible in an account, where it becomes a metric
+     * nobody is watching. Keeping it is what lets a test find out that the
+     * metrics it set up never wrote a datapoint.
+     */
+    get metricPublicationFailures(): readonly SimLogsMetricPublicationFailure[];
+    /** Handle a PutMetricFilter Command from the SDK. */
+    putMetricFilter(command: simLogsCommands.SimPutMetricFilterCommand, options?: SimLogsRequestOptions): Promise<simLogsCommands.SimPutMetricFilterCommandOutput>;
+    /** Handle a DescribeMetricFilters Command from the SDK. */
+    describeMetricFilters(command: simLogsCommands.SimDescribeMetricFiltersCommand, options?: SimLogsRequestOptions): Promise<simLogsCommands.SimDescribeMetricFiltersCommandOutput>;
+    /** Handle a DeleteMetricFilter Command from the SDK. */
+    deleteMetricFilter(command: simLogsCommands.SimDeleteMetricFilterCommand, options?: SimLogsRequestOptions): Promise<simLogsCommands.SimDeleteMetricFilterCommandOutput>;
+}

package/dist/service/logs/sim-logs-metric-operations.js

@@ -0,0 +1,37 @@
+import { SimLogsDeliveryOperations } from "./sim-logs-delivery-operations.js";
+/**
+ * The metric commands of the simulated CloudWatch Logs facade.
+ *
+ * They sit here for the reason the delivery commands do. SimLogs grows by one
+ * delegating method per simulated operation and is at the length this codebase
+ * allows. These belong together as the half of CloudWatch Logs that turns what
+ * is written into CloudWatch metrics.
+ */
+export class SimLogsMetricOperations extends SimLogsDeliveryOperations {
+    /**
+     * Every metric publication this scope could not make, whether a metric
+     * filter or an embedded metric document asked for it.
+     *
+     * A failed publication is invisible in an account, where it becomes a metric
+     * nobody is watching. Keeping it is what lets a test find out that the
+     * metrics it set up never wrote a datapoint.
+     */
+    get metricPublicationFailures() {
+        return this.commands.metricFanOut.failures;
+    }
+    /** Handle a PutMetricFilter Command from the SDK. */
+    async putMetricFilter(command, options) {
+        await this.commands.background.sequence();
+        return this.commands.metricFilters.putMetricFilter(command, options);
+    }
+    /** Handle a DescribeMetricFilters Command from the SDK. */
+    async describeMetricFilters(command, options) {
+        await this.commands.background.sequence();
+        return this.commands.metricFilters.describeMetricFilters(command, options);
+    }
+    /** Handle a DeleteMetricFilter Command from the SDK. */
+    async deleteMetricFilter(command, options) {
+        await this.commands.background.sequence();
+        return this.commands.metricFilters.deleteMetricFilter(command, options);
+    }
+}

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

@@ -4,7 +4,7 @@ import type * as simLogsCommands from "./command/sim-logs-command.types.js";
 import type { SimLogsRequestOptions } from "./command/sim-logs-request-options.js";
 import type { SimLogsLogGroup } from "./group/sim-logs-log-group.js";
 import { SimLogsCommands, type SimLogsProperties } from "./sim-logs-commands.js";
-import { SimLogsDeliveryOperations } from "./sim-logs-delivery-operations.js";
+import { SimLogsMetricOperations } from "./sim-logs-metric-operations.js";
 import type { SimLogsSubscriptionFailure } from "./subscription/sim-logs-subscription-fan-out.js";
 import type { SimLogsServiceWriter } from "./write/sim-logs-service-writer.js";
 /**
@@ -20,11 +20,12 @@ import type { SimLogsServiceWriter } from "./write/sim-logs-service-writer.js";
  * an event expire, and what teams get wrong about retention is the value they
  * deployed rather than the deletion that eventually follows from it.
  *
- * The delivery operations are held apart in `SimLogsDeliveryOperations`, which
+ * The delivery and metric operations are held apart in
+ * `SimLogsDeliveryOperations` and `SimLogsMetricOperations`, which
  * this extends, because this file grows by one delegating method per simulated
  * operation and is at the length this codebase allows.
  */
-export declare class SimLogs extends SimLogsDeliveryOperations {
+export declare class SimLogs extends SimLogsMetricOperations {
     #private;
     protected readonly commands: SimLogsCommands;
     constructor(properties?: SimLogsProperties);

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

@@ -1,7 +1,7 @@
 import { SimLogsCfnResourceFactory } from "./cfn/sim-logs-cfn-resource-factory.js";
 import { SimLogsSdkCommandRouter } from "./sdk/sim-logs-sdk-command-router.js";
 import { SimLogsCommands, } from "./sim-logs-commands.js";
-import { SimLogsDeliveryOperations } from "./sim-logs-delivery-operations.js";
+import { SimLogsMetricOperations } from "./sim-logs-metric-operations.js";
 /**
  * Simulated CloudWatch Logs. Handles SDK commands. Emulates AWS behaviour and
  * state.
@@ -15,11 +15,12 @@ import { SimLogsDeliveryOperations } from "./sim-logs-delivery-operations.js";
  * an event expire, and what teams get wrong about retention is the value they
  * deployed rather than the deletion that eventually follows from it.
  *
- * The delivery operations are held apart in `SimLogsDeliveryOperations`, which
+ * The delivery and metric operations are held apart in
+ * `SimLogsDeliveryOperations` and `SimLogsMetricOperations`, which
  * this extends, because this file grows by one delegating method per simulated
  * operation and is at the length this codebase allows.
  */
-export class SimLogs extends SimLogsDeliveryOperations {
+export class SimLogs extends SimLogsMetricOperations {
     commands;
     #sdkRouter = new SimLogsSdkCommandRouter(this);
     #cfnFactory;