cdk-monitoring-constructs
Version:
[](https://gitpod.io/#https://github.com/cdklabs/cdk-monitoring-constructs) [](https://badge
288 lines • 44.9 kB
JavaScript
;
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.MetricFactory = exports.DefaultMetricPeriod = void 0;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const aws_cdk_lib_1 = require("aws-cdk-lib");
const aws_cloudwatch_1 = require("aws-cdk-lib/aws-cloudwatch");
const AnomalyDetectionMathExpression_1 = require("./AnomalyDetectionMathExpression");
const MetricStatistic_1 = require("./MetricStatistic");
const RateComputationMethod_1 = require("./RateComputationMethod");
/**
* The most common default metric period used at Amazon is currently 5 minutes.
*/
exports.DefaultMetricPeriod = aws_cdk_lib_1.Duration.minutes(5);
class MetricFactory {
constructor(props) {
this.globalDefaults = props?.globalDefaults ?? {};
}
/**
* Factory method that creates a metric. The metric properties will already be updated to comply with the global defaults.
*
* @param metricName metric name
* @param statistic aggregation statistic to use
* @param label metric label; if undefined, metric name is used by CloudWatch
* @param dimensionsMap additional dimensions to be added
* @param color metric color; if undefined, uses a CloudWatch provided color (preferred)
* @param namespace specify a custom namespace; if undefined, uses the global default
* @param period specify a custom period; if undefined, uses the global default
*/
createMetric(metricName, statistic, label, dimensionsMap, color, namespace, period) {
return new aws_cloudwatch_1.Metric({
statistic,
metricName,
label,
color,
dimensionsMap: dimensionsMap
? this.removeUndefinedEntries(dimensionsMap)
: undefined,
namespace: this.getNamespaceWithFallback(namespace),
period: period ?? this.globalDefaults.period ?? exports.DefaultMetricPeriod,
});
}
/**
* Factory method that creates a metric math expression. The metric properties will already be updated to comply with the global defaults.
*
* @param expression CloudWatch metric math expression (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/using-metric-math.html)
* @param usingMetrics map of metrics, where keys are expression IDs (used in the expression) and values are metrics
* @param label metric label (required, as there is no reasonable default)
* @param color metric color; if undefined, uses a CloudWatch provided color (preferred)
* @param period specify a custom period; if undefined, uses the global default
*/
createMetricMath(expression, usingMetrics, label, color, period) {
return new aws_cloudwatch_1.MathExpression({
label,
color,
expression,
usingMetrics,
period: period ?? this.globalDefaults.period ?? exports.DefaultMetricPeriod,
});
}
/**
* Factory method that creates a metric search query. The metric properties will already be updated to comply with the global defaults.
* If you want to match "any value" of a specific dimension, please use `undefined` value representation in your consumer language.
* (For example, `undefined as any as string` in TypeScript, due to JSII typing quirks.)
*
* @param query metric search query (the same as the search query prompt in CloudWatch AWS Console), it might also be empty
* @param dimensionsMap dimensions, further narrowing the search results; use `undefined` if you want to represent "any value" (in TS: `undefined as any as string`)
* @param statistic aggregation statistic to use
* @param namespace specify a custom namespace; if undefined, uses the global default
* @param label specify custom label for search metrics; default is " " as it cannot be empty string
* @param period specify a custom period; if undefined, uses the global default
*/
createMetricSearch(query, dimensionsMap, statistic, namespace, label, period) {
const finalPeriod = period ?? this.globalDefaults.period ?? exports.DefaultMetricPeriod;
const searchNamespace = this.getNamespaceWithFallback(namespace);
const namespacePlusDimensionKeys = [
searchNamespace,
...Object.keys(dimensionsMap),
].join(",");
const metricSchema = `{${namespacePlusDimensionKeys}}`;
const dimensionKeysAndValues = Object.entries(this.removeUndefinedEntries(dimensionsMap))
.map(([key, value]) => `${key}="${value}"`)
.join(" ");
const expression = `SEARCH('${metricSchema} ${dimensionKeysAndValues} ${query}', '${statistic}', ${finalPeriod.toSeconds()})`;
return new aws_cloudwatch_1.MathExpression({
expression,
// see https://github.com/aws/aws-cdk/issues/7237
usingMetrics: {},
// cannot be an empty string and undefined is no good either
label: label ?? " ",
period: finalPeriod,
});
}
/**
* Factory method that creates anomaly detection on a metric.
* Anomaly occurs whenever a metric value falls outside of a precomputed range of predicted values.
* The detection does not need any setup. The model will start learning automatically and should be ready in a few minutes.
* Usually, the anomaly detection is paired with an alarm.
* @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Anomaly_Detection.html
*
* @param metric metric to detect anomaly detection of
* @param stdev standard deviation, basically the tolerance / band thickness
* @param label metric label (required, as there is no reasonable default)
* @param color metric color; if undefined, uses a CloudWatch provided color (preferred)
* @param expressionId expression ID of the metric; uses `m1` if undefined
* @param period specify a custom period; if undefined, uses the global default
*/
createMetricAnomalyDetection(metric, stdev, label, color, expressionId, period) {
const finalExpressionId = expressionId ?? "m1";
const usingMetrics = {};
usingMetrics[finalExpressionId] = metric;
return new AnomalyDetectionMathExpression_1.AnomalyDetectionMathExpression({
label,
color,
usingMetrics,
expression: `ANOMALY_DETECTION_BAND(${finalExpressionId},${stdev})`,
period: period ?? this.globalDefaults.period ?? exports.DefaultMetricPeriod,
});
}
/**
* Adapts properties of a foreign metric (metric created outside of this metric factory) to comply with the global defaults.
* Might modify namespace and metric period.
*
* @param metric metric to be adapted
*/
adaptMetric(metric) {
return metric.with({
period: this.globalDefaults.period ?? exports.DefaultMetricPeriod,
});
}
/**
* Adapts properties of a foreign metric (metric created outside of this metric factory) to comply with the global defaults.
* Might modify namespace. Preserves metric period.
*
* @param metric metric to be adapted
*/
adaptMetricPreservingPeriod(metric) {
return metric;
}
/**
* Creates a metric math expression that multiplies the given metric by given coefficient.
* Does nothing if the multiplier is one. Preserves the metric period.
*
* @param metric metric to multiply
* @param multiplier multiplier (must be > 1)
* @param label expression label
* @param expressionId expression ID of the metric; uses `m1` if undefined
*/
multiplyMetric(metric, multiplier, label, expressionId) {
if (multiplier == 1) {
return metric;
}
else if (multiplier < 1) {
throw new Error("Multiplier must be greater than one.");
}
else {
const finalExpressionId = expressionId ?? "m1";
const usingMetrics = {};
usingMetrics[finalExpressionId] = metric;
return this.createMetricMath(`${finalExpressionId} * ${multiplier}`, usingMetrics, label, metric.color, metric.period);
}
}
/**
* Creates a metric math expression that divides the given metric by given coefficient.
* Does nothing if the divisor is one. Preserves the metric period.
*
* @param metric metric to multiply
* @param divisor divisor (must be > 1)
* @param label expression label
* @param expressionId expression ID of the metric; uses `m1` if undefined
*/
divideMetric(metric, divisor, label, expressionId) {
if (divisor == 1) {
return metric;
}
else if (divisor < 1) {
throw new Error("Divisor must be greater than one.");
}
else {
const finalExpressionId = expressionId ?? "m1";
const usingMetrics = {};
usingMetrics[finalExpressionId] = metric;
return this.createMetricMath(`${finalExpressionId} / ${divisor}`, usingMetrics, label, metric.color, metric.period);
}
}
/**
* Creates a metric math expression that computes a rate from a regular metric.
* For example, it allows you to compute rate per second (TPS), per minute, or just an average of your transactions.
*
* @param metric metric to calculate the rate from
* @param method rate computation method
* @param addStatsToLabel add detailed statistics (min, max, average) to the label
* @param expressionId expression ID of the metric; uses `m1` if undefined
* @param fillWithZeroes if TRUE, the final metric will be zero-filled (0 on no data); false if undefined
*/
toRate(metric, method, addStatsToLabel, expressionId, fillWithZeroes) {
const finalExpressionId = expressionId ?? "m1";
const labelPrefix = metric.label ?? "Rate";
const statsInLabel = [];
if (addStatsToLabel ?? false) {
statsInLabel.push("min: ${MIN}");
statsInLabel.push("max: ${MAX}");
if (method !== RateComputationMethod_1.RateComputationMethod.AVERAGE) {
// only add average if do not have it already
statsInLabel.push("avg: ${AVG}");
}
}
const finalExpressionIdZeroed = fillWithZeroes ?? false
? `FILL(${finalExpressionId},0)`
: finalExpressionId;
const labelAppendix = statsInLabel.length > 0 ? ` (${statsInLabel.join(", ")})` : "";
switch (method) {
case RateComputationMethod_1.RateComputationMethod.AVERAGE:
const avgLabel = `${labelPrefix} (avg)${labelAppendix}`;
const avgMetric = metric.with({
label: avgLabel,
statistic: MetricStatistic_1.MetricStatistic.AVERAGE,
});
if (fillWithZeroes ?? false) {
return this.createMetricMath(finalExpressionIdZeroed, { [finalExpressionId]: avgMetric }, avgLabel, avgMetric.color, avgMetric.period);
}
return avgMetric;
case RateComputationMethod_1.RateComputationMethod.PER_SECOND:
let perSecondLabel = `${labelPrefix}/s${labelAppendix}`;
if (labelPrefix === "Requests" ||
labelPrefix === "Invocations" ||
labelPrefix === "Transactions") {
// currently, kept as "TPS" to reduce number of snapshot changes
perSecondLabel = `TPS${labelAppendix}`;
}
return this.createMetricMath(`${finalExpressionIdZeroed} / PERIOD(${finalExpressionId})`, { [finalExpressionId]: metric }, perSecondLabel, metric.color, metric.period);
case RateComputationMethod_1.RateComputationMethod.PER_MINUTE:
return this.createMetricMath(`(60 * ${finalExpressionIdZeroed}) / PERIOD(${finalExpressionId})`, { [finalExpressionId]: metric }, `${labelPrefix}/m${labelAppendix}`, metric.color, metric.period);
case RateComputationMethod_1.RateComputationMethod.PER_HOUR:
return this.createMetricMath(`(3600 * ${finalExpressionIdZeroed}) / PERIOD(${finalExpressionId})`, { [finalExpressionId]: metric }, `${labelPrefix}/h${labelAppendix}`, metric.color, metric.period);
case RateComputationMethod_1.RateComputationMethod.PER_DAY:
return this.createMetricMath(`(86400 * ${finalExpressionIdZeroed}) / PERIOD(${finalExpressionId})`, { [finalExpressionId]: metric }, `${labelPrefix}/d${labelAppendix}`, metric.color, metric.period);
}
}
/**
* Returns the given namespace (if defined) or the global namespace as a fallback.
* If there is no namespace to fallback to (neither the custom or the default one), it will fail.
* @param value custom namespace
*/
getNamespaceWithFallback(value) {
const namespace = value ?? this.globalDefaults.namespace;
if (!namespace) {
throw new Error("There is no custom namespace defined. Please specify it in your factory defaults.");
}
return namespace;
}
/**
* Helper method that helps to sanitize the given expression ID and removes all invalid characters.
* Valid expression ID regexp is the following: ^[a-z][a-zA-Z0-9_]*$
* As this is just to validate a suffix and not the whole ID, we do not have to verify the first lower case letter.
* @param expressionId expression ID to sanitize
*/
sanitizeMetricExpressionIdSuffix(expressionId) {
return expressionId.replace(/[^0-9a-z_]/gi, "");
}
/**
* Merges the given additional dimensions to the given target dimension hash.
* All existing dimensions with the same key are replaced.
* @param target target dimension hash to update
* @param additionalDimensions additional dimensions
*/
addAdditionalDimensions(target, additionalDimensions) {
// Add additional dimensions in the search query
Object.keys(additionalDimensions).forEach((key) => {
target[key] = additionalDimensions[key];
});
}
/**
* Removes all entries from the given dimension hash that contain an undefined value.
* @param dimensionsMap dimensions map to update
*/
removeUndefinedEntries(dimensionsMap) {
const copy = {};
Object.entries(dimensionsMap)
.filter(([_, value]) => value !== undefined)
.forEach(([key, value]) => (copy[key] = value));
return copy;
}
}
exports.MetricFactory = MetricFactory;
_a = JSII_RTTI_SYMBOL_1;
MetricFactory[_a] = { fqn: "cdk-monitoring-constructs.MetricFactory", version: "1.21.0" };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MetricFactory.js","sourceRoot":"","sources":["MetricFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration } from \"aws-cdk-lib\";\nimport {\n  DimensionsMap,\n  IMetric,\n  MathExpression,\n  Metric,\n} from \"aws-cdk-lib/aws-cloudwatch\";\n\nimport { AnomalyDetectionMathExpression } from \"./AnomalyDetectionMathExpression\";\nimport { MetricStatistic } from \"./MetricStatistic\";\nimport { MetricWithAlarmSupport } from \"./MetricWithAlarmSupport\";\nimport { RateComputationMethod } from \"./RateComputationMethod\";\n\n/**\n * The most common default metric period used at Amazon is currently 5 minutes.\n */\nexport const DefaultMetricPeriod = Duration.minutes(5);\n\n/**\n * These are the globals used for each metric, unless there is some kind of override.\n */\nexport interface MetricFactoryDefaults {\n  /**\n   * Each metric exists in a namespace. AWS Services have their own namespace, but here you can specify your custom one.\n   */\n  readonly namespace?: string;\n\n  /**\n   * Metric period. Default value is used if not defined.\n   * @default - DefaultMetricPeriod\n   */\n  readonly period?: Duration;\n}\n\nexport interface MetricFactoryProps {\n  /**\n   * Allows you to specify the global defaults, which can be overridden in the individual metrics or alarms.\n   */\n  readonly globalDefaults?: MetricFactoryDefaults;\n}\n\nexport class MetricFactory {\n  protected readonly globalDefaults: MetricFactoryDefaults;\n\n  constructor(props?: MetricFactoryProps) {\n    this.globalDefaults = props?.globalDefaults ?? {};\n  }\n\n  /**\n   * Factory method that creates a metric. The metric properties will already be updated to comply with the global defaults.\n   *\n   * @param metricName metric name\n   * @param statistic aggregation statistic to use\n   * @param label metric label; if undefined, metric name is used by CloudWatch\n   * @param dimensionsMap additional dimensions to be added\n   * @param color metric color; if undefined, uses a CloudWatch provided color (preferred)\n   * @param namespace specify a custom namespace; if undefined, uses the global default\n   * @param period specify a custom period; if undefined, uses the global default\n   */\n  createMetric(\n    metricName: string,\n    statistic: MetricStatistic,\n    label?: string,\n    dimensionsMap?: DimensionsMap,\n    color?: string,\n    namespace?: string,\n    period?: Duration\n  ): MetricWithAlarmSupport {\n    return new Metric({\n      statistic,\n      metricName,\n      label,\n      color,\n      dimensionsMap: dimensionsMap\n        ? this.removeUndefinedEntries(dimensionsMap)\n        : undefined,\n      namespace: this.getNamespaceWithFallback(namespace),\n      period: period ?? this.globalDefaults.period ?? DefaultMetricPeriod,\n    });\n  }\n\n  /**\n   * Factory method that creates a metric math expression. The metric properties will already be updated to comply with the global defaults.\n   *\n   * @param expression CloudWatch metric math expression (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/using-metric-math.html)\n   * @param usingMetrics map of metrics, where keys are expression IDs (used in the expression) and values are metrics\n   * @param label metric label (required, as there is no reasonable default)\n   * @param color metric color; if undefined, uses a CloudWatch provided color (preferred)\n   * @param period specify a custom period; if undefined, uses the global default\n   */\n  createMetricMath(\n    expression: string,\n    usingMetrics: Record<string, IMetric>,\n    label: string,\n    color?: string,\n    period?: Duration\n  ): MetricWithAlarmSupport {\n    return new MathExpression({\n      label,\n      color,\n      expression,\n      usingMetrics,\n      period: period ?? this.globalDefaults.period ?? DefaultMetricPeriod,\n    });\n  }\n\n  /**\n   * Factory method that creates a metric search query. The metric properties will already be updated to comply with the global defaults.\n   * If you want to match \"any value\" of a specific dimension, please use `undefined` value representation in your consumer language.\n   * (For example, `undefined as any as string` in TypeScript, due to JSII typing quirks.)\n   *\n   * @param query metric search query (the same as the search query prompt in CloudWatch AWS Console), it might also be empty\n   * @param dimensionsMap dimensions, further narrowing the search results; use `undefined` if you want to represent \"any value\" (in TS: `undefined as any as string`)\n   * @param statistic aggregation statistic to use\n   * @param namespace specify a custom namespace; if undefined, uses the global default\n   * @param label specify custom label for search metrics; default is \" \" as it cannot be empty string\n   * @param period specify a custom period; if undefined, uses the global default\n   */\n  createMetricSearch(\n    query: string,\n    dimensionsMap: DimensionsMap,\n    statistic: MetricStatistic,\n    namespace?: string,\n    label?: string,\n    period?: Duration\n  ): IMetric {\n    const finalPeriod =\n      period ?? this.globalDefaults.period ?? DefaultMetricPeriod;\n    const searchNamespace = this.getNamespaceWithFallback(namespace);\n    const namespacePlusDimensionKeys = [\n      searchNamespace,\n      ...Object.keys(dimensionsMap),\n    ].join(\",\");\n    const metricSchema = `{${namespacePlusDimensionKeys}}`;\n\n    const dimensionKeysAndValues = Object.entries(\n      this.removeUndefinedEntries(dimensionsMap)\n    )\n      .map(([key, value]) => `${key}=\"${value}\"`)\n      .join(\" \");\n\n    const expression = `SEARCH('${metricSchema} ${dimensionKeysAndValues} ${query}', '${statistic}', ${finalPeriod.toSeconds()})`;\n\n    return new MathExpression({\n      expression,\n      // see https://github.com/aws/aws-cdk/issues/7237\n      usingMetrics: {},\n      // cannot be an empty string and undefined is no good either\n      label: label ?? \" \",\n      period: finalPeriod,\n    });\n  }\n\n  /**\n   * Factory method that creates anomaly detection on a metric.\n   * Anomaly occurs whenever a metric value falls outside of a precomputed range of predicted values.\n   * The detection does not need any setup. The model will start learning automatically and should be ready in a few minutes.\n   * Usually, the anomaly detection is paired with an alarm.\n   * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Anomaly_Detection.html\n   *\n   * @param metric metric to detect anomaly detection of\n   * @param stdev standard deviation, basically the tolerance / band thickness\n   * @param label metric label (required, as there is no reasonable default)\n   * @param color metric color; if undefined, uses a CloudWatch provided color (preferred)\n   * @param expressionId expression ID of the metric; uses `m1` if undefined\n   * @param period specify a custom period; if undefined, uses the global default\n   */\n  createMetricAnomalyDetection(\n    metric: IMetric,\n    stdev: number,\n    label: string,\n    color?: string,\n    expressionId?: string,\n    period?: Duration\n  ): MetricWithAlarmSupport {\n    const finalExpressionId = expressionId ?? \"m1\";\n    const usingMetrics: Record<string, IMetric> = {};\n    usingMetrics[finalExpressionId] = metric;\n    return new AnomalyDetectionMathExpression({\n      label,\n      color,\n      usingMetrics,\n      expression: `ANOMALY_DETECTION_BAND(${finalExpressionId},${stdev})`,\n      period: period ?? this.globalDefaults.period ?? DefaultMetricPeriod,\n    });\n  }\n\n  /**\n   * Adapts properties of a foreign metric (metric created outside of this metric factory) to comply with the global defaults.\n   * Might modify namespace and metric period.\n   *\n   * @param metric metric to be adapted\n   */\n  adaptMetric(metric: MetricWithAlarmSupport): MetricWithAlarmSupport {\n    return metric.with({\n      period: this.globalDefaults.period ?? DefaultMetricPeriod,\n    });\n  }\n\n  /**\n   * Adapts properties of a foreign metric (metric created outside of this metric factory) to comply with the global defaults.\n   * Might modify namespace. Preserves metric period.\n   *\n   * @param metric metric to be adapted\n   */\n  adaptMetricPreservingPeriod(\n    metric: MetricWithAlarmSupport\n  ): MetricWithAlarmSupport {\n    return metric;\n  }\n\n  /**\n   * Creates a metric math expression that multiplies the given metric by given coefficient.\n   * Does nothing if the multiplier is one. Preserves the metric period.\n   *\n   * @param metric metric to multiply\n   * @param multiplier multiplier (must be > 1)\n   * @param label expression label\n   * @param expressionId expression ID of the metric; uses `m1` if undefined\n   */\n  multiplyMetric(\n    metric: MetricWithAlarmSupport,\n    multiplier: number,\n    label: string,\n    expressionId?: string\n  ): MetricWithAlarmSupport {\n    if (multiplier == 1) {\n      return metric;\n    } else if (multiplier < 1) {\n      throw new Error(\"Multiplier must be greater than one.\");\n    } else {\n      const finalExpressionId = expressionId ?? \"m1\";\n      const usingMetrics: Record<string, IMetric> = {};\n      usingMetrics[finalExpressionId] = metric;\n      return this.createMetricMath(\n        `${finalExpressionId} * ${multiplier}`,\n        usingMetrics,\n        label,\n        metric.color,\n        metric.period\n      );\n    }\n  }\n\n  /**\n   * Creates a metric math expression that divides the given metric by given coefficient.\n   * Does nothing if the divisor is one. Preserves the metric period.\n   *\n   * @param metric metric to multiply\n   * @param divisor divisor (must be > 1)\n   * @param label expression label\n   * @param expressionId expression ID of the metric; uses `m1` if undefined\n   */\n  divideMetric(\n    metric: MetricWithAlarmSupport,\n    divisor: number,\n    label: string,\n    expressionId?: string\n  ): MetricWithAlarmSupport {\n    if (divisor == 1) {\n      return metric;\n    } else if (divisor < 1) {\n      throw new Error(\"Divisor must be greater than one.\");\n    } else {\n      const finalExpressionId = expressionId ?? \"m1\";\n      const usingMetrics: Record<string, IMetric> = {};\n      usingMetrics[finalExpressionId] = metric;\n      return this.createMetricMath(\n        `${finalExpressionId} / ${divisor}`,\n        usingMetrics,\n        label,\n        metric.color,\n        metric.period\n      );\n    }\n  }\n\n  /**\n   * Creates a metric math expression that computes a rate from a regular metric.\n   * For example, it allows you to compute rate per second (TPS), per minute, or just an average of your transactions.\n   *\n   * @param metric metric to calculate the rate from\n   * @param method rate computation method\n   * @param addStatsToLabel add detailed statistics (min, max, average) to the label\n   * @param expressionId expression ID of the metric; uses `m1` if undefined\n   * @param fillWithZeroes if TRUE, the final metric will be zero-filled (0 on no data); false if undefined\n   */\n  toRate(\n    metric: MetricWithAlarmSupport,\n    method: RateComputationMethod,\n    addStatsToLabel?: boolean,\n    expressionId?: string,\n    fillWithZeroes?: boolean\n  ): MetricWithAlarmSupport {\n    const finalExpressionId = expressionId ?? \"m1\";\n    const labelPrefix = metric.label ?? \"Rate\";\n\n    const statsInLabel: string[] = [];\n    if (addStatsToLabel ?? false) {\n      statsInLabel.push(\"min: ${MIN}\");\n      statsInLabel.push(\"max: ${MAX}\");\n      if (method !== RateComputationMethod.AVERAGE) {\n        // only add average if do not have it already\n        statsInLabel.push(\"avg: ${AVG}\");\n      }\n    }\n\n    const finalExpressionIdZeroed =\n      fillWithZeroes ?? false\n        ? `FILL(${finalExpressionId},0)`\n        : finalExpressionId;\n    const labelAppendix =\n      statsInLabel.length > 0 ? ` (${statsInLabel.join(\", \")})` : \"\";\n\n    switch (method) {\n      case RateComputationMethod.AVERAGE:\n        const avgLabel = `${labelPrefix} (avg)${labelAppendix}`;\n        const avgMetric = metric.with({\n          label: avgLabel,\n          statistic: MetricStatistic.AVERAGE,\n        });\n        if (fillWithZeroes ?? false) {\n          return this.createMetricMath(\n            finalExpressionIdZeroed,\n            { [finalExpressionId]: avgMetric },\n            avgLabel,\n            avgMetric.color,\n            avgMetric.period\n          );\n        }\n        return avgMetric;\n      case RateComputationMethod.PER_SECOND:\n        let perSecondLabel = `${labelPrefix}/s${labelAppendix}`;\n        if (\n          labelPrefix === \"Requests\" ||\n          labelPrefix === \"Invocations\" ||\n          labelPrefix === \"Transactions\"\n        ) {\n          // currently, kept as \"TPS\" to reduce number of snapshot changes\n          perSecondLabel = `TPS${labelAppendix}`;\n        }\n        return this.createMetricMath(\n          `${finalExpressionIdZeroed} / PERIOD(${finalExpressionId})`,\n          { [finalExpressionId]: metric },\n          perSecondLabel,\n          metric.color,\n          metric.period\n        );\n      case RateComputationMethod.PER_MINUTE:\n        return this.createMetricMath(\n          `(60 * ${finalExpressionIdZeroed}) / PERIOD(${finalExpressionId})`,\n          { [finalExpressionId]: metric },\n          `${labelPrefix}/m${labelAppendix}`,\n          metric.color,\n          metric.period\n        );\n      case RateComputationMethod.PER_HOUR:\n        return this.createMetricMath(\n          `(3600 * ${finalExpressionIdZeroed}) / PERIOD(${finalExpressionId})`,\n          { [finalExpressionId]: metric },\n          `${labelPrefix}/h${labelAppendix}`,\n          metric.color,\n          metric.period\n        );\n      case RateComputationMethod.PER_DAY:\n        return this.createMetricMath(\n          `(86400 * ${finalExpressionIdZeroed}) / PERIOD(${finalExpressionId})`,\n          { [finalExpressionId]: metric },\n          `${labelPrefix}/d${labelAppendix}`,\n          metric.color,\n          metric.period\n        );\n    }\n  }\n\n  /**\n   * Returns the given namespace (if defined) or the global namespace as a fallback.\n   * If there is no namespace to fallback to (neither the custom or the default one), it will fail.\n   * @param value custom namespace\n   */\n  getNamespaceWithFallback(value?: string) {\n    const namespace = value ?? this.globalDefaults.namespace;\n    if (!namespace) {\n      throw new Error(\n        \"There is no custom namespace defined. Please specify it in your factory defaults.\"\n      );\n    }\n    return namespace;\n  }\n\n  /**\n   * Helper method that helps to sanitize the given expression ID and removes all invalid characters.\n   * Valid expression ID regexp is the following: ^[a-z][a-zA-Z0-9_]*$\n   * As this is just to validate a suffix and not the whole ID, we do not have to verify the first lower case letter.\n   * @param expressionId expression ID to sanitize\n   */\n  sanitizeMetricExpressionIdSuffix(expressionId: string) {\n    return expressionId.replace(/[^0-9a-z_]/gi, \"\");\n  }\n\n  /**\n   * Merges the given additional dimensions to the given target dimension hash.\n   * All existing dimensions with the same key are replaced.\n   * @param target target dimension hash to update\n   * @param additionalDimensions additional dimensions\n   */\n  addAdditionalDimensions(\n    target: DimensionsMap,\n    additionalDimensions: DimensionsMap\n  ) {\n    // Add additional dimensions in the search query\n    Object.keys(additionalDimensions).forEach((key) => {\n      target[key] = additionalDimensions[key];\n    });\n  }\n\n  /**\n   * Removes all entries from the given dimension hash that contain an undefined value.\n   * @param dimensionsMap dimensions map to update\n   */\n  private removeUndefinedEntries(dimensionsMap: DimensionsMap) {\n    const copy: DimensionsMap = {};\n\n    Object.entries(dimensionsMap)\n      .filter(([_, value]) => value !== undefined)\n      .forEach(([key, value]) => (copy[key] = value));\n\n    return copy;\n  }\n}\n"]}