chore(metrics): lint changes

Author: saragerion

packages/metrics/src/Metrics.ts

@@ -149,24 +149,13 @@ class Metrics implements MetricsInterface {
     if (this.isSingleMetric) this.purgeStoredMetrics();
   }
 
-  public clearDefaultDimensions(): void {
-    this.defaultDimensions = {};
-  }
-
-  public clearDimensions(): void {
-    this.dimensions = {};
-  }
-
-  public clearMetadata(): void {
-    this.metadata = {};
-  }
-
-  public clearMetrics(): void {
-    this.storedMetrics = {};
-  }
-
   /**
-   * Throw an Error if the metrics buffer is empty.
+   * Create a singleMetric to capture cold start.
+   * If it's a cold start invocation, this feature will:
+   *   * Create a separate EMF blob solely containing a metric named ColdStart
+   *   * Add function_name and service dimensions
+   *
+   * This has the advantage of keeping cold start metric separate from your application metrics, where you might have unrelated dimensions.
    *
    * @example
    *
@@ -177,13 +166,38 @@ class Metrics implements MetricsInterface {
    * const metrics = new Metrics({namespace:"ServerlessAirline", service:"orders"});
    *
    * export const handler = async (event: any, context: Context) => {
-   *     metrics.raiseOnEmptyMetrics();
-   *     metrics.purgeStoredMetrics(); // will throw since no metrics added.
+   *     metrics.captureColdStartMetric();
    * }
    * ```
    */
-  public raiseOnEmptyMetrics(): void {
-    this.shouldRaiseOnEmptyMetrics = true;
+  public captureColdStartMetric(): void {
+    if (!this.isColdStart) return;
+    this.isColdStart = false;
+    const singleMetric = this.singleMetric();
+
+    if (this.dimensions.service) {
+      singleMetric.addDimension('service', this.dimensions.service);
+    }
+    if (this.functionName != null) {
+      singleMetric.addDimension('function_name', this.functionName);
+    }
+    singleMetric.addMetric('ColdStart', MetricUnits.Count, 1);
+  }
+
+  public clearDefaultDimensions(): void {
+    this.defaultDimensions = {};
+  }
+
+  public clearDimensions(): void {
+    this.dimensions = {};
+  }
+
+  public clearMetadata(): void {
+    this.metadata = {};
+  }
+
+  public clearMetrics(): void {
+    this.storedMetrics = {};
   }
 
   /**
@@ -228,7 +242,7 @@ class Metrics implements MetricsInterface {
         if (captureColdStartMetric) this.captureColdStartMetric();
         try {
           const result = originalMethod?.apply(this, [ event, context, callback ]);
-          
+
           return result;
         } finally {
           this.purgeStoredMetrics();
@@ -259,6 +273,27 @@ class Metrics implements MetricsInterface {
     this.storedMetrics = {};
   }
 
+  /**
+   * Throw an Error if the metrics buffer is empty.
+   *
+   * @example
+   *
+   * ```typescript
+   * import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics';
+   * import { Context } from 'aws-lambda';
+   *
+   * const metrics = new Metrics({namespace:"ServerlessAirline", service:"orders"});
+   *
+   * export const handler = async (event: any, context: Context) => {
+   *     metrics.raiseOnEmptyMetrics();
+   *     metrics.purgeStoredMetrics(); // will throw since no metrics added.
+   * }
+   * ```
+   */
+  public raiseOnEmptyMetrics(): void {
+    this.shouldRaiseOnEmptyMetrics = true;
+  }
+
   /**
    * Function to create the right object compliant with Cloudwatch EMF (Event Metric Format).
    * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format_Specification.html for more details
@@ -315,6 +350,10 @@ class Metrics implements MetricsInterface {
     this.defaultDimensions = targetDimensions;
   }
 
+  public setFunctionName(value: string): void {
+    this.functionName = value;
+  }
+
   /**
    * CloudWatch EMF uses the same dimensions across all your metrics. Use singleMetric if you have a metric that should have different dimensions.
    *
@@ -339,45 +378,6 @@ class Metrics implements MetricsInterface {
     });
   }
 
-  /**
-   * Create a singleMetric to capture cold start.
-   * If it's a cold start invocation, this feature will:
-   *   * Create a separate EMF blob solely containing a metric named ColdStart
-   *   * Add function_name and service dimensions
-   *
-   * This has the advantage of keeping cold start metric separate from your application metrics, where you might have unrelated dimensions.
-   *
-   * @example
-   *
-   * ```typescript
-   * import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics';
-   * import { Context } from 'aws-lambda';
-   *
-   * const metrics = new Metrics({namespace:"ServerlessAirline", service:"orders"});
-   *
-   * export const handler = async (event: any, context: Context) => {
-   *     metrics.captureColdStartMetric();
-   * }
-   * ```
-   */
-  public captureColdStartMetric(): void {
-    if (!this.isColdStart) return;
-    this.isColdStart = false;
-    const singleMetric = this.singleMetric();
-
-    if (this.dimensions.service) {
-      singleMetric.addDimension('service', this.dimensions.service);
-    }
-    if (this.functionName != null) {
-      singleMetric.addDimension('function_name', this.functionName);
-    }
-    singleMetric.addMetric('ColdStart', MetricUnits.Count, 1);
-  }
-
-  public setFunctionName(value: string): void {
-    this.functionName = value;
-  }
-
   private getCurrentDimensionsCount(): number {
     return Object.keys(this.dimensions).length + Object.keys(this.defaultDimensions).length;
   }

packages/metrics/src/config/ConfigService.ts

@@ -2,9 +2,9 @@ import { ConfigServiceInterface } from '.';
 
 abstract class ConfigService implements ConfigServiceInterface {
 
-  abstract get(name: string): string;
-  abstract getNamespace(): string;
-  abstract getService(): string;
+  public abstract get(name: string): string;
+  public abstract getNamespace(): string;
+  public abstract getService(): string;
 
 }
 

packages/metrics/src/config/ConfigServiceInterface.ts

@@ -1,8 +1,8 @@
 interface ConfigServiceInterface {
 
-  get?(name: string): string;
-  getNamespace(): string;
-  getService(): string;
+  get?(name: string): string
+  getNamespace(): string
+  getService(): string
 
 }
 

packages/metrics/src/types/Metrics.ts

@@ -20,7 +20,7 @@ type EmfOutput = {
     CloudWatchMetrics: {
       Namespace: string
       Dimensions: [string[]]
-      Metrics: { Name: string; Unit: MetricUnit }[];
+      Metrics: { Name: string; Unit: MetricUnit }[]
     }[]
   }
 };

packages/metrics/tests/unit/Metrics.test.ts

@@ -1,5 +1,7 @@
 import { ContextExamples as dummyContext, LambdaInterface } from '@aws-lambda-powertools/commons';
 import { Context, Callback } from 'aws-lambda';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
 import * as dummyEvent from '../../../../tests/resources/events/custom/hello-world.json';
 import { Metrics, MetricUnits } from '../../src/';
 import { populateEnvironmentVariables } from '../helpers';
@@ -227,7 +229,7 @@ describe('Class: Metrics', () => {
     test('Cold start metric should only be written out once and flushed automatically', async () => {
       const metrics = new Metrics({ namespace: 'test' });
 
-      const handler = async (event: any, context: Context) => {
+      const handler = async (_event, _context): Promise<void> => {
         // Should generate only one log
         metrics.captureColdStartMetric();
       };
@@ -361,7 +363,7 @@ describe('Class: Metrics', () => {
       expect.assertions(1);
 
       const metrics = new Metrics({ namespace: 'test' });
-      const handler = async (event: any, context: Context) => {
+      const handler = async (_event, _context): Promise<void> => {
         metrics.raiseOnEmptyMetrics();
         // Logic goes here
         metrics.purgeStoredMetrics();