@digitraffic/common 2023.3.17-1 → 2023.3.21-2

package/dist/aws/infra/api/handler-factory.d.ts

@@ -1,7 +1,7 @@
 import { DtLogger } from "../../runtime/dt-logger";
 import { LambdaResponse } from "../../types/lambda-response";
-export type LoggingHandler = (method: () => Promise<LambdaResponse>, logger: DtLogger) => Promise<LambdaResponse>;
-export type ErrorHandler = (error: unknown, logger: DtLogger) => LambdaResponse;
+export declare type LoggingHandler = (method: () => Promise<LambdaResponse>, logger: DtLogger) => Promise<LambdaResponse>;
+export declare type ErrorHandler = (error: unknown, logger: DtLogger) => LambdaResponse;
 /**
  * Factory class for creating lambda-handler functions.  You can set functionality to handle logging and error-handling,
  * with the defaults:

package/dist/aws/infra/api/handler-factory.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createJsonLoggingHandler = exports.HandlerFactory = void 0;
+const utils_1 = require("../../../utils/utils");
+const functionName = (0, utils_1.getEnvVariableOrElse)("AWS_LAMBDA_FUNCTION_NAME", "test");
 /**
  * Factory class for creating lambda-handler functions.  You can set functionality to handle logging and error-handling,
  * with the defaults:
@@ -18,7 +20,7 @@ class HandlerFactory {
                 return await method();
             }
             finally {
-                console.info("method=%s.handler tookMs=%d", process.env.AWS_LAMBDA_FUNCTION_NAME, Date.now() - start);
+                console.info("method=%s.handler tookMs=%d", functionName, Date.now() - start);
             }
         };
         this.errorHandler = (error) => {
@@ -54,7 +56,10 @@ function createJsonLoggingHandler() {
             return await method();
         }
         finally {
-            logger.info({ tookMs: Date.now() - start });
+            logger.info({
+                method: `${functionName}.handler`,
+                tookMs: Date.now() - start,
+            });
         }
     };
 }

package/dist/aws/infra/api/integration.d.ts

@@ -1,7 +1,7 @@
 import { IntegrationResponse, LambdaIntegration } from "aws-cdk-lib/aws-apigateway";
 import { IFunction } from "aws-cdk-lib/aws-lambda";
 import { MediaType } from "../../types/mediatypes";
-type ParameterType = "path" | "querystring";
+declare type ParameterType = "path" | "querystring";
 interface ApiParameter {
     type: ParameterType;
     name: string;

package/dist/aws/infra/canaries/canary-parameters.d.ts

@@ -1,6 +1,6 @@
 import { Schedule } from "@aws-cdk/aws-synthetics-alpha";
 /** Optional env parameters for canary */
-type CanaryEnv = Record<string, string>;
+declare type CanaryEnv = Record<string, string>;
 export interface CanaryParameters {
     readonly name: string;
     readonly schedule?: Schedule;

package/dist/aws/infra/canaries/url-checker.d.ts

@@ -3,8 +3,8 @@ import { IncomingMessage } from "http";
 import { MediaType } from "../../types/mediatypes";
 import { FeatureCollection } from "geojson";
 export declare const API_KEY_HEADER = "x-api-key";
-type CheckerFunction = (Res: IncomingMessage) => Promise<void>;
-type JsonCheckerFunction<T> = (json: T, body: string, message: IncomingMessage) => Promise<void>;
+declare type CheckerFunction = (Res: IncomingMessage) => Promise<void>;
+declare type JsonCheckerFunction<T> = (json: T, body: string, message: IncomingMessage) => Promise<void>;
 export declare class UrlChecker {
     private readonly requestOptions;
     constructor(hostname: string, apiKey?: string);

package/dist/aws/infra/stack/lambda-configs.d.ts

@@ -3,8 +3,8 @@ import { IVpc, SubnetSelection } from "aws-cdk-lib/aws-ec2";
 import { Role } from "aws-cdk-lib/aws-iam";
 import { DigitrafficStack } from "./stack";
 import { MonitoredFunctionAlarmProps } from "./monitoredfunction";
-export type LambdaEnvironment = Record<string, string>;
-export type DBLambdaEnvironment = LambdaEnvironment & {
+export declare type LambdaEnvironment = Record<string, string>;
+export declare type DBLambdaEnvironment = LambdaEnvironment & {
     SECRET_ID?: string;
     DB_APPLICATION: string;
 };
@@ -27,7 +27,7 @@ export interface FunctionParameters {
     architecture?: Architecture;
     singleLambda?: boolean;
 }
-export type MonitoredFunctionParameters = FunctionParameters & {
+export declare type MonitoredFunctionParameters = FunctionParameters & {
     readonly durationAlarmProps?: MonitoredFunctionAlarmProps;
     readonly durationWarningProps?: MonitoredFunctionAlarmProps;
     readonly errorAlarmProps?: MonitoredFunctionAlarmProps;

package/dist/aws/infra/stack/monitoredfunction.js

@@ -11,39 +11,6 @@ const subscription_1 = require("../stack/subscription");
  * Creates a Lambda function that monitors default CloudWatch Lambda metrics with CloudWatch Alarms.
  */
 class MonitoredFunction extends aws_lambda_1.Function {
-    /**
-     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.
-     *
-     * @param stack DigitrafficStack
-     * @param id Lambda construct Id
-     * @param functionProps Lambda function properties
-     * @param props Monitored function properties
-     */
-    static create(stack, id, functionProps, props) {
-        if (props === MonitoredFunction.DISABLE_ALARMS &&
-            stack.configuration.production) {
-            throw new Error(
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            `Function ${functionProps.functionName} has DISABLE_ALARMS.  Remove before installing to production or define your own properties!`);
-        }
-        return new MonitoredFunction(stack, id, functionProps, stack.alarmTopic, stack.warningTopic, stack.configuration.production, stack.configuration.trafficType, props);
-    }
-    /**
-     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.  Generate names from given name and configuration shortName.
-     *
-     * For example, shortName FOO and given name update-things will create function FOO-UpdateThings and use code from lambda/update-things/update-things.ts method handler.
-     *
-     * @param stack DigitrafficStack
-     * @param name param-case name
-     * @param environment Lambda environment
-     * @param functionParameters Lambda function parameters
-     */
-    static createV2(stack, name, environment, functionParameters) {
-        const functionName = functionParameters?.functionName ??
-            `${stack.configuration.shortName}-${(0, change_case_1.pascalCase)(name)}`;
-        const functionProps = (0, lambda_configs_1.databaseFunctionProps)(stack, environment, functionName, name, functionParameters);
-        return MonitoredFunction.create(stack, functionName, functionProps, functionParameters);
-    }
     /**
      * @param scope Stack
      * @param id Lambda construct Id
@@ -81,6 +48,39 @@ class MonitoredFunction extends aws_lambda_1.Function {
             this.createAlarm(scope, this.metricThrottles(), "Throttles", "Throttles alarm", "Has throttled", trafficType, this.getAlarmActionForEnv(alarmSnsAction, warningSnsAction, production), 0, 1, 1, aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_THRESHOLD, props?.throttleAlarmProps);
         }
     }
+    /**
+     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.
+     *
+     * @param stack DigitrafficStack
+     * @param id Lambda construct Id
+     * @param functionProps Lambda function properties
+     * @param props Monitored function properties
+     */
+    static create(stack, id, functionProps, props) {
+        if (props === MonitoredFunction.DISABLE_ALARMS &&
+            stack.configuration.production) {
+            throw new Error(
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            `Function ${functionProps.functionName} has DISABLE_ALARMS.  Remove before installing to production or define your own properties!`);
+        }
+        return new MonitoredFunction(stack, id, functionProps, stack.alarmTopic, stack.warningTopic, stack.configuration.production, stack.configuration.trafficType, props);
+    }
+    /**
+     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.  Generate names from given name and configuration shortName.
+     *
+     * For example, shortName FOO and given name update-things will create function FOO-UpdateThings and use code from lambda/update-things/update-things.ts method handler.
+     *
+     * @param stack DigitrafficStack
+     * @param name param-case name
+     * @param environment Lambda environment
+     * @param functionParameters Lambda function parameters
+     */
+    static createV2(stack, name, environment, functionParameters) {
+        const functionName = functionParameters?.functionName ??
+            `${stack.configuration.shortName}-${(0, change_case_1.pascalCase)(name)}`;
+        const functionProps = (0, lambda_configs_1.databaseFunctionProps)(stack, environment, functionName, name, functionParameters);
+        return MonitoredFunction.create(stack, functionName, functionProps, functionParameters);
+    }
     createAlarm(stack, metric, alarmId, alarmName, alarmDescription, trafficType, alarmSnsAction, threshold, evaluationPeriods, datapointsToAlarm, comparisonOperator, alarmProps) {
         metric
             .createAlarm(stack, `${this.node.id}-${alarmId}`, {

package/dist/aws/runtime/dt-logger-default.d.ts

@@ -0,0 +1,5 @@
+import { DtLogger } from "./dt-logger";
+/**
+ * You can use this for your logging needs or create one locally and configure it as you wish.
+ */
+export declare const logger: DtLogger;

package/dist/aws/runtime/dt-logger-default.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const dt_logger_1 = require("./dt-logger");
+/**
+ * You can use this for your logging needs or create one locally and configure it as you wish.
+ */
+exports.logger = new dt_logger_1.DtLogger();
+//# sourceMappingURL=dt-logger-default.js.map

package/dist/aws/runtime/dt-logger.d.ts

@@ -1,16 +1,35 @@
 /// <reference types="node" />
 import { Writable } from "stream";
-type LOG_LEVEL = "DEBUG" | "INFO" | "ERROR";
+declare type LOG_LEVEL = "DEBUG" | "INFO" | "WARN" | "ERROR";
 export interface LoggerConfiguration {
     lambdaName?: string;
     fileName?: string;
     runTime?: string;
     writeStream?: Writable;
 }
-export type LoggableType = string | number | Record<string, unknown>;
+export interface LoggableType {
+    /** name of method logging the message */
+    method: `${string}.${string}`;
+    /** message to log, optional */
+    message?: string;
+    /** type of message, optional */
+    type?: string;
+    /** stack trace, optional */
+    stack?: string;
+    /** amount of time some operation took in milliseconds, optional */
+    tookMs?: number;
+    /** count of something, optional */
+    count?: number;
+    /** do not log your apikey! */
+    apikey?: never;
+    /** do not log your apikey! */
+    apiKey?: never;
+    /** any other loggable key */
+    [key: string]: string | number | boolean | Date | undefined;
+}
 /**
  * Helper class for json-logging.  Logged line will include
- * * log-level (see LOG_LEVEL)
+ * * log-level
  * * lambdaName (taken from process environment)
  * * runtime (taken from process environment)
  * * the actual message (as json or as string)
@@ -21,8 +40,44 @@ export declare class DtLogger {
     readonly runtime?: string;
     readonly writeStream: Writable;
     constructor(config?: LoggerConfiguration);
+    /**
+     * Log given message with level DEBUG.  This will not be forwarded to centralized logging system!.
+     *
+     * @param message anything
+     * @see log
+     */
+    debug(message: unknown): void;
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Json-object to log
+     * @see log
+     */
     info(message: LoggableType): void;
+    /**
+     * Log given message with level WARN
+     *
+     * @param message Json-object to log
+     * @see log
+     */
+    warn(message: LoggableType): void;
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Json-object to log
+     * @see log
+     */
     error(message: LoggableType): void;
+    /**
+     * Log message with given log level.  If message is a json object, it will be logged as it is and if it is a string it will be wrapped into json-element with key "message".
+     * Some metadata is also added to the message:
+     * * runtime     - can be configured with constructor or inferred from environment
+     * * lambdaName  - can be configured with constructor or inferred from environment
+     * * fileName    - can be configured with constructor
+     *
+     * @param level "DEBUG", "INFO" or "ERROR"
+     * @param message Either a string or json-object
+     */
     log(level: LOG_LEVEL, message: LoggableType): void;
 }
 export {};

package/dist/aws/runtime/dt-logger.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DtLogger = void 0;
 /**
  * Helper class for json-logging.  Logged line will include
- * * log-level (see LOG_LEVEL)
+ * * log-level
  * * lambdaName (taken from process environment)
  * * runtime (taken from process environment)
  * * the actual message (as json or as string)
@@ -16,23 +16,66 @@ class DtLogger {
         this.runtime = config?.runTime ?? process.env.AWS_EXECUTION_ENV;
         this.writeStream = config?.writeStream ?? process.stdout;
     }
+    /**
+     * Log given message with level DEBUG.  This will not be forwarded to centralized logging system!.
+     *
+     * @param message anything
+     * @see log
+     */
+    debug(message) {
+        const logMessage = {
+            message,
+            level: "DEBUG",
+            fileName: this.fileName,
+            lambdaName: this.lambdaName,
+            runtime: this.runtime,
+        };
+        this.writeStream.write(JSON.stringify(logMessage) + "\n");
+    }
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Json-object to log
+     * @see log
+     */
     info(message) {
         this.log("INFO", message);
     }
+    /**
+     * Log given message with level WARN
+     *
+     * @param message Json-object to log
+     * @see log
+     */
+    warn(message) {
+        this.log("WARN", message);
+    }
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Json-object to log
+     * @see log
+     */
     error(message) {
         this.log("ERROR", message);
     }
+    /**
+     * Log message with given log level.  If message is a json object, it will be logged as it is and if it is a string it will be wrapped into json-element with key "message".
+     * Some metadata is also added to the message:
+     * * runtime     - can be configured with constructor or inferred from environment
+     * * lambdaName  - can be configured with constructor or inferred from environment
+     * * fileName    - can be configured with constructor
+     *
+     * @param level "DEBUG", "INFO" or "ERROR"
+     * @param message Either a string or json-object
+     */
     log(level, message) {
-        // put string/number messages into message object
-        const actualMessage = typeof message == "object" ? message : { message: message };
         const logMessage = {
-            ...actualMessage,
-            ...{
-                level,
-                fileName: this.fileName,
-                lambdaName: this.lambdaName,
-                runtime: this.runtime,
-            },
+            ...message,
+            level,
+            fileName: message.fileName ?? this.fileName,
+            lambdaName: this.lambdaName,
+            runtime: this.runtime,
         };
         this.writeStream.write(JSON.stringify(logMessage) + "\n");
     }

package/dist/aws/runtime/secrets/dbsecret.d.ts

@@ -11,6 +11,6 @@ export declare enum RdsSecretKey {
     host = "host",
     ro_host = "ro_host"
 }
-export type RdsProxySecret = Record<RdsProxySecretKey, string>;
-export type RdsSecret = Record<RdsSecretKey, string>;
+export declare type RdsProxySecret = Record<RdsProxySecretKey, string>;
+export declare type RdsSecret = Record<RdsSecretKey, string>;
 export declare function checkExpectedSecretKeys<Secret extends GenericSecret>(keys: string[], secret: Secret): void;

package/dist/aws/runtime/secrets/secret.d.ts

@@ -1,2 +1,2 @@
-export type GenericSecret = Record<string, string>;
+export declare type GenericSecret = Record<string, string>;
 export declare function getSecret<Secret>(secretId: string, prefix?: string): Promise<Secret>;

package/dist/database/database.d.ts

@@ -6,8 +6,8 @@ export declare enum DatabaseEnvironmentKeys {
     DB_RO_URI = "DB_RO_URI",
     DB_APPLICATION = "DB_APPLICATION"
 }
-export type DTDatabase = IDatabase<unknown>;
-export type DTTransaction = ITask<unknown>;
+export declare type DTDatabase = IDatabase<unknown>;
+export declare type DTTransaction = ITask<unknown>;
 /**
  * Creates a non-pooling database connection primarily used by Lambdas.
  *

package/dist/test/asserter.d.ts

@@ -1,7 +1,7 @@
 /**
  * A simple asserter-class for writing canaries without dependency to testing-libraries.
  */
-type AssertedValue = string | number;
+declare type AssertedValue = string | number;
 export declare abstract class Asserter {
     static assertEquals(value: AssertedValue, expected: AssertedValue): void;
     static assertTrue(value: boolean): void;

package/dist/test/httpserver.d.ts

@@ -14,4 +14,4 @@ export declare class TestHttpServer {
     close(): void;
     private debuglog;
 }
-export type ListenProperties = Record<string, (url?: string, data?: string) => string>;
+export declare type ListenProperties = Record<string, (url?: string, data?: string) => string>;

package/dist/types/either.d.ts

@@ -6,4 +6,4 @@ export interface EitherError {
     result: "error";
     message: string;
 }
-export type Either<T> = EitherOk<T> | EitherError;
+export declare type Either<T> = EitherOk<T> | EitherError;

package/dist/types/urn.d.ts

@@ -1 +1 @@
-export type URN<Namespace extends string, NamespaceSpecificString extends string = ""> = `urn:${Namespace}:${NamespaceSpecificString}`;
+export declare type URN<Namespace extends string, NamespaceSpecificString extends string = ""> = `urn:${Namespace}:${NamespaceSpecificString}`;

package/dist/utils/logging.d.ts

@@ -0,0 +1,4 @@
+import { AxiosError } from "axios";
+import { DtLogger } from "../aws/runtime/dt-logger";
+export declare function logException(logger: DtLogger, error: Error | string, includeStack?: boolean): void;
+export declare function logException(logger: DtLogger, error: AxiosError): void;

package/dist/utils/logging.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logException = void 0;
+const axios_1 = require("axios");
+const utils_1 = require("./utils");
+const functionName = (0, utils_1.getEnvVariableOrElse)("AWS_LAMBDA_FUNCTION_NAME", "test");
+/**
+ * Log given exception with level ERROR to given logger.
+ *
+ * Supports AxiosError, Error and string
+ *
+ * @param logger DtLogger to use
+ * @param error AxiosError, Error or string to log
+ * @param includeStack Include stack in the message, default false
+ * @see log
+ */
+function logException(logger, error, includeStack = false) {
+    const message = error instanceof Error ? error.message : error;
+    const stack = error instanceof Error && includeStack ? error.stack : undefined;
+    const code = error instanceof axios_1.AxiosError ? error.code : undefined;
+    logger.error({
+        type: "Error",
+        method: `${functionName}.logException`,
+        message,
+        code,
+        stack,
+    });
+}
+exports.logException = logException;
+//# sourceMappingURL=logging.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitraffic/common",
-  "version": "2023.3.17-1",
+  "version": "2023.3.21-2",
   "description": "",
   "repository": {
     "type": "git",
@@ -45,7 +45,7 @@
     "axios": "^1.2.6",
     "change-case": "^4.1.2",
     "constructs": "^10.1.222",
-    "eslint": "^8.34.0",
+    "eslint": "~8.34.0",
     "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-deprecation": "1.3.3",
     "geojson-validation": "^1.0.2",
@@ -62,7 +62,7 @@
     "rimraf": "^4.1.0",
     "sinon": "^15.0.1",
     "ts-jest": "^29.0.5",
-    "typescript": "^4.9.5"
+    "typescript": "~4.8.4"
   },
   "externals": [
     "aws-sdk",
@@ -75,6 +75,7 @@
     "build": "tsc",
     "lint": "eslint --cache .",
     "eslint-report": "eslint . --format html",
+    "ci:eslint-report": "eslint . --format html -o report.html",
     "clean": "rimraf dist output",
     "test": "jest --detectOpenHandles --forceExit --coverage --coverageDirectory=output/coverage/jest"
   }

package/src/aws/infra/api/handler-factory.ts

@@ -1,3 +1,4 @@
+import { getEnvVariableOrElse } from "../../../utils/utils";
 import { DtLogger } from "../../runtime/dt-logger";
 import { LambdaResponse } from "../../types/lambda-response";
 
@@ -8,6 +9,8 @@ export type LoggingHandler = (
 
 export type ErrorHandler = (error: unknown, logger: DtLogger) => LambdaResponse;
 
+const functionName = getEnvVariableOrElse("AWS_LAMBDA_FUNCTION_NAME", "test");
+
 /**
  * Factory class for creating lambda-handler functions.  You can set functionality to handle logging and error-handling,
  * with the defaults:
@@ -30,7 +33,7 @@ export class HandlerFactory {
             } finally {
                 console.info(
                     "method=%s.handler tookMs=%d",
-                    process.env.AWS_LAMBDA_FUNCTION_NAME,
+                    functionName,
                     Date.now() - start
                 );
             }
@@ -74,7 +77,10 @@ export function createJsonLoggingHandler(): LoggingHandler {
         try {
             return await method();
         } finally {
-            logger.info({ tookMs: Date.now() - start });
+            logger.info({
+                method: `${functionName}.handler`,
+                tookMs: Date.now() - start,
+            });
         }
     };
 }

package/src/aws/runtime/dt-logger-default.ts

@@ -0,0 +1,6 @@
+import { DtLogger } from "./dt-logger";
+
+/**
+ * You can use this for your logging needs or create one locally and configure it as you wish.
+ */
+export const logger = new DtLogger();

package/src/aws/runtime/dt-logger.ts

@@ -1,6 +1,6 @@
 import { Writable } from "stream";
 
-type LOG_LEVEL = "DEBUG" | "INFO" | "ERROR";
+type LOG_LEVEL = "DEBUG" | "INFO" | "WARN" | "ERROR";
 
 export interface LoggerConfiguration {
     lambdaName?: string;
@@ -9,11 +9,30 @@ export interface LoggerConfiguration {
     writeStream?: Writable;
 }
 
-export type LoggableType = string | number | Record<string, unknown>;
+export interface LoggableType {
+    /** name of method logging the message */
+    method: `${string}.${string}`;
+    /** message to log, optional */
+    message?: string;
+    /** type of message, optional */
+    type?: string;
+    /** stack trace, optional */
+    stack?: string;
+    /** amount of time some operation took in milliseconds, optional */
+    tookMs?: number;
+    /** count of something, optional */
+    count?: number;
+    /** do not log your apikey! */
+    apikey?: never;
+    /** do not log your apikey! */
+    apiKey?: never;
+    /** any other loggable key */
+    [key: string]: string | number | boolean | Date | undefined;
+}
 
 /**
  * Helper class for json-logging.  Logged line will include
- * * log-level (see LOG_LEVEL)
+ * * log-level
  * * lambdaName (taken from process environment)
  * * runtime (taken from process environment)
  * * the actual message (as json or as string)
@@ -33,27 +52,70 @@ export class DtLogger {
         this.writeStream = config?.writeStream ?? process.stdout;
     }
 
-    info(message: LoggableType) {
+    /**
+     * Log given message with level DEBUG.  This will not be forwarded to centralized logging system!.
+     *
+     * @param message anything
+     * @see log
+     */
+    debug(message: unknown): void {
+        const logMessage = {
+            message,
+            level: "DEBUG",
+            fileName: this.fileName,
+            lambdaName: this.lambdaName,
+            runtime: this.runtime,
+        };
+
+        this.writeStream.write(JSON.stringify(logMessage) + "\n");
+    }
+
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Json-object to log
+     * @see log
+     */
+    info(message: LoggableType): void {
         this.log("INFO", message);
     }
 
-    error(message: LoggableType) {
+    /**
+     * Log given message with level WARN
+     *
+     * @param message Json-object to log
+     * @see log
+     */
+    warn(message: LoggableType): void {
+        this.log("WARN", message);
+    }
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Json-object to log
+     * @see log
+     */
+    error(message: LoggableType): void {
         this.log("ERROR", message);
     }
 
-    log(level: LOG_LEVEL, message: LoggableType) {
-        // put string/number messages into message object
-        const actualMessage =
-            typeof message == "object" ? message : { message: message };
-
+    /**
+     * Log message with given log level.  If message is a json object, it will be logged as it is and if it is a string it will be wrapped into json-element with key "message".
+     * Some metadata is also added to the message:
+     * * runtime     - can be configured with constructor or inferred from environment
+     * * lambdaName  - can be configured with constructor or inferred from environment
+     * * fileName    - can be configured with constructor
+     *
+     * @param level "DEBUG", "INFO" or "ERROR"
+     * @param message Either a string or json-object
+     */
+    log(level: LOG_LEVEL, message: LoggableType): void {
         const logMessage = {
-            ...actualMessage,
-            ...{
-                level,
-                fileName: this.fileName,
-                lambdaName: this.lambdaName,
-                runtime: this.runtime,
-            },
+            ...message,
+            level,
+            fileName: message.fileName ?? this.fileName,
+            lambdaName: this.lambdaName,
+            runtime: this.runtime,
         };
 
         this.writeStream.write(JSON.stringify(logMessage) + "\n");

package/src/utils/logging.ts

@@ -0,0 +1,41 @@
+import { AxiosError } from "axios";
+import { DtLogger } from "../aws/runtime/dt-logger";
+import { getEnvVariableOrElse } from "./utils";
+
+const functionName = getEnvVariableOrElse("AWS_LAMBDA_FUNCTION_NAME", "test");
+
+export function logException(
+    logger: DtLogger,
+    error: Error | string,
+    includeStack?: boolean
+): void;
+export function logException(logger: DtLogger, error: AxiosError): void;
+
+/**
+ * Log given exception with level ERROR to given logger.
+ *
+ * Supports AxiosError, Error and string
+ *
+ * @param logger DtLogger to use
+ * @param error AxiosError, Error or string to log
+ * @param includeStack Include stack in the message, default false
+ * @see log
+ */
+export function logException(
+    logger: DtLogger,
+    error: Error | string | AxiosError,
+    includeStack = false
+) {
+    const message = error instanceof Error ? error.message : error;
+    const stack =
+        error instanceof Error && includeStack ? error.stack : undefined;
+    const code = error instanceof AxiosError ? error.code : undefined;
+
+    logger.error({
+        type: "Error",
+        method: `${functionName}.logException`,
+        message,
+        code,
+        stack,
+    });
+}