Initial upload

Author: SharonGrossman

.gitignore

@@ -0,0 +1,9 @@
+node_modules
+npm-debug.log
+.env
+.idea
+.npmrc
+yarn.*
+.vscode
+yarn-error.log
+dist

.npmignore

@@ -0,0 +1,9 @@
+node_modules
+npm-debug.log
+.env
+.idea
+.npmrc
+yarn.*
+.vscode
+yarn-error.log
+example

.prettierignore

@@ -0,0 +1,4 @@
+package.json
+node_modules
+dist
+coverage

.prettierrc.yml

@@ -0,0 +1,5 @@
+trailingComma: es5
+singleQuote: true
+printWidth: 120
+tabWidth: 4
+bracketSpacing: false

CHANGELOG.md

@@ -0,0 +1 @@
+# Changelog

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Soluto by Asurion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1 +1,108 @@
 # monitored
+
+A utility for monitoring services
+
+# API
+
+### setGlobalInstance
+
+In order to wire this pacakge you need to pass `Options` object.
+
+`serviceName` - represents the name of the service you are monitoring (mandatory)
+
+`logger` - writes success and error logs with the passed in logger (optional)
+
+`statsd` - writes metrics to statsd server (optional)
+
+```
+setGlobalInstance(new Monitor({
+    serviceName: 'monitored-example',
+    logging: {
+        logger,
+        logErrorsAsWarnings?: true,
+        defaultParseError?: e => new Error(e.message + " defaultParseError")
+
+    },
+    statsd: {
+        apiKey: 'STATSD_API_KEY',
+        root: 'testing',
+        host: 'STATSD_HOST',
+    },
+    shouldMonitorExecutionStart?: boolean; //when true will log execution start and will increment a metrics. defaults to true
+}));
+```
+
+### monitored
+
+Wrapper function that write success/error logs and statsd metrics (gague, increment, timing) after execution.
+It supports both asynchronous and synchronous functions:
+
+```
+
+const asyncFunc1 = monitored('foo1', () => {
+    console.log('bar1');
+    return Promise.resolve();
+});
+
+const asyncFunc2 = monitored('foo2', async () => {
+    await Promise.resolve();
+    console.log('bar1');
+});
+
+const syncFunc = monitored('foo3', () => {
+    console.log('bar2');
+});
+```
+
+You can pass `options` argument to `monitored`:
+
+```
+type MonitoredOptions = {
+    context?; //add more inforamtion to the logs
+    logResult?: boolean; //should write log of the method start and success
+    parseResult?: (e: any) => any; //custom parser for result (in case it is logged)
+    parseError?: (e: any) => any; //custom parser for different types of errors
+    level?: 'info' | 'debug'; //which log level to write (debug is the default)
+    logAsError?: boolean; //enables to write error log in case the global `logErrorsAsWarnings` is on
+    logErrorAsInfo?: boolean //enables to write the errpr as info log
+    shouldMonitorError: e => boolean //determines if error should be monitored and logged, defaults to true
+    shouldMonitorSuccess: (r: T) => boolean //determines if success result should be monitored and logged, defaults to true 
+
+};
+```
+
+```
+const foo3 = monitored('foo3', () => {
+    console.log('bar3');
+}, {context: {id: 'some context'}});
+```
+
+Also you can log the function result by setting `logResult` to `true`:
+
+```
+const foo4 = monitored('foo4', () => {
+    console.log('bar4');
+}, {context: {id: 'some context'}, logResult: true});
+```
+
+Full usage documentation is details in `Testing` section
+
+### getStatsdClient
+
+Returns the StatsD client directly, in order to write custom metrics
+
+### flush
+
+Wait for all current metric to be sent to server.
+You should use it in the end of lambda execution to make sure all metrics are sent.
+
+```
+await monitor.flush(timeout: number = 2000)
+```
+
+
+## Testing
+
+1. Create `.env` file with `STATSD_API_KEY` and `STATSD_HOST` values
+2. Run `yarn example`
+3. Verify manually that console logs and metrics in the statsd server are valid

__tests__/AsyncStatsD.spec.ts

@@ -0,0 +1,135 @@
+import {MonitorOptions} from '../src';
+import {AsyncStatsD} from '../src/AsyncStatsD';
+import {mocked} from 'ts-jest/utils';
+import {StatsCb} from 'hot-shots';
+import { Logger } from '../src/Logger';
+import {consoleLogger} from '../src/loggers';
+
+jest.mock('hot-shots');
+
+const statsdOptions: MonitorOptions['statsd'] = {
+    apiKey: 'key',
+    host: 'host',
+    root: 'root',
+};
+
+let client: AsyncStatsD;
+
+describe('AsyncStatsD', () => {
+    beforeEach(() => {
+        jest.resetAllMocks();
+        client = new AsyncStatsD(new Logger(consoleLogger), statsdOptions);
+    });
+
+    describe('increment', () => {
+        test('success', async () => {
+            mockStatsdCallback(client.statsd.increment, undefined);
+            await expect(client.increment('test', 3)).resolves.toEqual(undefined);
+
+            expect(mocked(client.statsd.increment)).toHaveBeenCalledWith('test', 3, expect.any(Function));
+        });
+
+        test('success - use default value', async () => {
+            mockStatsdCallback(client.statsd.increment, undefined);
+            await expect(client.increment('test')).resolves.toEqual(undefined);
+
+            expect(mocked(client.statsd.increment)).toHaveBeenCalledWith('test', 1, expect.any(Function));
+        });
+
+        test('error', async () => {
+            mockStatsdCallback(client.statsd.increment, {error: 'err'});
+
+            await expect(client.increment('test', 3)).resolves.toEqual(undefined);
+
+            expect(mocked(client.statsd.increment)).toHaveBeenCalledWith('test', 3, expect.any(Function));
+        });
+    });
+
+    describe('timing', () => {
+        test('success', async () => {
+            mockStatsdCallback(client.statsd.timing, undefined);
+            await expect(client.timing('test', 2000)).resolves.toEqual(undefined);
+
+            expect(mocked(client.statsd.timing)).toHaveBeenCalledWith('test', 2000, expect.any(Function));
+        });
+
+        test('error', async () => {
+            mockStatsdCallback(client.statsd.timing, {error: 'err'});
+
+            await expect(client.timing('test', 2000)).resolves.toEqual(undefined);
+
+            expect(mocked(client.statsd.timing)).toHaveBeenCalledWith('test', 2000, expect.any(Function));
+        });
+    });
+
+    describe('gauge', () => {
+        test('success', async () => {
+            mockStatsdCallback(client.statsd.gauge, undefined);
+            await expect(client.gauge('test', 1)).resolves.toEqual(undefined);
+
+            expect(mocked(client.statsd.gauge)).toHaveBeenCalledWith('test', 1, expect.any(Function));
+        });
+
+        test('error', async () => {
+            mockStatsdCallback(client.statsd.gauge, {error: 'err'});
+
+            await expect(client.gauge('test', 1)).resolves.toEqual(undefined);
+
+            expect(mocked(client.statsd.gauge)).toHaveBeenCalledWith('test', 1, expect.any(Function));
+        });
+    });
+
+    describe('flush', () => {
+        test('success', async () => {
+            mockStatsdCallback(client.statsd.increment);
+            client.increment('test', 3);
+            client.increment('test', 3);
+
+            mockStatsdCallback(client.statsd.timing, {delay: 1000});
+            client.timing('asjkdsajk', 1000);
+
+            await expect(client.flush()).resolves.toEqual(true);
+        });
+
+        test('timeout', async () => {
+            mockStatsdCallback(client.statsd.increment);
+            client.increment('test', 3);
+            client.increment('test', 3);
+
+            mockStatsdCallback(client.statsd.timing, {delay: 1500});
+            client.timing('asjkdsajk', 1000);
+
+            await expect(client.flush(1000)).resolves.toEqual(false);
+        });
+
+        test('success - some promises return errors', async () => {
+            try {
+                mockStatsdCallback(client.statsd.increment);
+                client.increment('test', 3);
+                client.increment('test', 3);
+
+                mockStatsdCallback(client.statsd.timing, {delay: 1000, error: 'errrrrrr'});
+                client.timing('asjkdsajk', 1000);
+
+                mockStatsdCallback(client.statsd.increment, {delay: 1000, error: 'err2'});
+                client.increment('test', 3);
+                client.increment('test', 3);
+
+                await expect(client.flush(2000)).resolves.toEqual(true);
+            } catch (err) {}
+        });
+    });
+});
+
+interface MockStatsdCallbackOptions {
+    delay?: number;
+    error?: any;
+}
+
+function mockStatsdCallback(func: (_a: string, _b: number, cb: StatsCb) => void, opts: MockStatsdCallbackOptions = {}) {
+    const {delay = 50, error = undefined} = opts;
+
+    mocked(func).mockImplementation((_a, _b, cb) => {
+        setTimeout(() => cb(error, undefined), delay);
+    });
+}

__tests__/__mocks__/AsyncStatsD.ts

@@ -0,0 +1,9 @@
+export class AsyncStatsD {
+    constructor() {}
+
+    increment = jest.fn();
+    gauge = jest.fn();
+    timing = jest.fn();
+    close = jest.fn();
+    flush = jest.fn();
+}

__tests__/monitor.spec.ts

@@ -0,0 +1,309 @@
+import {mocked} from 'ts-jest/utils';
+import Monitor from '../src/Monitor';
+import {consoleLogger} from '../src/loggers';
+import {MonitorOptions} from '../src';
+import {
+    assertIncrementWasCalled,
+    assertIncrementWasNotCalled,
+    assertTimingWasCalled,
+    assertGaugeWasCalled,
+} from './utils';
+
+jest.mock('../AsyncStatsD');
+jest.mock('../loggers', () => ({
+    consoleLogger: {
+        info: jest.fn(),
+        debug: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+    },
+    emptyLogger: {
+        info: jest.fn(),
+        debug: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+    },
+}));
+jest.mock('../parseError', () => ({
+    default: err => err,
+}));
+
+const statsdOptions: MonitorOptions['statsd'] = {
+    apiKey: 'key',
+    host: 'host',
+    root: 'root',
+};
+
+const defaultMonitorOptions: MonitorOptions = {
+    serviceName: 'test-service',
+    statsd: statsdOptions,
+};
+
+describe('Monitor', () => {
+    beforeEach(() => {
+        jest.resetAllMocks();
+    });
+
+    describe('monitored', () => {
+        describe('validate result', () => {
+            test('sync function', async () => {
+                const mockReturn = 10;
+                const mockFunc = jest.fn().mockReturnValue(mockReturn);
+                const monitor = new Monitor({...defaultMonitorOptions});
+
+                const res = monitor.monitored('test', mockFunc);
+
+                expect(mockFunc).toBeCalledTimes(1);
+                expect(res).toEqual(mockReturn);
+            });
+
+            test('async function', async () => {
+                const mockReturn = 10;
+                const mockFunc = jest.fn().mockResolvedValue(mockReturn);
+                const monitor = new Monitor({...defaultMonitorOptions});
+
+                const res = await monitor.monitored('test', mockFunc);
+
+                expect(mockFunc).toBeCalledTimes(1);
+                expect(res).toEqual(mockReturn);
+            });
+
+            test('sync function throws', async () => {
+                const mockError = new Error('error');
+                const mockFunc = jest.fn(() => {
+                    throw mockError;
+                });
+                const monitor = new Monitor({...defaultMonitorOptions});
+
+                try {
+                    monitor.monitored('test', mockFunc);
+
+                    fail('should throw error');
+                } catch (err) {
+                    expect(err).toEqual(mockError);
+                }
+
+                expect(mockFunc).toBeCalledTimes(1);
+            });
+
+            test('async function throws', async () => {
+                const mockError = new Error('error');
+                const mockFunc = jest.fn().mockRejectedValue(mockError);
+                const monitor = new Monitor({...defaultMonitorOptions});
+
+                try {
+                    await monitor.monitored('test', mockFunc);
+
+                    fail('should throw error');
+                } catch (err) {
+                    expect(err).toEqual(mockError);
+                }
+
+                expect(mockFunc).toBeCalledTimes(1);
+            });
+        });
+
+        describe('shouldMonitorExecutionStart', () => {
+            test('true', async () => {
+                const mockReturn = 10;
+                const mockFunc = jest.fn().mockReturnValue(mockReturn);
+                const monitor = new Monitor({...defaultMonitorOptions, shouldMonitorExecutionStart: true});
+
+                const res = monitor.monitored('test', mockFunc);
+
+                expect(mockFunc).toBeCalledTimes(1);
+                expect(res).toEqual(mockReturn);
+                assertIncrementWasCalled(monitor, 'test.start');
+                expect(mocked(consoleLogger.debug)).toHaveBeenCalledWith('test.start', {extra: undefined});
+            });
+
+            test('false', async () => {
+                const mockReturn = 10;
+                const mockFunc = jest.fn().mockReturnValue(mockReturn);
+                const monitor = new Monitor({...defaultMonitorOptions, shouldMonitorExecutionStart: false});
+
+                const res = monitor.monitored('test', mockFunc);
+
+                expect(mockFunc).toBeCalledTimes(1);
+                expect(res).toEqual(mockReturn);
+                assertIncrementWasNotCalled(monitor, 'test.start');
+                expect(mocked(consoleLogger.debug)).not.toHaveBeenCalledWith('test.start', expect.anything());
+            });
+        });
+
+        describe('result', () => {
+            const mockReturn = 10;
+
+            [false, true].forEach(isAsync => {
+                const mockFunc: any = isAsync
+                    ? () =>
+                          new Promise<number>(resolve => {
+                              resolve(mockReturn);
+                          })
+                    : () => mockReturn;
+
+                describe(`${isAsync ? 'async' : 'sync'} function`, () => {
+                    test('default options', async () => {
+                        const monitor = new Monitor({...defaultMonitorOptions});
+
+                        const res = monitor.monitored('test', mockFunc);
+
+                        if (isAsync) {
+                            await res;
+                        }
+
+                        assertIncrementWasCalled(monitor, 'test.success');
+                        assertGaugeWasCalled(monitor, 'test.ExecutionTime');
+                        assertTimingWasCalled(monitor, 'test.ExecutionTime');
+
+                        expect(mocked(consoleLogger.debug)).toHaveBeenCalledWith('test.success', {
+                            extra: {
+                                executionTime: expect.any(Number),
+                                executionResult: 'NOT_LOGGED',
+                            },
+                        });
+                    });
+
+                    test('send context', async () => {
+                        const context = {a: 'a', b: 'bbbbb', c: true};
+                        const monitor = new Monitor({...defaultMonitorOptions});
+
+                        const res = monitor.monitored('test', mockFunc, {context});
+
+                        if (isAsync) {
+                            await res;
+                        }
+
+                        expect(mocked(consoleLogger.debug)).toHaveBeenCalledWith('test.success', {
+                            extra: {
+                                ...context,
+                                executionTime: expect.any(Number),
+                                executionResult: 'NOT_LOGGED',
+                            },
+                        });
+                    });
+
+                    test('logResult: true', async () => {
+                        const monitor = new Monitor({...defaultMonitorOptions, shouldMonitorExecutionStart: false});
+
+                        const res = monitor.monitored('test', mockFunc, {logResult: true});
+
+                        if (isAsync) {
+                            await res;
+                        }
+
+                        expect(mocked(consoleLogger.debug)).toHaveBeenCalledWith('test.success', {
+                            extra: {
+                                executionTime: expect.any(Number),
+                                executionResult: mockReturn,
+                            },
+                        });
+                    });
+
+                    test('logResult: true with parseResult', async () => {
+                        const monitor = new Monitor({...defaultMonitorOptions});
+                        const mockParsedReturn = 50;
+                        const parseResult = jest.fn().mockReturnValue(mockParsedReturn);
+
+                        let res = monitor.monitored('test', mockFunc, {logResult: true, parseResult});
+
+                        if (isAsync) {
+                            res = await res;
+                        }
+
+                        expect(res).toEqual(mockReturn);
+
+                        expect(mocked(consoleLogger.debug)).toHaveBeenCalledWith('test.success', {
+                            extra: {
+                                executionTime: expect.any(Number),
+                                executionResult: mockParsedReturn,
+                            },
+                        });
+                    });
+                });
+            });
+        });
+
+        describe('error', () => {
+            const mockError = new Error('error');
+
+            [false, true].forEach(isAsync => {
+                const mockFunc: any = isAsync
+                    ? () =>
+                          new Promise<number>((_, reject) => {
+                            reject(mockError);
+                          })
+                    : () => { throw mockError };
+
+                describe(`${isAsync ? 'async' : 'sync'} function`, () => {
+                    test('default options', async () => {
+                        const monitor = new Monitor({...defaultMonitorOptions});
+
+                        try {
+                            const res = monitor.monitored('test', mockFunc);
+
+                            if (isAsync) {
+                                await res;
+                            }
+
+                            fail('Should not success');
+                        } catch (err) {
+                            expect(err).toEqual(mockError);
+
+                            assertIncrementWasCalled(monitor, 'test.error');
+
+                            expect(mocked(consoleLogger.error)).toHaveBeenCalledWith('test.error', {
+                                err: mockError,
+                                extra: undefined
+                            });
+                        }
+                    });
+
+                    test('send context', async () => {
+                        const context = {a: 'a', b: 'bbbbb', c: true};
+                        const monitor = new Monitor({...defaultMonitorOptions});
+
+                        try {
+                            const res = monitor.monitored('test', mockFunc, {context});
+
+                            if (isAsync) {
+                                await res;
+                            }
+
+                            fail('Should not success');
+                        } catch (err) {
+                            expect(err).toEqual(mockError);
+
+                            expect(mocked(consoleLogger.error)).toHaveBeenCalledWith('test.error', {
+                                err: mockError,
+                                extra: context
+                            });
+                        }
+                    });
+
+                    test('with parseError', async () => {
+                        const monitor = new Monitor({...defaultMonitorOptions});
+                        const mockParsedError = 'blabla';
+
+                        try {
+                            const res = monitor.monitored('test', mockFunc, {parseError: () => mockParsedError});
+
+                            if (isAsync) {
+                                await res;
+                            }
+
+                            fail('Should not success');
+                        } catch (err) {
+                            expect(err).toEqual(mockError);
+
+                            expect(mocked(consoleLogger.error)).toHaveBeenCalledWith('test.error', {
+                                err: mockParsedError,
+                                extra: undefined
+                            });
+                        }
+                    });
+                });
+            });
+        });
+    });
+});

__tests__/utils.ts

@@ -0,0 +1,26 @@
+import {mocked} from 'ts-jest/utils';
+import Monitor from '../src/Monitor';
+
+export function assertIncrementWasCalled(monitor: Monitor, metricName: string) {
+  expect(mocked(monitor.getStatsdClient()!.increment)).toHaveBeenCalledWith(metricName);
+}
+
+export function assertIncrementWasNotCalled(monitor: Monitor, metricName: string) {
+  expect(mocked(monitor.getStatsdClient()!.increment)).not.toHaveBeenCalledWith(metricName);
+}
+
+export function assertTimingWasCalled(monitor: Monitor, metricName: string) {
+  expect(mocked(monitor.getStatsdClient()!.timing)).toHaveBeenCalledWith(metricName, expect.any(Number));
+}
+
+export function assertTimingWasNotCalled(monitor: Monitor, metricName: string) {
+  expect(mocked(monitor.getStatsdClient()!.timing)).not.toHaveBeenCalledWith(metricName, expect.any(Number));
+}
+
+export function assertGaugeWasCalled(monitor: Monitor, metricName: string) {
+  expect(mocked(monitor.getStatsdClient()!.gauge)).toHaveBeenCalledWith(metricName, expect.any(Number));
+}
+
+export function assertGaugeWasNotCalled(monitor: Monitor, metricName: string) {
+  expect(mocked(monitor.getStatsdClient()!.gauge)).not.toHaveBeenCalledWith(metricName, expect.any(Number));
+}

example/run.ts

@@ -0,0 +1,91 @@
+import 'dotenv/config';
+
+import {setGlobalInstance, monitored, Monitor} from '../src';
+
+setGlobalInstance(new Monitor({
+    serviceName: 'monitored-example',
+    logging: {
+        logger: {warn: console.warn, info: console.info, debug: console.debug, error: console.error},
+        logErrorsAsWarnings: true,
+        defaultParseError: _e => 'defaultParseError',
+    },
+}));
+
+monitored('foo1', () => 'bar1', {context: {id: 1}, logResult: true});
+
+try {
+    monitored(
+        'foo2',
+        () => {
+            throw 'something';
+        },
+        {logAsError: true, parseError: () => 'wrong!'}
+    );
+} catch (e) {
+    console.log('caught foo2', e);
+}
+
+const someResolvingPromise = (x: string) => Promise.resolve(x);
+monitored('foo3', () => someResolvingPromise('some string')).then(s =>
+    console.log(`Promise resolved with return value - ${s}`)
+);
+
+const someRejectingPromise = (x: string) => Promise.reject(x);
+monitored('foo4', () => someRejectingPromise('some reject string')).catch(e => console.log('caught promise', e));
+
+monitored('foo5', () => 'bar5', {context: {id: 5}, logResult: false});
+
+monitored('foo6', () => 'bar6', {context: {id: 6}, logResult: true});
+
+monitored('foo7', () => 'bar5', {level: 'debug'});
+
+monitored('foo8', () => 'bar8', {level: 'info'});
+
+monitored('foo9', () => 'bar9');
+
+try {
+    monitored('foo10', () => {
+        throw new Error('error!');
+    });
+} catch {}
+
+monitored('foo11', () => 'bar11');
+
+try {
+    monitored(
+        'foo12',
+        () => {
+            throw new Error('error!');
+        },
+        {logAsError: true, shouldMonitorError: () => false}
+    );
+} catch {}
+
+monitored(
+    'foo13',
+    async () => {
+        throw new Error('error!');
+    },
+    {logAsError: true, shouldMonitorError: () => true}
+).catch(() => {});
+
+monitored('foo14', () => 'bar14', {shouldMonitorSuccess: () => false});
+monitored('foo15', () => 'bar15', {shouldMonitorSuccess: () => true});
+
+try {
+    monitored(
+        'foo16',
+        () => {
+            throw new Error('error!');
+        },
+        {logErrorAsInfo: true}
+    );
+} catch {}
+
+monitored(
+    'foo17',
+    async () => {
+        throw new Error('error!');
+    },
+    {logErrorAsInfo: true}
+).catch(() => {});

jest.config.js

@@ -0,0 +1,13 @@
+module.exports = {
+    rootDir: '.',
+    moduleFileExtensions: ['ts', 'tsx', 'js'],
+    transform: {
+        '^.+\\.(ts|tsx)$': 'ts-jest',
+    },
+    globals: {
+        'ts-jest': {
+            tsConfig: 'tsconfig.json',
+        },
+    },
+    testMatch: ['__tests__/**/*.spec.+(ts|tsx|js)'],
+};

package.json

@@ -0,0 +1,45 @@
+{
+  "name": "monitored",
+  "version": "0.0.1",
+  "description": "monitored",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "format": "prettier --write '**/*.{ts,js,json}'",
+    "precommit": "lint-staged",
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "example": "ts-node example/run.ts",
+    "prepublish": "yarn build && yarn test",
+    "test": "jest --config jest.config.js --forceExit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Soluto/monitored.git"
+  },
+  "author": "Soluto",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Soluto/monitored/issues"
+  },
+  "homepage": "https://github.com/Soluto/monitored#readme",
+  "dependencies": {
+    "hot-shots": "^7.4.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^25.1.0",
+    "@types/node": "^12.0.0",
+    "dotenv": "^5.0.1",
+    "jest": "^25.1.0",
+    "lint-staged": "^6.0.1",
+    "prettier": "^1.8.2",
+    "ts-jest": "^25.0.0",
+    "ts-node": "^7.0.1",
+    "typescript": "^3.7.5"
+  },
+  "lint-staged": {
+    "*.{js,ts,tsx,css}": [
+      "prettier --write",
+      "git add"
+    ]
+  }
+}

src/AsyncStatsD.ts

@@ -0,0 +1,96 @@
+import {StatsD, ClientOptions} from 'hot-shots';
+import {promisify} from 'util';
+import {timeoutPromise} from './utils';
+import {Logger} from './Logger';
+
+const noop = () => {};
+
+export class AsyncStatsD {
+    private client: StatsD;
+    private logger: Logger;
+    private promiseCount: number;
+    private pendingPromises: Record<number, Promise<any>>;
+
+    private _increment: (name: string, value: number) => Promise<void>;
+    private _gauge: (name: string, value: number) => Promise<void>;
+    private _timing: (name: string, value: number) => Promise<void>;
+    close: () => Promise<void>;
+
+    constructor(logger: Logger, options?: ClientOptions) {
+        this.client = new StatsD({cacheDns: true, ...options});
+        this.logger = logger;
+        this.promiseCount = 0;
+        this.pendingPromises = {};
+
+        this._increment = promisify(this.client.increment.bind(this.client));
+        this._gauge = promisify(this.client.gauge.bind(this.client));
+        this._timing = promisify(this.client.timing.bind(this.client));
+        this.close = promisify(this.client.close.bind(this.client));
+    }
+
+    get statsd() {
+        return this.client;
+    }
+
+    increment = async (name: string, value: number = 1) => {
+        try {
+            await this.wrapStatsdPromise(this._increment(name, value));
+        } catch (err) {
+            this.logger.error(`Failed to send increment: ${name}`, err);
+        }
+    };
+
+    gauge = async (name: string, value: number) => {
+        try {
+            await this.wrapStatsdPromise(this._gauge(name, value));
+        } catch (err) {
+            this.logger.error(`Failed to send gauge: ${name}`, err);
+        }
+    };
+
+    timing = async (name: string, value: number) => {
+        try {
+            await this.wrapStatsdPromise(this._timing(name, value));
+        } catch (err) {
+            this.logger.error(`Failed to send timing: ${name}`, err);
+        }
+    };
+
+    flush = async (timeout: number = 2000) => {
+        const remainingPromises = Object.values(this.pendingPromises).map(p => p.catch(noop));
+
+        if (remainingPromises.length > 0) {
+            try {
+                await timeoutPromise(
+                    timeout,
+                    Promise.all(remainingPromises),
+                    'Timeout reached, stopped wait for pending log writes'
+                );
+            } catch (err) {
+                this.logger.error('flush timeout', err);
+
+                return false;
+            }
+        }
+
+        return true;
+    };
+
+    private wrapStatsdPromise = async <R = void>(prom: Promise<R>): Promise<R> => {
+        const currentCount = this.incrementPromiseCount();
+
+        try {
+            this.pendingPromises[currentCount] = prom;
+
+            return await this.pendingPromises[currentCount];
+        } finally {
+            delete this.pendingPromises[currentCount];
+        }
+    };
+
+    private incrementPromiseCount = () => {
+        this.promiseCount = (this.promiseCount + 1) % Number.MAX_SAFE_INTEGER;
+
+        return this.promiseCount;
+    };
+}

src/Logger.ts

@@ -0,0 +1,43 @@
+interface LoggerConfig {
+    logErrorsAsWarnings: boolean;
+}
+
+export class Logger {
+    private logger: any;
+    private config: LoggerConfig;
+
+    constructor(logger: any, config?: Partial<LoggerConfig>) {
+        this.logger = logger;
+        this.config = {logErrorsAsWarnings: false, ...config};
+    }
+
+    debug = (message, {extra}) => {
+        try {
+            this.logger.debug(message, {extra});
+        } catch (_) {}
+    };
+
+    info = (message, {extra}) => {
+        try {
+            this.logger.info(message, {extra});
+        } catch (_) {}
+    };
+
+    error = (message: string, err?: Error, extra?: any, logAsError?: boolean, logErrorAsInfo?: boolean) => {
+        try {
+            if (logErrorAsInfo) {
+                this.logger.info(message, {err, extra});
+                return;
+            }
+            if (logAsError) {
+                this.logger.error(message, {err, extra});
+                return;
+            }
+            if (this.config.logErrorsAsWarnings) {
+                this.logger.warn(message, {err, extra});
+                return;
+            }
+            this.logger.error(message, {err, extra});
+        } catch (_) {}
+    };
+}

src/Monitor.ts

@@ -0,0 +1,154 @@
+import {safe} from './utils';
+import {MonitorOptions, MonitoredOptions, Unpromisify} from './types';
+import {emptyLogger, consoleLogger} from './loggers';
+import parseError from './parseError';
+import {AsyncStatsD} from './AsyncStatsD';
+import {Logger} from './Logger';
+
+interface Config {
+    serviceName: string;
+    shouldMonitorExecutionStart: boolean;
+    disableSuccessLogs: boolean;
+}
+
+class Monitor {
+    private statsdClient: AsyncStatsD | undefined;
+    private config: Config;
+    private logger: Logger;
+    private defaultParseError: (e: any) => any;
+
+    constructor(options: MonitorOptions) {
+        this.config = {
+            serviceName: options.serviceName ? options.serviceName + '.' : '',
+            shouldMonitorExecutionStart: options.shouldMonitorExecutionStart ?? true,
+            disableSuccessLogs: options.logging?.disableSuccessLogs ?? false,
+        };
+
+        this.logger = new Logger(options.mock ? emptyLogger : options.logging?.logger ?? consoleLogger, {
+            logErrorsAsWarnings: options.logging?.logErrorsAsWarnings,
+        });
+        this.defaultParseError = options.logging?.defaultParseError ?? parseError;
+
+        if (options.statsd) {
+            const {apiKey, root, ...restStatsdOptions} = options.statsd;
+            const prefixesArray = [apiKey, root];
+            if (options.serviceName) {
+                prefixesArray.push(options.serviceName);
+            }
+            const prefix = prefixesArray.join('.') + '.';
+
+            this.statsdClient = new AsyncStatsD(this.logger, {
+                port: 8125,
+                prefix,
+                mock: options.mock,
+                ...restStatsdOptions,
+            });
+        }
+    }
+
+    monitored = <T>(name: string, callable: () => T, options: MonitoredOptions<T> = {}) => {
+        const {level = 'debug', context} = options;
+        const startTime = Date.now();
+
+        if (this.config.shouldMonitorExecutionStart) {
+            this.increment(`${name}.start`);
+            this.monitoredLogger(level, `${name}.start`, {extra: context});
+        }
+
+        try {
+            const result = callable();
+            if (result && result instanceof Promise) {
+                return <T>(
+                    (<any>(
+                        result
+                            .then((promiseResult: Unpromisify<T>) =>
+                                this.onResult(promiseResult, name, startTime, options)
+                            )
+                            .catch(err => this.onErrorAsync(err, name, options))
+                    ))
+                );
+            }
+            return this.onResult(result as Unpromisify<T>, name, startTime, options);
+        } catch (err) {
+            return this.onErrorSync(err, name, options);
+        }
+    };
+
+    getStatsdClient = () => this.statsdClient;
+
+    increment: AsyncStatsD['increment'] = async (...args) => this.statsdClient?.increment(...args);
+
+    gauge: AsyncStatsD['gauge'] = async (...args) => this.statsdClient?.gauge(...args);
+
+    timing: AsyncStatsD['timing'] = async (...args) => this.statsdClient?.timing(...args);
+
+    flush: AsyncStatsD['flush'] = async (...args) => this.statsdClient?.flush(...args) ?? true;
+
+    monitoredLogger = (level: MonitoredOptions<any>['level'], message, {extra}) => {
+        const log = level === 'info' ? this.logger.info : this.logger.debug;
+        log(message, {extra});
+    };
+
+    private onResult = <T>(
+        result: Unpromisify<T>,
+        name: string,
+        startTime: number,
+        {shouldMonitorSuccess, context, parseResult, logResult, level}: MonitoredOptions<T>
+    ): Unpromisify<T> => {
+        const executionTime = Date.now() - startTime;
+
+        if (shouldMonitorSuccess?.(result) ?? true) {
+            this.increment(`${name}.success`);
+            this.gauge(`${name}.ExecutionTime`, executionTime);
+            this.timing(`${name}.ExecutionTime`, executionTime);
+        }
+
+        if (!this.config.disableSuccessLogs) {
+            this.monitoredLogger(level, `${name}.success`, {
+                extra: {
+                    ...context,
+                    executionTime,
+                    executionResult: logResult ? safe(parseResult)(result) : 'NOT_LOGGED',
+                },
+            });
+        }
+
+        return result;
+    };
+
+    private onErrorAsync = async (
+        err,
+        name: string,
+        {shouldMonitorError, context, logAsError, logErrorAsInfo, parseError}: MonitoredOptions<never>
+    ) => {
+        if (shouldMonitorError && !shouldMonitorError(err)) throw err;
+        this.increment(`${name}.error`);
+        this.logger.error(
+            `${name}.error`,
+            await safe(parseError || this.defaultParseError)(err),
+            context,
+            logAsError,
+            logErrorAsInfo
+        );
+        throw err;
+    };
+
+    private onErrorSync = (
+        err,
+        name: string,
+        {shouldMonitorError, context, logAsError, logErrorAsInfo, parseError}: MonitoredOptions<never>
+    ) => {
+        if (shouldMonitorError && shouldMonitorError(err)) throw err;
+        this.increment(`${name}.error`);
+        this.logger.error(
+            `${name}.error`,
+            safe(parseError || this.defaultParseError)(err),
+            context,
+            logAsError,
+            logErrorAsInfo
+        );
+        throw err;
+    };
+}
+
+export default Monitor;

src/globalInstance.ts

@@ -0,0 +1,23 @@
+import Monitor from './Monitor';
+
+let instance: Monitor | undefined;
+
+export function setGlobalInstance(monitor: Monitor) {
+    instance = monitor;
+}
+
+export function getGlobalInstance(): Monitor {
+    if (!instance) {
+        instance = new Monitor({
+            serviceName: '',
+        });
+    }
+
+    return instance;
+}
+
+export const monitored: Monitor['monitored'] = (...args) => getGlobalInstance().monitored(...args);
+export const getStatsdClient: Monitor['getStatsdClient'] = (...args) => getGlobalInstance().getStatsdClient(...args);
+export const increment: Monitor['increment'] = (...args) => getGlobalInstance().increment(...args);
+export const gauge: Monitor['gauge'] = (...args) => getGlobalInstance().gauge(...args);
+export const timing: Monitor['timing'] = (...args) => getGlobalInstance().timing(...args);

src/index.ts

@@ -0,0 +1,4 @@
+export {default as Monitor} from './Monitor'; 
+export * from './globalInstance';
+export {default as parseError} from './parseError';
+export * from './types';

src/loggers.ts

@@ -0,0 +1,18 @@
+type LogOptions = {
+  err?: Error;
+  extra?: any;
+};
+
+export const consoleLogger = {
+  info: (message, logOptions: LogOptions = {}) => console.log(message, logOptions.extra),
+  debug: (message, logOptions: LogOptions = {}) => console.log(message, logOptions.extra),
+  warn: (message, logOptions: LogOptions = {}) => console.log(message, logOptions.err, logOptions.extra),
+  error: (message, logOptions: LogOptions = {}) => console.log(message, logOptions.err, logOptions.extra),
+};
+
+export const emptyLogger = {
+  info: () => {},
+  debug: () => {},
+  warn: () => {},
+  error: () => {},
+};

src/parseError.ts

@@ -0,0 +1,34 @@
+export default async function(e: any) {
+  try {
+      // e.text function should be fetch error
+      if (e.text && typeof e.text === 'function') {
+          try {
+              const text = await e.clone().text();
+              return JSON.parse(text);
+          } catch {
+              return {status: e.status, statusText: e.statusText, url: e.url};
+          }
+      }
+      // Axios error has buffer properties, toJSON will create a nice object
+      if (e.isAxiosError) {
+          return e.toJSON();
+      }
+      if (e.response) {
+          return {
+              status: e.response.status,
+              statusText: e.response.statusText,
+              data: e.response.data,
+          };
+      }
+      if (e.body) {
+          try {
+              return JSON.parse(e.body);
+          } catch {
+              return e.body;
+          }
+      }
+      return e;
+  } catch {
+      return e;
+  }
+};

src/types.ts

@@ -0,0 +1,34 @@
+import {ClientOptions as StatsdClientOptions} from 'hot-shots';
+
+interface StatsdOptions extends Omit<StatsdClientOptions, 'prefix'> {
+  apiKey: string;
+  root: string;
+  host: string;
+}
+
+export type MonitorOptions = {
+    serviceName: string;
+    statsd?: StatsdOptions;
+    logging?: {
+        logger: any;
+        logErrorsAsWarnings?: boolean;
+        disableSuccessLogs?: boolean;
+        defaultParseError?: (e: any) => any;
+    };
+    shouldMonitorExecutionStart?: boolean;
+    mock?: boolean;
+};
+
+export type Unpromisify<T> = T extends PromiseLike<infer U> ? U : T
+
+export type MonitoredOptions<T> = {
+  context?: any;
+  logResult?: boolean;
+  parseResult?: (r: Unpromisify<T>) => any;
+  parseError?: (e: any) => any;
+  level?: 'info' | 'debug';
+  logAsError?: boolean;
+  logErrorAsInfo?: boolean,
+  shouldMonitorError?: (e: any) => boolean;
+  shouldMonitorSuccess?: (r: Unpromisify<T>) => boolean;
+};

src/utils.ts

@@ -0,0 +1,23 @@
+export const safe = fn => r => {
+  try {
+      if (fn) {
+          return fn(r);
+      }
+      return r;
+  } catch {
+      return r;
+  }
+};
+
+export const timeoutPromise = function(ms: number, promise: Promise<any>, timeoutError?: string) {
+    // Create a promise that rejects in <ms> milliseconds
+    let timeout = new Promise((_, reject) => {
+      let id = setTimeout(() => {
+        clearTimeout(id);
+        reject(timeoutError || 'Timed out in ' + ms + 'ms.');
+      }, ms);
+    });
+  
+    // Returns a race between our timeout and the passed in promise
+    return Promise.race([promise, timeout]);
+  };

tsconfig.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "target": "es2015",
+        "module": "commonjs",
+        "moduleResolution": "node",
+        "declaration": true,
+        "rootDir": "src",
+        "outDir": "dist",
+        "removeComments": true,
+        "allowSyntheticDefaultImports": true,
+        "strict": true,
+        "suppressImplicitAnyIndexErrors": true,
+        "sourceMap": false,
+        "forceConsistentCasingInFileNames": true,
+        "noImplicitReturns": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "lib": ["dom", "es2017"],
+        "skipLibCheck": true,
+        "noImplicitAny": false
+    },
+    "include": ["src/**/*", "types/*.d.ts"],
+    "exclude": ["__tests__", "dist"]
+}