@alliander-opensource/aws-jwt-sts 0.3.4 → 0.3.6

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/Logger.js

@@ -1,16 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
 const node_console_1 = require("node:console");
 const node_crypto_1 = require("node:crypto");
 const commons_1 = require("@aws-lambda-powertools/commons");
-const lodash_merge_1 = __importDefault(require("lodash.merge"));
-const EnvironmentVariablesService_js_1 = require("./config/EnvironmentVariablesService.js");
+const env_1 = require("@aws-lambda-powertools/commons/utils/env");
 const constants_js_1 = require("./constants.js");
 const PowertoolsLogFormatter_js_1 = require("./formatter/PowertoolsLogFormatter.js");
+const LogAttributesStore_js_1 = require("./LogAttributesStore.js");
 const logBuffer_js_1 = require("./logBuffer.js");
 /**
  * The Logger utility provides an opinionated logger with output structured as JSON for AWS Lambda.
@@ -70,7 +67,7 @@ const logBuffer_js_1 = require("./logBuffer.js");
  *
  * If instead you use Middy.js middlewares, you use the {@link "middleware/middy".injectLambdaContext | `injectLambdaContext()`} middleware.
  *
- * @see https://docs.powertools.aws.dev/lambda/typescript/latest/core/logger/
+ * @see https://docs.aws.amazon.com/powertools/typescript/latest/core/logger/
  */
 class Logger extends commons_1.Utility {
     /**
@@ -87,10 +84,6 @@ class Logger extends commons_1.Utility {
      * Custom config service instance used to configure the logger.
      */
     customConfigService;
-    /**
-     * Environment variables service instance used to fetch environment variables.
-     */
-    envVarsService = new EnvironmentVariablesService_js_1.EnvironmentVariablesService();
     /**
      * Whether to print the Lambda invocation event in the logs.
      */
@@ -114,10 +107,6 @@ class Logger extends commons_1.Utility {
      * environment variable AWS_LAMBDA_LOG_LEVEL is set
      */
     #alcLogLevel;
-    /**
-     * Persistent log attributes that will be logged in all log items.
-     */
-    persistentLogAttributes = {};
     /**
      * Standard attributes managed by Powertools that will be logged in all log items.
      */
@@ -125,9 +114,9 @@ class Logger extends commons_1.Utility {
         sampleRateValue: 0,
     };
     /**
-     * Temporary log attributes that can be appended with `appendKeys()` method.
+     * Store for managing temporary and persistent log attributes.
      */
-    temporaryLogAttributes = {};
+    #attributesStore = new LogAttributesStore_js_1.LogAttributesStore();
     /**
      * Buffer used to store logs until the logger is initialized.
      *
@@ -139,13 +128,6 @@ class Logger extends commons_1.Utility {
      * Flag used to determine if the logger is initialized.
      */
     #isInitialized = false;
-    /**
-     * Map used to hold the list of keys and their type.
-     *
-     * Because keys of different types can be overwritten, we keep a list of keys that were added and their last
-     * type. We then use this map at log preparation time to pick the last one.
-     */
-    #keys = new Map();
     /**
      * This is the initial log leval as set during the initialization of the logger.
      *
@@ -204,7 +186,7 @@ class Logger extends commons_1.Utility {
     constructor(options = {}) {
         super();
         const { customConfigService, ...rest } = options;
-        this.setCustomConfigService(customConfigService);
+        this.customConfigService = customConfigService;
         // all logs are buffered until the logger is initialized
         this.setOptions(rest);
         this.#isInitialized = true;
@@ -229,6 +211,7 @@ class Logger extends commons_1.Utility {
                 memoryLimitInMB: context.memoryLimitInMB,
                 functionName: context.functionName,
                 functionVersion: context.functionVersion,
+                tenantId: context.tenantId,
             },
         });
     }
@@ -267,17 +250,24 @@ class Logger extends commons_1.Utility {
      * @param options - The options to initialize the child logger with.
      */
     createChild(options = {}) {
+        // Determine proper key to use when merging persistent options with
+        // parent. Preferring persistentKeys over persistentLogAttributes.
+        // NOTE: when both are passed in for options warning message in
+        // setOptions is still triggered
+        const persistentKeyName = 'persistentLogAttributes' in options && !('persistentKeys' in options)
+            ? 'persistentLogAttributes'
+            : 'persistentKeys';
         const childLogger = this.createLogger(
         // Merge parent logger options with options passed to createChild,
         // the latter having precedence.
-        (0, lodash_merge_1.default)({}, {
+        (0, commons_1.deepMerge)({}, {
             logLevel: this.getLevelName(),
             serviceName: this.powertoolsLogData.serviceName,
             sampleRateValue: this.#debugLogSampling.sampleRateValue,
             logFormatter: this.getLogFormatter(),
             customConfigService: this.getCustomConfigService(),
             environment: this.powertoolsLogData.environment,
-            persistentLogAttributes: this.persistentLogAttributes,
+            [persistentKeyName]: this.#attributesStore.getPersistentAttributes(),
             jsonReplacerFn: this.#jsonReplacerFn,
             correlationIdSearchFn: this.#correlationIdSearchFn,
             ...(this.#bufferConfig.enabled && {
@@ -290,8 +280,9 @@ class Logger extends commons_1.Utility {
         }, options));
         if (this.powertoolsLogData.lambdaContext)
             childLogger.addContext(this.powertoolsLogData.lambdaContext);
-        if (this.temporaryLogAttributes) {
-            childLogger.appendKeys(this.temporaryLogAttributes);
+        const temporaryAttributes = this.#attributesStore.getTemporaryAttributes();
+        if (Object.keys(temporaryAttributes).length > 0) {
+            childLogger.appendKeys(temporaryAttributes);
         }
         return childLogger;
     }
@@ -346,7 +337,7 @@ class Logger extends commons_1.Utility {
      * that will be logged in all log items.
      */
     getPersistentLogAttributes() {
-        return this.persistentLogAttributes;
+        return this.#attributesStore.getPersistentAttributes();
     }
     /**
      * Print a log item with level INFO.
@@ -402,15 +393,15 @@ class Logger extends commons_1.Utility {
             const loggerRef = this;
             // Use a function() {} instead of an () => {} arrow function so that we can
             // access `myClass` as `this` in a decorated `myClass.myMethod()`.
-            descriptor.value = async function (event, context, callback) {
+            descriptor.value = async function (...args) {
                 loggerRef.refreshSampleRateCalculation();
-                loggerRef.addContext(context);
-                loggerRef.logEventIfEnabled(event, options?.logEvent);
+                loggerRef.addContext(args[1]);
+                loggerRef.logEventIfEnabled(args[0], options?.logEvent);
                 if (options?.correlationIdPath) {
-                    loggerRef.setCorrelationId(event, options?.correlationIdPath);
+                    loggerRef.setCorrelationId(args[0], options?.correlationIdPath);
                 }
                 try {
-                    return await originalMethod.apply(this, [event, context, callback]);
+                    return await originalMethod.apply(this, args);
                 }
                 catch (error) {
                     if (options?.flushBufferOnUncaughtError) {
@@ -421,7 +412,6 @@ class Logger extends commons_1.Utility {
                         });
                     }
                     throw error;
-                    /* v8 ignore next */
                 }
                 finally {
                     if (options?.clearState || options?.resetKeys)
@@ -434,22 +424,19 @@ class Logger extends commons_1.Utility {
     /**
      * @deprecated This method is deprecated and will be removed in the future major versions. Use {@link resetKeys()} instead.
      */
-    /* v8 ignore start */ static injectLambdaContextAfterOrOnError(logger, _persistentAttributes, options) {
+    /* v8 ignore next -- @preserve */
+    static injectLambdaContextAfterOrOnError(logger, _persistentAttributes, options) {
         if (options && (options.clearState || options?.resetKeys)) {
             logger.resetKeys();
         }
-    } /* v8 ignore stop */
+    }
     /**
      * @deprecated - This method is deprecated and will be removed in the next major version.
      */
-    /* v8 ignore start */ static injectLambdaContextBefore(logger, event, context, options) {
+    /* v8 ignore next -- @preserve */ static injectLambdaContextBefore(logger, event, context, options) {
         logger.addContext(context);
-        let shouldLogEvent = undefined;
-        if (options && Object.hasOwn(options, 'logEvent')) {
-            shouldLogEvent = options.logEvent;
-        }
-        logger.logEventIfEnabled(event, shouldLogEvent);
-    } /* v8 ignore stop */
+        logger.logEventIfEnabled(event, options?.logEvent);
+    }
     /**
      * Log the AWS Lambda event payload for the current invocation if the environment variable `POWERTOOLS_LOGGER_LOG_EVENT` is set to `true`.
      *
@@ -502,15 +489,7 @@ class Logger extends commons_1.Utility {
      * @param keys - The keys to remove.
      */
     removeKeys(keys) {
-        for (const key of keys) {
-            this.temporaryLogAttributes[key] = undefined;
-            if (this.persistentLogAttributes[key]) {
-                this.#keys.set(key, 'persistent');
-            }
-            else {
-                this.#keys.delete(key);
-            }
-        }
+        this.#attributesStore.removeTemporaryKeys(keys);
     }
     /**
      * Remove the given keys from the persistent keys.
@@ -531,15 +510,7 @@ class Logger extends commons_1.Utility {
      * @param keys - The keys to remove from the persistent attributes.
      */
     removePersistentKeys(keys) {
-        for (const key of keys) {
-            this.persistentLogAttributes[key] = undefined;
-            if (this.temporaryLogAttributes[key]) {
-                this.#keys.set(key, 'temp');
-            }
-            else {
-                this.#keys.delete(key);
-            }
-        }
+        this.#attributesStore.removePersistentKeys(keys);
     }
     /**
      * @deprecated This method is deprecated and will be removed in the future major versions. Use {@link removePersistentKeys()} instead.
@@ -551,15 +522,7 @@ class Logger extends commons_1.Utility {
      * Remove all temporary log attributes added with {@link appendKeys() `appendKeys()`} method.
      */
     resetKeys() {
-        for (const key of Object.keys(this.temporaryLogAttributes)) {
-            if (this.persistentLogAttributes[key]) {
-                this.#keys.set(key, 'persistent');
-            }
-            else {
-                this.#keys.delete(key);
-            }
-        }
-        this.temporaryLogAttributes = {};
+        this.#attributesStore.clearTemporaryAttributes();
     }
     /**
      * Set the log level for this Logger instance.
@@ -583,7 +546,14 @@ class Logger extends commons_1.Utility {
      * @deprecated This method is deprecated and will be removed in the future major versions, please use {@link appendPersistentKeys() `appendPersistentKeys()`} instead.
      */
     setPersistentLogAttributes(attributes) {
-        this.persistentLogAttributes = attributes;
+        const filtered = this.#filterReservedAttributeKeys(attributes);
+        this.#attributesStore.setPersistentAttributes(filtered);
+    }
+    /**
+     * @deprecated Use getPersistentLogAttributes() instead
+     */
+    get persistentLogAttributes() {
+        return this.#attributesStore.getPersistentAttributes();
     }
     /**
      * Check whether the current Lambda invocation event should be printed in the logs or not.
@@ -672,6 +642,7 @@ class Logger extends commons_1.Utility {
                 return replacedValue.toString();
             }
             if (typeof replacedValue === 'object' && replacedValue !== null) {
+                /* v8 ignore next -- @preserve */
                 if (references.has(replacedValue)) {
                     return;
                 }
@@ -686,7 +657,16 @@ class Logger extends commons_1.Utility {
      * @param attributes - The attributes to add to all log items.
      */
     addToPowertoolsLogData(attributes) {
-        (0, lodash_merge_1.default)(this.powertoolsLogData, attributes);
+        (0, commons_1.deepMerge)(this.powertoolsLogData, attributes);
+    }
+    #filterReservedAttributeKeys(attributes) {
+        const filtered = {};
+        for (const [key, value] of Object.entries(attributes)) {
+            if (!this.#checkReservedKeyAndWarn(key)) {
+                filtered[key] = value;
+            }
+        }
+        return filtered;
     }
     /**
      * Shared logic for adding keys to the logger instance.
@@ -695,16 +675,13 @@ class Logger extends commons_1.Utility {
      * @param type - The type of the attributes to add.
      */
     #appendKeys(attributes, type) {
-        for (const attributeKey of Object.keys(attributes)) {
-            if (this.#checkReservedKeyAndWarn(attributeKey) === false) {
-                this.#keys.set(attributeKey, type);
-            }
-        }
+        const filtered = this.#filterReservedAttributeKeys(attributes);
         if (type === 'temp') {
-            (0, lodash_merge_1.default)(this.temporaryLogAttributes, attributes);
+            this.#attributesStore.appendTemporaryKeys(filtered);
         }
         else {
-            (0, lodash_merge_1.default)(this.persistentLogAttributes, attributes);
+            const current = this.#attributesStore.getPersistentAttributes();
+            this.#attributesStore.setPersistentAttributes((0, commons_1.deepMerge)(current, filtered));
         }
     }
     awsLogLevelShortCircuit(selectedLogLevel) {
@@ -725,30 +702,15 @@ class Logger extends commons_1.Utility {
         const unformattedBaseAttributes = {
             logLevel: this.getLogLevelNameFromNumber(logLevel),
             timestamp: new Date(),
-            xRayTraceId: this.envVarsService.getXrayTraceId(),
+            xRayTraceId: (0, env_1.getXRayTraceIdFromEnv)(),
             ...this.getPowertoolsLogData(),
             message: '',
         };
-        const additionalAttributes = this.#createAdditionalAttributes();
+        const additionalAttributes = this.#attributesStore.getAllAttributes();
         this.#processMainInput(input, unformattedBaseAttributes, additionalAttributes);
         this.#processExtraInput(extraInput, additionalAttributes);
         return this.getLogFormatter().formatAttributes(unformattedBaseAttributes, additionalAttributes);
     }
-    /**
-     * Create additional attributes from persistent and temporary keys
-     */
-    #createAdditionalAttributes() {
-        const attributes = {};
-        for (const [key, type] of this.#keys) {
-            if (!this.#checkReservedKeyAndWarn(key)) {
-                attributes[key] =
-                    type === 'persistent'
-                        ? this.persistentLogAttributes[key]
-                        : this.temporaryLogAttributes[key];
-            }
-        }
-        return attributes;
-    }
     /**
      * Process the main input message and add it to the attributes
      */
@@ -819,12 +781,6 @@ class Logger extends commons_1.Utility {
     getCustomConfigService() {
         return this.customConfigService;
     }
-    /**
-     * Get the instance of a service that fetches environment variables.
-     */
-    getEnvVarsService() {
-        return this.envVarsService;
-    }
     /**
      * Get the instance of a service that formats the structure of a
      * log item's keys and values in the desired way.
@@ -895,7 +851,7 @@ class Logger extends commons_1.Utility {
      * @param extraInput - The extra input to log
      */
     processLogItem(logLevel, input, extraInput) {
-        const traceId = this.envVarsService.getXrayTraceId();
+        const traceId = (0, env_1.getXRayTraceIdFromEnv)();
         if (traceId !== undefined && this.shouldBufferLog(traceId, logLevel)) {
             try {
                 this.bufferLogItem(traceId, this.createAndPopulateLogItem(logLevel, input, extraInput), logLevel);
@@ -920,15 +876,15 @@ class Logger extends commons_1.Utility {
      * or as the global node console if the `POWERTOOLS_DEV' env variable is set and has truthy value.
      */
     setConsole() {
-        if (!this.getEnvVarsService().isDevMode()) {
+        if ((0, env_1.isDevMode)()) {
+            this.console = console;
+        }
+        else {
             this.console = new node_console_1.Console({
                 stdout: process.stdout,
                 stderr: process.stderr,
             });
         }
-        else {
-            this.console = console;
-        }
         /**
          * Patch `console.trace` to avoid printing a stack trace and aligning with AWS Lambda behavior - see #2902
          */
@@ -936,17 +892,6 @@ class Logger extends commons_1.Utility {
             this.console.log(message, ...optionalParams);
         };
     }
-    /**
-     * Set the Logger's customer config service instance, which will be used
-     * to fetch environment variables.
-     *
-     * @param customConfigService - The custom config service
-     */
-    setCustomConfigService(customConfigService) {
-        this.customConfigService = customConfigService
-            ? customConfigService
-            : undefined;
-    }
     /**
      * Set the initial Logger log level based on the following order:
      * 1. If a log level is set using AWS Lambda Advanced Logging Controls, it sets it.
@@ -977,11 +922,18 @@ class Logger extends commons_1.Utility {
             this.#initialLogLevel = this.logLevel;
             return;
         }
-        const envVarsValue = this.getEnvVarsService()?.getLogLevel()?.toUpperCase();
-        if (this.isValidLogLevel(envVarsValue)) {
-            this.logLevel = constants_js_1.LogLevelThreshold[envVarsValue];
+        const logLevelVariable = (0, env_1.getStringFromEnv)({
+            key: 'POWERTOOLS_LOG_LEVEL',
+            defaultValue: '',
+        });
+        const logLevelVariableAlias = (0, env_1.getStringFromEnv)({
+            key: 'LOG_LEVEL',
+            defaultValue: '',
+        });
+        const logLevelValue = logLevelVariable || logLevelVariableAlias;
+        if (this.isValidLogLevel(logLevelValue)) {
+            this.logLevel = constants_js_1.LogLevelThreshold[logLevelValue];
             this.#initialLogLevel = this.logLevel;
-            return;
         }
     }
     /**
@@ -996,8 +948,15 @@ class Logger extends commons_1.Utility {
     setInitialSampleRate(sampleRateValue) {
         const constructorValue = sampleRateValue;
         const customConfigValue = this.getCustomConfigService()?.getSampleRateValue();
-        const envVarsValue = this.getEnvVarsService().getSampleRateValue();
-        for (const value of [constructorValue, customConfigValue, envVarsValue]) {
+        const sampleRateEnvVariable = (0, env_1.getNumberFromEnv)({
+            key: 'POWERTOOLS_LOGGER_SAMPLE_RATE',
+            defaultValue: 0,
+        });
+        for (const value of [
+            constructorValue,
+            customConfigValue,
+            sampleRateEnvVariable,
+        ]) {
             if (this.isValidSampleRate(value)) {
                 this.#debugLogSampling.sampleRateValue = value;
                 this.powertoolsLogData.sampleRateValue = value;
@@ -1015,9 +974,10 @@ class Logger extends commons_1.Utility {
      * the event passed to the Lambda function handler should be logged or not.
      */
     setLogEvent() {
-        if (this.getEnvVarsService().getLogEvent()) {
-            this.logEvent = true;
-        }
+        this.logEvent = (0, env_1.getBooleanFromEnv)({
+            key: 'POWERTOOLS_LOGGER_LOG_EVENT',
+            defaultValue: false,
+        });
     }
     /**
      * Set the log formatter instance, in charge of giving a custom format
@@ -1030,7 +990,6 @@ class Logger extends commons_1.Utility {
         this.logFormatter =
             logFormatter ??
                 new PowertoolsLogFormatter_js_1.PowertoolsLogFormatter({
-                    envVarsService: this.getEnvVarsService(),
                     logRecordOrder,
                 });
     }
@@ -1039,7 +998,7 @@ class Logger extends commons_1.Utility {
      * add JSON indentation for pretty printing logs.
      */
     setLogIndentation() {
-        if (this.getEnvVarsService().isDevMode()) {
+        if ((0, env_1.isDevMode)()) {
             this.logIndentation = constants_js_1.LogJsonIndent.PRETTY;
         }
     }
@@ -1052,13 +1011,20 @@ class Logger extends commons_1.Utility {
     setOptions(options) {
         const { logLevel, serviceName, sampleRateValue, logFormatter, persistentKeys, persistentLogAttributes, // deprecated in favor of persistentKeys
         environment, jsonReplacerFn, logRecordOrder, logBufferOptions, correlationIdSearchFn, } = options;
-        if (persistentLogAttributes && persistentKeys) {
+        if (persistentLogAttributes &&
+            Object.keys(persistentLogAttributes).length > 0 &&
+            persistentKeys &&
+            Object.keys(persistentKeys).length > 0) {
             this.warn('Both persistentLogAttributes and persistentKeys options were provided. Using persistentKeys as persistentLogAttributes is deprecated and will be removed in future releases');
         }
         // configurations that affect log content
         this.setPowertoolsLogData(serviceName, environment, persistentKeys || persistentLogAttributes);
         // configurations that affect Logger behavior
-        const AlcLogLevel = this.getEnvVarsService().getAwsLogLevel();
+        const lambdaLogLevel = (0, env_1.getStringFromEnv)({
+            key: 'AWS_LAMBDA_LOG_LEVEL',
+            defaultValue: '',
+        });
+        const AlcLogLevel = lambdaLogLevel === 'FATAL' ? 'CRITICAL' : lambdaLogLevel;
         if (this.isValidLogLevel(AlcLogLevel)) {
             this.#alcLogLevel = AlcLogLevel;
         }
@@ -1083,13 +1049,22 @@ class Logger extends commons_1.Utility {
      */
     setPowertoolsLogData(serviceName, environment, persistentKeys) {
         this.addToPowertoolsLogData({
-            awsRegion: this.getEnvVarsService().getAwsRegion(),
+            awsRegion: (0, env_1.getStringFromEnv)({
+                key: 'AWS_REGION',
+                defaultValue: '',
+            }),
             environment: environment ||
                 this.getCustomConfigService()?.getCurrentEnvironment() ||
-                this.getEnvVarsService().getCurrentEnvironment(),
+                (0, env_1.getStringFromEnv)({
+                    key: 'ENVIRONMENT',
+                    defaultValue: '',
+                }),
             serviceName: serviceName ||
                 this.getCustomConfigService()?.getServiceName() ||
-                this.getEnvVarsService().getServiceName() ||
+                (0, env_1.getStringFromEnv)({
+                    key: 'POWERTOOLS_SERVICE_NAME',
+                    defaultValue: '',
+                }) ||
                 this.defaultServiceName,
         });
         persistentKeys && this.appendPersistentKeys(persistentKeys);
@@ -1152,7 +1127,7 @@ class Logger extends commons_1.Utility {
      * your function throws an error.
      */
     flushBuffer() {
-        const traceId = this.envVarsService.getXrayTraceId();
+        const traceId = (0, env_1.getXRayTraceIdFromEnv)();
         if (traceId === undefined) {
             return;
         }
@@ -1178,7 +1153,7 @@ class Logger extends commons_1.Utility {
      * Empties the buffer for the current request
      */
     clearBuffer() {
-        const traceId = this.envVarsService.getXrayTraceId();
+        const traceId = (0, env_1.getXRayTraceIdFromEnv)();
         if (traceId === undefined) {
             return;
         }
@@ -1238,7 +1213,7 @@ class Logger extends commons_1.Utility {
      * Get the correlation ID from the log attributes.
      */
     getCorrelationId() {
-        return this.temporaryLogAttributes.correlation_id;
+        return this.#attributesStore.getTemporaryAttributes().correlation_id;
     }
 }
 exports.Logger = Logger;

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/formatter/LogFormatter.d.ts

@@ -1,6 +1,4 @@
-import type { EnvironmentVariablesService } from '../config/EnvironmentVariablesService.js';
 import type { LogAttributes } from '../types/Logger.js';
-import type { LogFormatterOptions } from '../types/formatters.js';
 import type { UnformattedAttributes } from '../types/logKeys.js';
 import type { LogItem } from './LogItem.js';
 /**
@@ -13,11 +11,6 @@ import type { LogItem } from './LogItem.js';
  */
 declare abstract class LogFormatter {
     #private;
-    /**
-     * Instance of the {@link EnvironmentVariablesService} to use for configuration.
-     */
-    protected envVarsService?: EnvironmentVariablesService;
-    constructor(options?: LogFormatterOptions);
     /**
      * Format key-value pairs of log attributes.
      *
@@ -106,9 +99,7 @@ declare abstract class LogFormatter {
     /**
      * Format a date into an ISO 8601 string with the configured timezone.
      *
-     * If the log formatter is passed an {@link EnvironmentVariablesService} instance
-     * during construction, the timezone is read from the `TZ` environment variable, if present.
-     *
+     * The timezone is read from the `TZ` environment variable, if present.
      * Otherwise, the timezone defaults to ':UTC'.
      *
      * @param now - The date to format

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/formatter/LogFormatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LogFormatter.d.ts","sourceRoot":"","sources":["../../../src/formatter/LogFormatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AAC5F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C;;;;;;;GAOG;AACH,uBAAe,YAAY;;IACzB;;OAEG;IACH,SAAS,CAAC,cAAc,CAAC,EAAE,2BAA2B,CAAC;gBAEpC,OAAO,CAAC,EAAE,mBAAmB;IAIhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6DG;aACa,gBAAgB,CAC9B,UAAU,EAAE,qBAAqB,EACjC,uBAAuB,EAAE,aAAa,GACrC,OAAO;IAEV;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa;IA2B/C;;;;;;;;;OASG;IACI,eAAe,CAAC,GAAG,EAAE,IAAI,GAAG,MAAM;IAczC;;;;OAIG;IACI,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;CA8E/C;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"LogFormatter.d.ts","sourceRoot":"","sources":["../../../src/formatter/LogFormatter.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C;;;;;;;GAOG;AACH,uBAAe,YAAY;;IACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6DG;aACa,gBAAgB,CAC9B,UAAU,EAAE,qBAAqB,EACjC,uBAAuB,EAAE,aAAa,GACrC,OAAO;IAEV;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa;IAsB/C;;;;;;;OAOG;IACI,eAAe,CAAC,GAAG,EAAE,IAAI,GAAG,MAAM;IAkBzC;;;;OAIG;IACI,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;CA8E/C;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/logger/lib/cjs/formatter/LogFormatter.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogFormatter = void 0;
+const env_1 = require("@aws-lambda-powertools/commons/utils/env");
 /**
  * Class that defines and implements common methods for the formatting of log attributes.
  *
@@ -10,13 +11,6 @@ exports.LogFormatter = void 0;
  * @abstract
  */
 class LogFormatter {
-    /**
-     * Instance of the {@link EnvironmentVariablesService} to use for configuration.
-     */
-    envVarsService;
-    constructor(options) {
-        this.envVarsService = options?.envVarsService;
-    }
     /**
      * Format an error into a loggable object.
      *
@@ -44,12 +38,8 @@ class LogFormatter {
             name,
             location: this.getCodeLocation(error.stack),
             message,
-            stack: this.envVarsService?.isDevMode() && typeof stack === 'string'
-                ? stack?.split('\n')
-                : stack,
-            cause: error.cause instanceof Error
-                ? this.formatError(error.cause)
-                : error.cause,
+            stack: (0, env_1.isDevMode)() && typeof stack === 'string' ? stack?.split('\n') : stack,
+            cause: cause instanceof Error ? this.formatError(cause) : cause,
         };
         for (const key in error) {
             if (typeof key === 'string' &&
@@ -62,9 +52,7 @@ class LogFormatter {
     /**
      * Format a date into an ISO 8601 string with the configured timezone.
      *
-     * If the log formatter is passed an {@link EnvironmentVariablesService} instance
-     * during construction, the timezone is read from the `TZ` environment variable, if present.
-     *
+     * The timezone is read from the `TZ` environment variable, if present.
      * Otherwise, the timezone defaults to ':UTC'.
      *
      * @param now - The date to format
@@ -74,8 +62,11 @@ class LogFormatter {
         /**
          * If a specific timezone is configured and it's not the default `UTC`,
          * format the timestamp with the appropriate timezone offset.
-         **/
-        const configuredTimezone = this.envVarsService?.getTimezone();
+         */
+        const configuredTimezone = (0, env_1.getStringFromEnv)({
+            key: 'TZ',
+            defaultValue: '',
+        });
         if (configuredTimezone && !configuredTimezone.includes(defaultTimezone))
             return this.#generateISOTimestampWithOffset(now, configuredTimezone);
         return now.toISOString();
@@ -90,7 +81,7 @@ class LogFormatter {
             return '';
         }
         const stackLines = stack.split('\n');
-        const regex = /\(([^)]*?):(\d+?):(\d+?)\)\\?$/;
+        const regex = /\(([^()]*?):(\d+?):(\d+?)\)\\?$/;
         for (const item of stackLines) {
             const match = regex.exec(item);
             if (Array.isArray(match)) {
@@ -113,13 +104,13 @@ class LogFormatter {
             ? timezone
             : 'UTC';
         return new Intl.DateTimeFormat('en', {
+            hourCycle: 'h23',
             year: 'numeric',
             month: twoDigitFormatOption,
             day: twoDigitFormatOption,
             hour: twoDigitFormatOption,
             minute: twoDigitFormatOption,
             second: twoDigitFormatOption,
-            hour12: false,
             timeZone: validTimeZone,
         });
     };