@koralabs/kora-labs-common 1.0.0 → 1.0.2

package/lib/environment/index.d.ts

@@ -0,0 +1,21 @@
+export declare enum ComputeEnvironment {
+    AWS_LAMBDA = "aws_lambda",
+    AWS_FARGATE = "aws_fargate",
+    AWS_EC2 = "aws_ec2",
+    AWS_OTHER = "aws_other",
+    OTHER = "other"
+}
+export declare class Environment {
+    static getComputeEnvironment(): Promise<ComputeEnvironment>;
+    static getIpAddress(): Promise<{
+        private: string | null;
+        public: string | null;
+    } | null>;
+    static getEc2InstanceName(): Promise<string | null>;
+    static getEcsTaskMetaData(): Promise<{
+        Networks: [{
+            IPv4Addresses: [string];
+        }];
+    } | null>;
+    static getPotentialApplicationName(): Promise<string | null>;
+}

package/lib/environment/index.js

@@ -0,0 +1,123 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Environment = exports.ComputeEnvironment = void 0;
+var ComputeEnvironment;
+(function (ComputeEnvironment) {
+    ComputeEnvironment["AWS_LAMBDA"] = "aws_lambda";
+    ComputeEnvironment["AWS_FARGATE"] = "aws_fargate";
+    ComputeEnvironment["AWS_EC2"] = "aws_ec2";
+    ComputeEnvironment["AWS_OTHER"] = "aws_other";
+    ComputeEnvironment["OTHER"] = "other";
+})(ComputeEnvironment = exports.ComputeEnvironment || (exports.ComputeEnvironment = {}));
+class Environment {
+    static getComputeEnvironment() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (process.env.AWS_LAMBDA_FUNCTION_NAME || process.env.AWS_EXECUTION_ENV) {
+                return ComputeEnvironment.AWS_LAMBDA;
+            }
+            if (process.env.ECS_CLUSTER) {
+                return ComputeEnvironment.AWS_FARGATE;
+            }
+            if (yield Environment.getEc2InstanceName()) {
+                return ComputeEnvironment.AWS_EC2;
+            }
+            if (process.env.AWS_DEFAULT_REGION || process.env.AWS_REGION) {
+                return ComputeEnvironment.AWS_OTHER;
+            }
+            return ComputeEnvironment.OTHER;
+        });
+    }
+    static getIpAddress() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            let prv;
+            let pub;
+            if ((yield Environment.getComputeEnvironment()) == ComputeEnvironment.AWS_EC2) {
+                try {
+                    const response = yield fetch('http://169.254.169.254/latest/meta-data/local-ipv4');
+                    prv = yield response.text();
+                }
+                catch (_c) {
+                }
+                try {
+                    const response = yield fetch('http://169.254.169.254/latest/meta-data/public-ipv4');
+                    pub = yield response.text();
+                }
+                catch (_d) {
+                }
+                if (prv || pub) {
+                    return { private: prv !== null && prv !== void 0 ? prv : null, public: pub !== null && pub !== void 0 ? pub : null };
+                }
+            }
+            if ((yield Environment.getComputeEnvironment()) == ComputeEnvironment.AWS_EC2) {
+                const metadata = yield Environment.getEcsTaskMetaData();
+                return { private: (_b = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.Networks[0]) === null || _a === void 0 ? void 0 : _a.IPv4Addresses[0]) !== null && _b !== void 0 ? _b : null, public: null };
+            }
+            return null;
+        });
+    }
+    static getEc2InstanceName() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield fetch('http://169.254.169.254/latest/meta-data/tags/instance/Name');
+                return response.text();
+            }
+            catch (err) {
+            }
+            try {
+                const response = yield fetch('http://169.254.169.254/latest/meta-data/instance-id');
+                return response.text();
+            }
+            catch (err) {
+            }
+            return null;
+        });
+    }
+    static getEcsTaskMetaData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield fetch('http://169.254.170.2/v2/metadata');
+                return yield response.json();
+            }
+            catch (err) {
+                return null;
+            }
+        });
+    }
+    static getPotentialApplicationName() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (process.env.APPLICATION_NAME) {
+                return process.env.APPLICATION_NAME;
+            }
+            if ((yield Environment.getComputeEnvironment()) == ComputeEnvironment.AWS_LAMBDA) {
+                return (_a = process.env.AWS_LAMBDA_FUNCTION_NAME) !== null && _a !== void 0 ? _a : null;
+            }
+            if ((yield Environment.getComputeEnvironment()) == ComputeEnvironment.AWS_FARGATE) {
+                return (_b = process.env.ECS_CLUSTER) !== null && _b !== void 0 ? _b : null;
+            }
+            if ((yield Environment.getComputeEnvironment()) == ComputeEnvironment.AWS_EC2) {
+                const ec2_name = yield Environment.getEc2InstanceName();
+                if (ec2_name) {
+                    return ec2_name;
+                }
+            }
+            try {
+                return process.cwd();
+            }
+            catch (_c) {
+                return null;
+            }
+        });
+    }
+}
+exports.Environment = Environment;

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { Logger } from "./logger";
+export { Environment } from "./environment";

package/lib/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Environment = exports.Logger = void 0;
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
+var environment_1 = require("./environment");
+Object.defineProperty(exports, "Environment", { enumerable: true, get: function () { return environment_1.Environment; } });

package/lib/logger/index.d.ts

@@ -0,0 +1,23 @@
+export declare enum LogCategory {
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    WARN = "WARN",
+    ERROR = "ERROR",
+    FATAL = "FATAL",
+    NOTIFY = "NOTIFY",
+    METRIC = "METRIC"
+}
+export declare class Logger {
+    static application: string;
+    private static isInitialized;
+    static initialize(): Promise<void>;
+    static log(args: {
+        message: string;
+        category?: LogCategory;
+        event?: string;
+        milliseconds?: number;
+        count?: number;
+        dimensions?: string[];
+    } | string): void;
+    private static log_entry;
+}

package/lib/logger/index.js

@@ -0,0 +1,71 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LogCategory = void 0;
+const environment_1 = require("../environment");
+// Fix from https://stackoverflow.com/questions/18391212/is-it-not-possible-to-stringify-an-error-using-json-stringify
+if (!('toJSON' in Error.prototype))
+    Object.defineProperty(Error.prototype, 'toJSON', {
+        value: function () {
+            const alt = {};
+            Object.getOwnPropertyNames(this).forEach((key) => {
+                alt[key] = this[key];
+            }, this);
+            return alt;
+        },
+        configurable: true,
+        writable: true
+    });
+var LogCategory;
+(function (LogCategory) {
+    LogCategory["DEBUG"] = "DEBUG";
+    LogCategory["INFO"] = "INFO";
+    LogCategory["WARN"] = "WARN";
+    LogCategory["ERROR"] = "ERROR";
+    LogCategory["FATAL"] = "FATAL";
+    LogCategory["NOTIFY"] = "NOTIFY";
+    LogCategory["METRIC"] = "METRIC";
+})(LogCategory = exports.LogCategory || (exports.LogCategory = {}));
+class Logger {
+    static initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!Logger.application) {
+                const potentialName = yield environment_1.Environment.getPotentialApplicationName();
+                if (!potentialName) {
+                    throw new Error("Logger.application must be set!");
+                }
+                Logger.application = potentialName;
+            }
+            Logger.isInitialized = true;
+        });
+    }
+    static log(args) {
+        if (!Logger.isInitialized)
+            Logger.initialize();
+        if (typeof args === 'string') {
+            this.log_entry(LogCategory.INFO, args);
+            return;
+        }
+        const { message, category, event, milliseconds, count, dimensions } = args;
+        this.log_entry(category !== null && category !== void 0 ? category : LogCategory.INFO, message, event, milliseconds, count, dimensions);
+    }
+    static log_entry(category, message, event, milliseconds, count, dimensions) {
+        const now = new Date().toISOString();
+        message = message.replace(/\\/g, '\\\\').replace(/"/g, '\\"'); // escape double quotes and already escaped escapes
+        const log_event = event ? `, "event": "${event}"` : '';
+        const log_milliseconds = milliseconds != undefined && milliseconds != null ? `, "milliseconds": ${milliseconds}` : '';
+        const log_count = count != undefined && count != null ? `, "count": ${count}` : '';
+        const log_dimensions = dimensions && Object.keys(dimensions).length ? `, "dimensions": ${JSON.stringify(dimensions)}` : '';
+        console.log(`{ "category": "${category !== null && category !== void 0 ? category : LogCategory.INFO}", "message": "${message}"${log_event}, "timestamp": "${now}"${log_milliseconds}${log_count}${log_dimensions} }`);
+    }
+}
+exports.Logger = Logger;
+Logger.isInitialized = false;

package/lib/logger/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/logger/index.test.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+describe('Logger Tests', () => {
+    it('should log', () => {
+        const now = Date.now();
+        const logSpy = jest.spyOn(console, 'log');
+        _1.Logger.log({
+            message: 'burritos',
+            category: _1.LogCategory.ERROR,
+            event: 'test.log',
+            milliseconds: now,
+            count: 1,
+            dimensions: ['taco']
+        });
+        const call = logSpy.mock.calls[0][0];
+        const obj = JSON.parse(call);
+        expect(obj).toEqual({
+            category: 'ERROR',
+            count: 1,
+            dimensions: ['taco'],
+            event: 'test.log',
+            message: 'burritos',
+            milliseconds: now,
+            timestamp: expect.stringMatching(/[0-9\-]+T[0-9\:\.]+Z/)
+        });
+    });
+});

package/package.json

@@ -1,7 +1,9 @@
 {
   "name": "@koralabs/kora-labs-common",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Kora Labs Common Utilities",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "homepage": "https://github.com/koralabs/kora-labs-common",
   "repository": {
     "type": "git",