@rudderstack/integrations-lib 0.2.8 → 0.2.10

package/build/constants.d.ts

@@ -96,4 +96,10 @@ export declare const GENERIC_MAPPING_CONFIG: {
 export declare const MappedToDestinationKey = "context.mappedToDestination";
 export declare const GENERIC_TRUE_VALUES: string[];
 export declare const GENERIC_FALSE_VALUES: string[];
+export declare const LOGLEVELS: {
+    debug: number;
+    info: number;
+    warn: number;
+    error: number;
+};
 //# sourceMappingURL=constants.d.ts.map

package/build/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDlC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuHlC,CAAC;AAEF,eAAO,MAAM,sBAAsB,gCAAgC,CAAC;AAEpE,eAAO,MAAM,mBAAmB,UAA0C,CAAC;AAC3E,eAAO,MAAM,oBAAoB,UAA6C,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDlC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuHlC,CAAC;AAEF,eAAO,MAAM,sBAAsB,gCAAgC,CAAC;AAEpE,eAAO,MAAM,mBAAmB,UAA0C,CAAC;AAC3E,eAAO,MAAM,oBAAoB,UAA6C,CAAC;AAC/E,eAAO,MAAM,SAAS;;;;;CAKrB,CAAC"}

package/build/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GENERIC_FALSE_VALUES = exports.GENERIC_TRUE_VALUES = exports.MappedToDestinationKey = exports.GENERIC_MAPPING_CONFIG = exports.NETWORK_STATUS_ERR_MAP = void 0;
+exports.LOGLEVELS = exports.GENERIC_FALSE_VALUES = exports.GENERIC_TRUE_VALUES = exports.MappedToDestinationKey = exports.GENERIC_MAPPING_CONFIG = exports.NETWORK_STATUS_ERR_MAP = void 0;
 exports.NETWORK_STATUS_ERR_MAP = {
     EACCES: {
         status: 400,
@@ -180,4 +180,10 @@ exports.GENERIC_MAPPING_CONFIG = {
 exports.MappedToDestinationKey = 'context.mappedToDestination';
 exports.GENERIC_TRUE_VALUES = ['true', 'True', 'TRUE', 't', 'T', '1'];
 exports.GENERIC_FALSE_VALUES = ['false', 'False', 'FALSE', 'f', 'F', '0'];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"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","sourcesContent":["export const NETWORK_STATUS_ERR_MAP = {\n  EACCES: {\n    status: 400,\n    message: '[EACCES] :: Permission denied',\n  },\n  EADDRINUSE: {\n    status: 400,\n    message: '[EADDRINUSE] :: Address already in use',\n  },\n  ECONNREFUSED: {\n    status: 500,\n    message: '[ECONNREFUSED] :: Connection refused',\n  },\n  ECONNRESET: {\n    status: 500,\n    message: '[ECONNRESET] :: Connection reset by peer',\n  },\n  EEXIST: {\n    status: 400,\n    message: '[EEXIST] :: File exists',\n  },\n  EISDIR: {\n    status: 400,\n    message: '[EEXIST] :: Is a directory',\n  },\n  EMFILE: {\n    status: 400,\n    message: '[EMFILE] :: Too many open files in system',\n  },\n  ENOENT: {\n    status: 400,\n    message: '[ENOENT] :: No such file or directory',\n  },\n  ENOTDIR: {\n    status: 400,\n    message: '[ENOTDIR] :: Not a directory',\n  },\n  ENOTEMPTY: {\n    status: 400,\n    message: '[ENOTEMPTY] :: Directory not empty)',\n  },\n  ENOTFOUND: {\n    status: 400,\n    message: '[ENOTFOUND] :: DNS lookup failed',\n  },\n  EPERM: {\n    status: 400,\n    message: '[EPERM] :: Operation not permitted',\n  },\n  EPIPE: {\n    status: 400,\n    message: '[EPIPE] :: Broken pipe',\n  },\n  ETIMEDOUT: {\n    status: 500,\n    message: '[ETIMEDOUT] :: Operation timed out',\n  },\n};\n\nexport const GENERIC_MAPPING_CONFIG = {\n  address: ['traits.address', 'context.traits.address'],\n  createdAt: ['traits.createdAt', 'context.traits.createdAt', 'timestamp', 'originalTimestamp'],\n  createdAtOnly: ['traits.createdAt', 'context.traits.createdAt'],\n  email: ['traits.email', 'context.traits.email', 'properties.email', 'context.externalId.0.id'],\n  emailOnly: ['traits.email', 'context.traits.email', 'properties.email'],\n  timestamp: ['timestamp', 'originalTimestamp'],\n  historicalTimestamp: ['timestamp', 'originalTimestamp'],\n  traits: ['traits', 'context.traits'],\n  groupId: ['groupId', 'traits.groupId'],\n  groupTraits: ['traits', 'context.traits'],\n  userId: [\n    'userId',\n    'traits.userId',\n    'traits.id',\n    'context.traits.userId',\n    'context.traits.id',\n    'anonymousId',\n  ],\n  userIdOnly: [\n    'userId',\n    'traits.userId',\n    'traits.id',\n    'context.traits.userId',\n    'context.traits.id',\n  ],\n  name: ['traits.name', 'context.traits.name'],\n  title: ['traits.title', 'context.traits.title'],\n  firstName: [\n    'traits.firstName',\n    'traits.firstname',\n    'traits.first_name',\n    'context.traits.firstName',\n    'context.traits.firstname',\n    'context.traits.first_name',\n  ],\n  lastName: [\n    'traits.lastName',\n    'traits.lastname',\n    'traits.last_name',\n    'context.traits.lastName',\n    'context.traits.lastname',\n    'context.traits.last_name',\n  ],\n  middleName: [\n    'traits.middleName',\n    'traits.middleName',\n    'traits.middle_name',\n    'context.traits.middleName',\n    'context.traits.middleName',\n    'context.traits.middle_name',\n  ],\n  gender: ['traits.gender', 'context.traits.gender'],\n  phone: ['traits.phone', 'context.traits.phone', 'properties.phone'],\n  pageTitle: ['context.page.title', 'properties.title'],\n  pageUrl: ['context.page.url', 'properties.url'],\n  pagePath: ['context.page.path', 'properties.path'],\n  website: ['traits.website', 'context.traits.website', 'properties.website'],\n  GApageUrl: ['properties.url', 'context.page.url'],\n  GApageRef: ['properties.referrer', 'context.page.referrer'],\n  GApageTitle: ['properties.title', 'context.page.title'],\n  GApageSearch: ['properties.search', 'context.page.search'],\n  birthday: [\n    'traits.birthday',\n    'context.traits.birthday',\n    'traits.dateOfBirth',\n    'context.traits.dateOfBirth',\n    'traits.dateofbirth',\n    'context.dateofbirth',\n    'traits.dob',\n    'context.traits.dob',\n    'traits.DOB',\n    'context.traits.DOB',\n  ],\n\n  state: ['traits.state', 'context.traits.state'],\n  country: ['traits.country', 'context.traits.country'],\n  region: ['traits.region', 'context.traits.region'],\n  city: ['traits.address.city', 'context.traits.address.city'],\n\n  avatar: [\n    'traits.avatar',\n    'context.traits.avatar',\n    'traits.avatarURL',\n    'context.traits.avatarURL',\n    'traits.avatar_URL',\n    'context.traits.avatar_URL',\n  ],\n  zipcode: [\n    'traits.zip',\n    'traits.zipcode',\n    'traits.zip_code',\n    'traits.zipCode',\n    'traits.postalcode',\n    'traits.postal_code',\n    'traits.postalCode',\n    'traits.address.zipcode',\n    'traits.address.zip_code',\n    'traits.address.zip',\n    'traits.address.zipCode',\n    'traits.address.postalcode',\n    'traits.address.postal_code',\n    'traits.address.postalCode',\n    'context.traits.zip',\n    'context.traits.zipcode',\n    'context.traits.zip_code',\n    'context.traits.zipCode',\n    'context.traits.postalcode',\n    'context.traits.postal_code',\n    'context.traits.postalCode',\n    'context.traits.address.zip',\n    'context.traits.address.zipcode',\n    'context.traits.address.zip_code',\n    'context.traits.address.zipCode',\n    'context.traits.address.postalcode',\n    'context.traits.address.postal_code',\n    'context.traits.address.postalCode',\n  ],\n  sessionId: ['session_id', 'context.sessionId'],\n};\n\nexport const MappedToDestinationKey = 'context.mappedToDestination';\n\nexport const GENERIC_TRUE_VALUES = ['true', 'True', 'TRUE', 't', 'T', '1'];\nexport const GENERIC_FALSE_VALUES = ['false', 'False', 'FALSE', 'f', 'F', '0'];\n"]}
+exports.LOGLEVELS = {
+    debug: 3,
+    info: 2,
+    warn: 1,
+    error: 0, // Logs about errors which dont immediately halt the application
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"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","sourcesContent":["export const NETWORK_STATUS_ERR_MAP = {\n  EACCES: {\n    status: 400,\n    message: '[EACCES] :: Permission denied',\n  },\n  EADDRINUSE: {\n    status: 400,\n    message: '[EADDRINUSE] :: Address already in use',\n  },\n  ECONNREFUSED: {\n    status: 500,\n    message: '[ECONNREFUSED] :: Connection refused',\n  },\n  ECONNRESET: {\n    status: 500,\n    message: '[ECONNRESET] :: Connection reset by peer',\n  },\n  EEXIST: {\n    status: 400,\n    message: '[EEXIST] :: File exists',\n  },\n  EISDIR: {\n    status: 400,\n    message: '[EEXIST] :: Is a directory',\n  },\n  EMFILE: {\n    status: 400,\n    message: '[EMFILE] :: Too many open files in system',\n  },\n  ENOENT: {\n    status: 400,\n    message: '[ENOENT] :: No such file or directory',\n  },\n  ENOTDIR: {\n    status: 400,\n    message: '[ENOTDIR] :: Not a directory',\n  },\n  ENOTEMPTY: {\n    status: 400,\n    message: '[ENOTEMPTY] :: Directory not empty)',\n  },\n  ENOTFOUND: {\n    status: 400,\n    message: '[ENOTFOUND] :: DNS lookup failed',\n  },\n  EPERM: {\n    status: 400,\n    message: '[EPERM] :: Operation not permitted',\n  },\n  EPIPE: {\n    status: 400,\n    message: '[EPIPE] :: Broken pipe',\n  },\n  ETIMEDOUT: {\n    status: 500,\n    message: '[ETIMEDOUT] :: Operation timed out',\n  },\n};\n\nexport const GENERIC_MAPPING_CONFIG = {\n  address: ['traits.address', 'context.traits.address'],\n  createdAt: ['traits.createdAt', 'context.traits.createdAt', 'timestamp', 'originalTimestamp'],\n  createdAtOnly: ['traits.createdAt', 'context.traits.createdAt'],\n  email: ['traits.email', 'context.traits.email', 'properties.email', 'context.externalId.0.id'],\n  emailOnly: ['traits.email', 'context.traits.email', 'properties.email'],\n  timestamp: ['timestamp', 'originalTimestamp'],\n  historicalTimestamp: ['timestamp', 'originalTimestamp'],\n  traits: ['traits', 'context.traits'],\n  groupId: ['groupId', 'traits.groupId'],\n  groupTraits: ['traits', 'context.traits'],\n  userId: [\n    'userId',\n    'traits.userId',\n    'traits.id',\n    'context.traits.userId',\n    'context.traits.id',\n    'anonymousId',\n  ],\n  userIdOnly: [\n    'userId',\n    'traits.userId',\n    'traits.id',\n    'context.traits.userId',\n    'context.traits.id',\n  ],\n  name: ['traits.name', 'context.traits.name'],\n  title: ['traits.title', 'context.traits.title'],\n  firstName: [\n    'traits.firstName',\n    'traits.firstname',\n    'traits.first_name',\n    'context.traits.firstName',\n    'context.traits.firstname',\n    'context.traits.first_name',\n  ],\n  lastName: [\n    'traits.lastName',\n    'traits.lastname',\n    'traits.last_name',\n    'context.traits.lastName',\n    'context.traits.lastname',\n    'context.traits.last_name',\n  ],\n  middleName: [\n    'traits.middleName',\n    'traits.middleName',\n    'traits.middle_name',\n    'context.traits.middleName',\n    'context.traits.middleName',\n    'context.traits.middle_name',\n  ],\n  gender: ['traits.gender', 'context.traits.gender'],\n  phone: ['traits.phone', 'context.traits.phone', 'properties.phone'],\n  pageTitle: ['context.page.title', 'properties.title'],\n  pageUrl: ['context.page.url', 'properties.url'],\n  pagePath: ['context.page.path', 'properties.path'],\n  website: ['traits.website', 'context.traits.website', 'properties.website'],\n  GApageUrl: ['properties.url', 'context.page.url'],\n  GApageRef: ['properties.referrer', 'context.page.referrer'],\n  GApageTitle: ['properties.title', 'context.page.title'],\n  GApageSearch: ['properties.search', 'context.page.search'],\n  birthday: [\n    'traits.birthday',\n    'context.traits.birthday',\n    'traits.dateOfBirth',\n    'context.traits.dateOfBirth',\n    'traits.dateofbirth',\n    'context.dateofbirth',\n    'traits.dob',\n    'context.traits.dob',\n    'traits.DOB',\n    'context.traits.DOB',\n  ],\n\n  state: ['traits.state', 'context.traits.state'],\n  country: ['traits.country', 'context.traits.country'],\n  region: ['traits.region', 'context.traits.region'],\n  city: ['traits.address.city', 'context.traits.address.city'],\n\n  avatar: [\n    'traits.avatar',\n    'context.traits.avatar',\n    'traits.avatarURL',\n    'context.traits.avatarURL',\n    'traits.avatar_URL',\n    'context.traits.avatar_URL',\n  ],\n  zipcode: [\n    'traits.zip',\n    'traits.zipcode',\n    'traits.zip_code',\n    'traits.zipCode',\n    'traits.postalcode',\n    'traits.postal_code',\n    'traits.postalCode',\n    'traits.address.zipcode',\n    'traits.address.zip_code',\n    'traits.address.zip',\n    'traits.address.zipCode',\n    'traits.address.postalcode',\n    'traits.address.postal_code',\n    'traits.address.postalCode',\n    'context.traits.zip',\n    'context.traits.zipcode',\n    'context.traits.zip_code',\n    'context.traits.zipCode',\n    'context.traits.postalcode',\n    'context.traits.postal_code',\n    'context.traits.postalCode',\n    'context.traits.address.zip',\n    'context.traits.address.zipcode',\n    'context.traits.address.zip_code',\n    'context.traits.address.zipCode',\n    'context.traits.address.postalcode',\n    'context.traits.address.postal_code',\n    'context.traits.address.postalCode',\n  ],\n  sessionId: ['session_id', 'context.sessionId'],\n};\n\nexport const MappedToDestinationKey = 'context.mappedToDestination';\n\nexport const GENERIC_TRUE_VALUES = ['true', 'True', 'TRUE', 't', 'T', '1'];\nexport const GENERIC_FALSE_VALUES = ['false', 'False', 'FALSE', 'f', 'F', '0'];\nexport const LOGLEVELS = {\n  debug: 3, // Most verbose logging level\n  info: 2, // Logs about state of the application\n  warn: 1, // Logs about warnings which dont immediately halt the application\n  error: 0, // Logs about errors which dont immediately halt the application\n};\n"]}

package/build/index.d.ts

@@ -5,4 +5,5 @@ export * from './logger';
 export * from './structured-logger';
 export * from './network';
 export * from './utils';
+export * from './constants';
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC"}

package/build/index.js

@@ -21,4 +21,5 @@ __exportStar(require("./logger"), exports);
 __exportStar(require("./structured-logger"), exports);
 __exportStar(require("./network"), exports);
 __exportStar(require("./utils"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDBDQUF3QjtBQUN4Qix5Q0FBdUI7QUFDdkIsMkNBQXlCO0FBQ3pCLDJDQUF5QjtBQUN6QixzREFBb0M7QUFDcEMsNENBQTBCO0FBQzFCLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi90YWdzJztcbmV4cG9ydCAqIGZyb20gJy4vZXJyb3JzJztcbmV4cG9ydCAqIGZyb20gJy4vbG9nZ2VyJztcbmV4cG9ydCAqIGZyb20gJy4vc3RydWN0dXJlZC1sb2dnZXInO1xuZXhwb3J0ICogZnJvbSAnLi9uZXR3b3JrJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbHMnO1xuIl19
+__exportStar(require("./constants"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDBDQUF3QjtBQUN4Qix5Q0FBdUI7QUFDdkIsMkNBQXlCO0FBQ3pCLDJDQUF5QjtBQUN6QixzREFBb0M7QUFDcEMsNENBQTBCO0FBQzFCLDBDQUF3QjtBQUN4Qiw4Q0FBNEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4vdGFncyc7XG5leHBvcnQgKiBmcm9tICcuL2Vycm9ycyc7XG5leHBvcnQgKiBmcm9tICcuL2xvZ2dlcic7XG5leHBvcnQgKiBmcm9tICcuL3N0cnVjdHVyZWQtbG9nZ2VyJztcbmV4cG9ydCAqIGZyb20gJy4vbmV0d29yayc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzJztcbmV4cG9ydCAqIGZyb20gJy4vY29uc3RhbnRzJztcbiJdfQ==

package/build/logger.d.ts

@@ -1,7 +1,8 @@
+declare const getLogLevel: (lvl: string) => string;
 declare const setLogLevel: (level: any) => void;
 declare const debug: (...args: any[]) => void;
 declare const info: (...args: any[]) => void;
 declare const warn: (...args: any[]) => void;
 declare const error: (...args: any[]) => void;
-export { debug, error, info, setLogLevel, warn };
+export { debug, error, info, setLogLevel, warn, getLogLevel };
 //# sourceMappingURL=logger.d.ts.map

package/build/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAUA,QAAA,MAAM,WAAW,sBAEhB,CAAC;AAEF,QAAA,MAAM,KAAK,0BAIV,CAAC;AAEF,QAAA,MAAM,IAAI,0BAIT,CAAC;AAEF,QAAA,MAAM,IAAI,0BAIT,CAAC;AAEF,QAAA,MAAM,KAAK,0BAIV,CAAC;AAEF,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAKA,QAAA,MAAM,WAAW,QAAS,MAAM,WAK/B,CAAC;AAEF,QAAA,MAAM,WAAW,sBAEhB,CAAC;AAEF,QAAA,MAAM,KAAK,0BAIV,CAAC;AAEF,QAAA,MAAM,IAAI,0BAIT,CAAC;AAEF,QAAA,MAAM,IAAI,0BAIT,CAAC;AAEF,QAAA,MAAM,KAAK,0BAIV,CAAC;AAEF,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC"}

package/build/logger.js

@@ -1,39 +1,42 @@
 "use strict";
-/* istanbul ignore file */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.warn = exports.setLogLevel = exports.info = exports.error = exports.debug = void 0;
-const levelDebug = 0; // Most verbose logging level
-const levelInfo = 1; // Logs about state of the application
-const levelWarn = 2; // Logs about warnings which dont immediately halt the application
-const levelError = 3; // Logs about errors which dont immediately halt the application
-// any value greater than levelError will work as levelNone
-let logLevel = process.env.LOG_LEVEL ? parseInt(process.env.LOG_LEVEL, 10) : levelInfo;
+exports.getLogLevel = exports.warn = exports.setLogLevel = exports.info = exports.error = exports.debug = void 0;
+/* istanbul ignore file */
+const constants_1 = require("./constants");
+let logLevel = 'error';
+const getLogLevel = (lvl) => {
+    if (constants_1.LOGLEVELS[lvl] === undefined || constants_1.LOGLEVELS[lvl] === null) {
+        return 'error'; // when loglevel is invalid
+    }
+    return lvl;
+};
+exports.getLogLevel = getLogLevel;
 const setLogLevel = (level) => {
-    logLevel = level || logLevel;
+    logLevel = getLogLevel(level || logLevel);
 };
 exports.setLogLevel = setLogLevel;
 const debug = (...args) => {
-    if (levelDebug >= logLevel) {
+    if (constants_1.LOGLEVELS.debug >= constants_1.LOGLEVELS[logLevel]) {
         console.debug(...args);
     }
 };
 exports.debug = debug;
 const info = (...args) => {
-    if (levelInfo >= logLevel) {
+    if (constants_1.LOGLEVELS.info >= constants_1.LOGLEVELS[logLevel]) {
         console.info(...args);
     }
 };
 exports.info = info;
 const warn = (...args) => {
-    if (levelWarn >= logLevel) {
+    if (constants_1.LOGLEVELS.warn >= constants_1.LOGLEVELS[logLevel]) {
         console.warn(...args);
     }
 };
 exports.warn = warn;
 const error = (...args) => {
-    if (levelError >= logLevel) {
+    if (constants_1.LOGLEVELS.error >= constants_1.LOGLEVELS[logLevel]) {
         console.error(...args);
     }
 };
 exports.error = error;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/structured-logger.d.ts

@@ -1,6 +1,4 @@
-import { Logform } from 'winston';
 import { LoggableExtraData } from './types';
-export declare const printLog: (info: Logform.TransformableInfo) => string;
 interface LeveledLogMethod {
     (message: string, extraData?: Partial<LoggableExtraData>): void;
     (infoObject: {
@@ -13,6 +11,42 @@ interface CustLogger {
     debugw: LeveledLogMethod;
     warnw: LeveledLogMethod;
 }
-export declare const structuredLogger: import("winston").Logger & CustLogger;
+export type LogOpts = {
+    level?: string;
+    fillExcept?: string[];
+    levels?: Record<string, number>;
+};
+/**
+ * Structured logger powered by winston
+ * We are trying to create structured logging methods.
+ * Whenever someone would like to log something using structured logging, they can use these methods to do so.
+ * Structured logger methods:
+ * - debugw
+ * - infow
+ * - warnw
+ * - errorw
+ * Note: While using levels option, we need to make sure that lowest level(debug) has a value higher than higher level(warn)
+ *
+ * @example
+ *  const logger = structuredLogger();
+ *  logger.setLogLevel('warn')
+ *  logger.warn('my warning', {...})
+ * @example
+ *  const logger = structuredLogger({level: 'info'});
+ *
+ *  @example
+ *  logger.infow("my error message", { destinationId: "destId", workspaceId: "wspId", destinationType: "dest_type" }) // preferred
+ *  logger.infow({ message: "my error message-2", destinationId: "destId", workspaceId: "wspId",  destinationType: "dest_type" })
+ *
+ * @example
+ * const logger = structuredLogger({levels: {error:0,warn:1,info:2,debug:3}})
+ *
+ * @param opts
+ * @returns
+ */
+export declare const structuredLogger: (opts?: LogOpts) => import("winston").Logger & CustLogger & {
+    setLogLevel: (level: string) => void;
+    getLogLevel: (level: string) => string;
+};
 export {};
 //# sourceMappingURL=structured-logger.d.ts.map

package/build/structured-logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"structured-logger.d.ts","sourceRoot":"","sources":["../src/structured-logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,OAAO,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAyB5C,eAAO,MAAM,QAAQ,SAAU,QAAQ,iBAAiB,KAAG,MAM1D,CAAC;AA4BF,UAAU,gBAAgB;IACxB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC;IAChE,CAAC,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC;CACtE;AAED,UAAU,UAAU;IAClB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,EAAE,gBAAgB,CAAC;IACxB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,EAAE,gBAAgB,CAAC;CACzB;AA6CD,eAAO,MAAM,gBAAgB,uCAAsC,CAAC"}
+{"version":3,"file":"structured-logger.d.ts","sourceRoot":"","sources":["../src/structured-logger.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAuB5C,UAAU,gBAAgB;IACxB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC;IAChE,CAAC,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC;CACtE;AAED,UAAU,UAAU;IAClB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,EAAE,gBAAgB,CAAC;IACxB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,EAAE,gBAAgB,CAAC;CACzB;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC,CAAC;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,gBAAgB,UAAW,OAAO;yBA6EjB,MAAM;yBAjIR,MAAM;CAyIjC,CAAC"}

package/build/structured-logger.js

@@ -1,8 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.structuredLogger = exports.printLog = void 0;
+exports.structuredLogger = void 0;
 const winston_1 = require("winston");
+const constants_1 = require("./constants");
+const { timestamp, combine, metadata, errors, json, splat } = winston_1.format;
+const metadataKey = 'logMetadata';
+const fillExceptFields = [
+    'destinationId',
+    'sourceId',
+    'destinationType',
+    'workspaceId',
+    'module',
+    'implementation',
+    'feature',
+];
+const getLogLevel = (level) => {
+    if (constants_1.LOGLEVELS[level] === undefined || constants_1.LOGLEVELS[level] === null) {
+        return 'error'; // when loglevel is invalid
+    }
+    return level;
+};
 /**
+ * Structured logger powered by winston
  * We are trying to create structured logging methods.
  * Whenever someone would like to log something using structured logging, they can use these methods to do so.
  * Structured logger methods:
@@ -10,77 +29,94 @@ const winston_1 = require("winston");
  * - infow
  * - warnw
  * - errorw
+ * Note: While using levels option, we need to make sure that lowest level(debug) has a value higher than higher level(warn)
+ *
+ * @example
+ *  const logger = structuredLogger();
+ *  logger.setLogLevel('warn')
+ *  logger.warn('my warning', {...})
+ * @example
+ *  const logger = structuredLogger({level: 'info'});
  *
- * Example for how should one use this logger:
+ *  @example
  *  logger.infow("my error message", { destinationId: "destId", workspaceId: "wspId", destinationType: "dest_type" }) // preferred
  *  logger.infow({ message: "my error message-2", destinationId: "destId", workspaceId: "wspId",  destinationType: "dest_type" })
- */
-const { timestamp, combine, metadata, printf, errors, json, splat } = winston_1.format;
-const metadataKey = 'extraData';
-const { LOG_LEVEL } = process.env;
-const envLevelInt = parseInt(LOG_LEVEL ?? '1', 10);
-const winstonConfigLevel = ['debug', 'info', 'warn', 'error'];
-const printLog = (info) => {
-    let extraData = '';
-    if (info?.[metadataKey]) {
-        extraData += ` ${JSON.stringify(info[metadataKey])}`;
-    }
-    return `${info.timestamp} ${info.level}: ${info.message}${extraData}`;
-};
-exports.printLog = printLog;
-// Doc: https://github.com/winstonjs/winston?tab=readme-ov-file#creating-your-own-logger
-const logger = (0, winston_1.createLogger)({
-    level: winstonConfigLevel[envLevelInt],
-    format: combine(timestamp({
-        format: 'YYYY-MM-DD HH:mm:ss',
-    }), errors({ stack: true }), splat(), metadata({
-        key: metadataKey,
-        fillExcept: [
-            'timestamp',
-            'level',
-            'message',
-            'stack',
-            'destinationResponse',
-            'authErrorCategory',
-        ],
-    }), printf(exports.printLog), json()),
-    transports: [new winston_1.transports.Console()],
-});
-/**
- * Logically below method puts structured logger methods into logger instance with required labels such as
- * - destinationId
- * - workspaceId
- * - module
- * - implementation
- * - sourceId
- * - destinationType
  *
- * **Note**: presence of anyone of them is supported at this point
+ * @example
+ * const logger = structuredLogger({levels: {error:0,warn:1,info:2,debug:3}})
+ *
+ * @param opts
+ * @returns
  */
-const objectLogger = Object.entries({
-    debugw: 'debug',
-    infow: 'info',
-    warnw: 'warning',
-    errorw: 'error',
-}).reduce((agg, curr) => {
-    const [custLogMethod, winstonLogLevel] = curr;
-    const method = (msg, ex) => {
-        const loggableExtraData = {
-            ...(ex?.destinationId && { destinationId: ex.destinationId }),
-            ...(ex?.workspaceId && { workspaceId: ex.workspaceId }),
-            ...(ex?.destinationType && { destinationType: ex.destinationType }),
-            ...(ex?.sourceId && { sourceId: ex.sourceId }),
-            ...(ex?.module && { module: ex.module }),
-            ...(ex?.implementation && { implementation: ex.implementation }),
+const structuredLogger = (opts) => {
+    let levels = opts?.levels ?? {};
+    if (Object.keys(levels).length === 0) {
+        levels = constants_1.LOGLEVELS;
+    }
+    // Doc: https://github.com/winstonjs/winston?tab=readme-ov-file#creating-your-own-logger
+    const logger = (0, winston_1.createLogger)({
+        level: getLogLevel(opts?.level || 'error'),
+        levels,
+        format: combine(timestamp({
+            format: 'YYYY-MM-DD HH:mm:ssZ',
+        }), errors({ stack: true }), splat(), metadata({
+            key: metadataKey,
+            fillExcept: [
+                'timestamp',
+                'level',
+                'message',
+                'stack',
+                'destinationResponse',
+                'authErrorCategory',
+                ...(opts?.fillExcept || fillExceptFields),
+            ],
+        }), json()),
+        transports: [new winston_1.transports.Console()],
+    });
+    /**
+     * Logically below method puts structured logger methods into logger instance with required labels such as
+     * - destinationId
+     * - workspaceId
+     * - module
+     * - implementation
+     * - sourceId
+     * - destinationType
+     *
+     * **Note**: presence of anyone of them is supported at this point
+     */
+    const objectLogger = Object.entries({
+        debugw: 'debug',
+        infow: 'info',
+        warnw: 'warning',
+        errorw: 'error',
+    }).reduce((agg, curr) => {
+        const [custLogMethod, winstonLogLevel] = curr;
+        const method = (msg, ex) => {
+            const loggableExtraData = {
+                ...(ex?.destinationId && { destinationId: ex.destinationId }),
+                ...(ex?.workspaceId && { workspaceId: ex.workspaceId }),
+                ...(ex?.destinationType && { destinationType: ex.destinationType }),
+                ...(ex?.sourceId && { sourceId: ex.sourceId }),
+                ...(ex?.module && { module: ex.module }),
+                ...(ex?.implementation && { implementation: ex.implementation }),
+                ...(ex?.feature && { implementation: ex.feature }),
+            };
+            if (typeof msg === 'object') {
+                const { message, ...others } = msg;
+                logger.log(winstonLogLevel, message, { ...others, ...loggableExtraData });
+                return;
+            }
+            logger.log(winstonLogLevel, msg, loggableExtraData);
         };
-        if (typeof msg === 'object') {
-            const { message, ...others } = msg;
-            logger.log(winstonLogLevel, message, { ...others, ...loggableExtraData });
-            return;
-        }
-        logger.log(winstonLogLevel, msg, loggableExtraData);
+        return { ...agg, [custLogMethod]: method };
+    }, { errorw: () => { }, infow: () => { }, debugw: () => { }, warnw: () => { } });
+    const setLogLevel = (level) => {
+        logger.level = getLogLevel(level);
     };
-    return { ...agg, [custLogMethod]: method };
-}, { errorw: () => { }, infow: () => { }, debugw: () => { }, warnw: () => { } });
-exports.structuredLogger = Object.assign(logger, objectLogger);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"structured-logger.js","sourceRoot":"","sources":["../src/structured-logger.ts"],"names":[],"mappings":"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","sourcesContent":["import { createLogger, transports, format, Logform } from 'winston';\nimport { LoggableExtraData } from './types';\n\n/**\n * We are trying to create structured logging methods.\n * Whenever someone would like to log something using structured logging, they can use these methods to do so.\n * Structured logger methods:\n * - debugw\n * - infow\n * - warnw\n * - errorw\n *\n * Example for how should one use this logger:\n *  logger.infow(\"my error message\", { destinationId: \"destId\", workspaceId: \"wspId\", destinationType: \"dest_type\" }) // preferred\n *  logger.infow({ message: \"my error message-2\", destinationId: \"destId\", workspaceId: \"wspId\",  destinationType: \"dest_type\" })\n */\n\nconst { timestamp, combine, metadata, printf, errors, json, splat } = format;\n\nconst metadataKey = 'extraData';\n\nconst { LOG_LEVEL } = process.env;\n\nconst envLevelInt = parseInt(LOG_LEVEL ?? '1', 10);\nconst winstonConfigLevel = ['debug', 'info', 'warn', 'error'];\n\nexport const printLog = (info: Logform.TransformableInfo): string => {\n  let extraData = '';\n  if (info?.[metadataKey]) {\n    extraData += ` ${JSON.stringify(info[metadataKey])}`;\n  }\n  return `${info.timestamp} ${info.level}: ${info.message}${extraData}`;\n};\n\n// Doc: https://github.com/winstonjs/winston?tab=readme-ov-file#creating-your-own-logger\nconst logger = createLogger({\n  level: winstonConfigLevel[envLevelInt],\n  format: combine(\n    timestamp({\n      format: 'YYYY-MM-DD HH:mm:ss',\n    }),\n    errors({ stack: true }),\n    splat(),\n    metadata({\n      key: metadataKey,\n      fillExcept: [\n        'timestamp',\n        'level',\n        'message',\n        'stack',\n        'destinationResponse',\n        'authErrorCategory',\n      ],\n    }),\n    printf(printLog),\n    json(),\n  ),\n  transports: [new transports.Console()],\n});\n\ninterface LeveledLogMethod {\n  (message: string, extraData?: Partial<LoggableExtraData>): void;\n  (infoObject: { message: string } & Partial<LoggableExtraData>): void;\n}\n\ninterface CustLogger {\n  errorw: LeveledLogMethod;\n  infow: LeveledLogMethod;\n  debugw: LeveledLogMethod;\n  warnw: LeveledLogMethod;\n}\n/**\n * Logically below method puts structured logger methods into logger instance with required labels such as\n * - destinationId\n * - workspaceId\n * - module\n * - implementation\n * - sourceId\n * - destinationType\n *\n * **Note**: presence of anyone of them is supported at this point\n */\nconst objectLogger: CustLogger = Object.entries({\n  debugw: 'debug',\n  infow: 'info',\n  warnw: 'warning',\n  errorw: 'error',\n}).reduce(\n  (agg, curr) => {\n    const [custLogMethod, winstonLogLevel] = curr;\n\n    const method = (\n      msg: string | ({ message: string } & Partial<LoggableExtraData>),\n      ex?: Partial<LoggableExtraData>,\n    ) => {\n      const loggableExtraData: Partial<LoggableExtraData> = {\n        ...(ex?.destinationId && { destinationId: ex.destinationId }),\n        ...(ex?.workspaceId && { workspaceId: ex.workspaceId }),\n        ...(ex?.destinationType && { destinationType: ex.destinationType }),\n        ...(ex?.sourceId && { sourceId: ex.sourceId }),\n        ...(ex?.module && { module: ex.module }),\n        ...(ex?.implementation && { implementation: ex.implementation }),\n      };\n      if (typeof msg === 'object') {\n        const { message, ...others } = msg;\n        logger.log(winstonLogLevel, message, { ...others, ...loggableExtraData });\n        return;\n      }\n      logger.log(winstonLogLevel, msg, loggableExtraData);\n    };\n    return { ...agg, [custLogMethod]: method };\n  },\n  { errorw: () => {}, infow: () => {}, debugw: () => {}, warnw: () => {} },\n);\n\nexport const structuredLogger = Object.assign(logger, objectLogger);\n"]}
+    return Object.assign(logger, objectLogger, {
+        setLogLevel,
+        getLogLevel,
+    });
+};
+exports.structuredLogger = structuredLogger;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"structured-logger.js","sourceRoot":"","sources":["../src/structured-logger.ts"],"names":[],"mappings":"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","sourcesContent":["import { createLogger, transports, format } from 'winston';\nimport { LoggableExtraData } from './types';\nimport { LOGLEVELS } from './constants';\n\nconst { timestamp, combine, metadata, errors, json, splat } = format;\n\nconst metadataKey = 'logMetadata';\nconst fillExceptFields = [\n  'destinationId',\n  'sourceId',\n  'destinationType',\n  'workspaceId',\n  'module',\n  'implementation',\n  'feature',\n];\n\nconst getLogLevel = (level: string) => {\n  if (LOGLEVELS[level] === undefined || LOGLEVELS[level] === null) {\n    return 'error'; // when loglevel is invalid\n  }\n  return level;\n};\n\ninterface LeveledLogMethod {\n  (message: string, extraData?: Partial<LoggableExtraData>): void;\n  (infoObject: { message: string } & Partial<LoggableExtraData>): void;\n}\n\ninterface CustLogger {\n  errorw: LeveledLogMethod;\n  infow: LeveledLogMethod;\n  debugw: LeveledLogMethod;\n  warnw: LeveledLogMethod;\n}\n\nexport type LogOpts = {\n  level?: string;\n  fillExcept?: string[];\n  levels?: Record<string, number>;\n};\n/**\n * Structured logger powered by winston\n * We are trying to create structured logging methods.\n * Whenever someone would like to log something using structured logging, they can use these methods to do so.\n * Structured logger methods:\n * - debugw\n * - infow\n * - warnw\n * - errorw\n * Note: While using levels option, we need to make sure that lowest level(debug) has a value higher than higher level(warn)\n *\n * @example\n *  const logger = structuredLogger();\n *  logger.setLogLevel('warn')\n *  logger.warn('my warning', {...})\n * @example\n *  const logger = structuredLogger({level: 'info'});\n *\n *  @example\n *  logger.infow(\"my error message\", { destinationId: \"destId\", workspaceId: \"wspId\", destinationType: \"dest_type\" }) // preferred\n *  logger.infow({ message: \"my error message-2\", destinationId: \"destId\", workspaceId: \"wspId\",  destinationType: \"dest_type\" })\n *\n * @example\n * const logger = structuredLogger({levels: {error:0,warn:1,info:2,debug:3}})\n *\n * @param opts\n * @returns\n */\nexport const structuredLogger = (opts?: LogOpts) => {\n  let levels = opts?.levels ?? {};\n  if (Object.keys(levels).length === 0) {\n    levels = LOGLEVELS;\n  }\n  // Doc: https://github.com/winstonjs/winston?tab=readme-ov-file#creating-your-own-logger\n  const logger = createLogger({\n    level: getLogLevel(opts?.level || 'error'),\n    levels,\n    format: combine(\n      timestamp({\n        format: 'YYYY-MM-DD HH:mm:ssZ',\n      }),\n      errors({ stack: true }),\n      splat(),\n      metadata({\n        key: metadataKey,\n        fillExcept: [\n          'timestamp',\n          'level',\n          'message',\n          'stack',\n          'destinationResponse',\n          'authErrorCategory',\n          ...(opts?.fillExcept || fillExceptFields),\n        ],\n      }),\n      json(),\n    ),\n    transports: [new transports.Console()],\n  });\n\n  /**\n   * Logically below method puts structured logger methods into logger instance with required labels such as\n   * - destinationId\n   * - workspaceId\n   * - module\n   * - implementation\n   * - sourceId\n   * - destinationType\n   *\n   * **Note**: presence of anyone of them is supported at this point\n   */\n  const objectLogger: CustLogger = Object.entries({\n    debugw: 'debug',\n    infow: 'info',\n    warnw: 'warning',\n    errorw: 'error',\n  }).reduce(\n    (agg, curr) => {\n      const [custLogMethod, winstonLogLevel] = curr;\n\n      const method = (\n        msg: string | ({ message: string } & Partial<LoggableExtraData>),\n        ex?: Partial<LoggableExtraData>,\n      ) => {\n        const loggableExtraData: Partial<LoggableExtraData> = {\n          ...(ex?.destinationId && { destinationId: ex.destinationId }),\n          ...(ex?.workspaceId && { workspaceId: ex.workspaceId }),\n          ...(ex?.destinationType && { destinationType: ex.destinationType }),\n          ...(ex?.sourceId && { sourceId: ex.sourceId }),\n          ...(ex?.module && { module: ex.module }),\n          ...(ex?.implementation && { implementation: ex.implementation }),\n          ...(ex?.feature && { implementation: ex.feature }),\n        };\n        if (typeof msg === 'object') {\n          const { message, ...others } = msg;\n          logger.log(winstonLogLevel, message, { ...others, ...loggableExtraData });\n          return;\n        }\n        logger.log(winstonLogLevel, msg, loggableExtraData);\n      };\n      return { ...agg, [custLogMethod]: method };\n    },\n    { errorw: () => {}, infow: () => {}, debugw: () => {}, warnw: () => {} },\n  );\n\n  const setLogLevel = (level: string) => {\n    logger.level = getLogLevel(level);\n  };\n\n  return Object.assign(logger, objectLogger, {\n    setLogLevel,\n    getLogLevel,\n  });\n};\n"]}

package/build/structured-logger.test.js

@@ -24,36 +24,34 @@ jest.mock('winston', () => ({
 }));
 // eslint-disable-next-line import/first
 const structured_logger_1 = require("./structured-logger");
-const printLogTestCases = [
-    {
-        description: 'should show log correctly when extraData is not available',
-        input: { message: 'some error - 1', level: 'warning', timestamp: 'Jan-12-2024 00:01:02' },
-        output: 'Jan-12-2024 00:01:02 warning: some error - 1',
-    },
-    {
-        description: 'should show log with stringified extraData when extraData is available',
-        input: {
-            message: 'some error - 2',
-            level: 'warning',
-            timestamp: 'Jan-12-2024 00:01:02',
-            extraData: { workspaceId: '21' },
-        },
-        output: 'Jan-12-2024 00:01:02 warning: some error - 2 {"workspaceId":"21"}',
-    },
-];
-describe('printLog tests', () => {
-    test.each(printLogTestCases)('$description', ({ input, output }) => {
-        expect((0, structured_logger_1.printLog)(input)).toEqual(output);
+const testLogger = (0, structured_logger_1.structuredLogger)(); // initialising logger
+describe('Structured logger setLogLevel tests', () => {
+    test('set a debug level', () => {
+        testLogger.setLogLevel('debug');
+        expect(testLogger.level).toBe('debug');
+    });
+    test('set a info level', () => {
+        testLogger.setLogLevel('info');
+        expect(testLogger.level).toBe('info');
+    });
+    test('set an improper level(invalid loglevel)', () => {
+        testLogger.setLogLevel('22');
+        expect(testLogger.level).toBe('error');
+    });
+    test('set an improper level(undefined)', () => {
+        // @ts-expect-error this is not possible
+        testLogger.setLogLevel(undefined);
+        expect(testLogger.level).toBe('error');
     });
 });
 describe('Structured logging tests', () => {
     test('testing logger errorw function', () => {
-        structured_logger_1.structuredLogger.errorw('Some error', { destinationId: 'd1' });
+        testLogger.errorw('Some error', { destinationId: 'd1' });
         expect(logger.log).toHaveBeenCalled();
         expect(logger.log).toHaveBeenCalledWith('error', 'Some error', { destinationId: 'd1' });
     });
     test('testing logger debugw function', () => {
-        structured_logger_1.structuredLogger.debugw('Some error-2', {
+        testLogger.debugw('Some error-2', {
             destinationId: 'd1',
             workspaceId: 'w1',
             destinationType: 'd',
@@ -72,7 +70,7 @@ describe('Structured logging tests', () => {
         });
     });
     test('testing logger warnw function', () => {
-        structured_logger_1.structuredLogger.warnw({
+        testLogger.warnw({
             message: 'some error - 3',
             destinationId: 'd1',
             workspaceId: 'w1',
@@ -92,4 +90,4 @@ describe('Structured logging tests', () => {
         });
     });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rudderstack/integrations-lib",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "",
   "main": "build/index.js",
   "module": "build/index.js",