Configure Monitoring for Node.js

const config = GermainAPM.getDefaultConfiguration(
    'https://GERMAIN_APM_SERVER/',
    'APP_NAME'
);

config.defaults.application = {
    name: 'APP_NAME',
    component: 'APP_COMPONENT'
};

config.monitoring.frequencySeconds = 60;

config.monitoring.asyncCorrelation = false;

config.datapoints.maxFlushTimeSeconds = 60;

config.datapoints.sendData
config.datapoints.compress
config.datapoints.maxNumInMemory
config.datapoints.maxFlushTimeSeconds

config.monitoring.httpIncoming.enabled = true;

config.monitoring.httpOutgoing.enabled = true;

config.monitoring.unhandledExceptions.enabled
config.monitoring.unhandledExceptions.exitOnError
config.monitoring.unhandledExceptions.callbackOnError

config.monitoring.warning = true;

config.monitoring.unhandledPromiseRejection = true;

config.monitoring.multiplePromiseResolves = false;

config.monitoring.eventLoopLatency = false;

config.monitoring.startup = false;

GermainAPM.collectStartup();

config.monitoring.exit = false;

GermainAPM.startTransaction(
    'UNIQUE_TRANSACTION_NAME',
    'AdditionalInformation'
);

GermainAPM.endTransaction(
    'UNIQUE_TRANSACTION_NAME'
);

config.monitoring.pid = false;

config.monitoring.os = false;

config.monitoring.disk = false;

config.defaults.user
config.defaults.system
config.defaults.application
config.defaults.pid

config.logging.level = 'debug';
config.logging.filename = 'GermainAPM_custom.log';
config.logging.maxFiles = 20;
config.logging.maxSize = 20000000;

config.exclusions = [{
    fieldName: 'sessionId',
    factType: '',
    type: 'MASK',
    name: 'SessionId Anonymization',
    pattern: '',
    preserveLength: true,
    preserveWhitespace: true,
    enabled: true
}, {
    fieldName: 'requestBody',
    factType: 'NodeJS:Outbound',
    type: 'ANONYMIZE',
    name: 'Request Body Exclusion',
    pattern: '',
    preserveLength: true,
    preserveWhitespace: false,
    enabled: true
}];

type GermainAPMConfiguration = {
    /** GermainUX environment URL (e.g. http://localhost:8080). */
    servicesUrl: string;
    /** Config to enable/disable/customize what is monitored */
    monitoring: {
        /** How often periodic monitoring should be collected. Default: 60 */
        frequencySeconds: number;
        /** Whether to enable correlation of data across async callbacks. Default: true */
        asyncCorrelation: boolean;
        /** Unhandled Exception monitoring */
        unhandledExceptions: {
            /** Enable monitoring. Default: true */
            enabled: boolean;
            /** Whether to exit the Node process on error. Default: true */
            exitOnError: boolean;
            /** Callback to be fired when an error occurs. */
            callbackOnError?: (error: Error) => void;
        },
        /** Incoming HTTP monitoring */
        httpIncoming: {
            /** Enable monitoring. Default: true */
            enabled: boolean;
            /** Function to extract a sessionId from an incoming request */
            sessionExtractor?: (request: IncomingMessage) => string;
        },
        /** Outgoing HTTP monitoring */
        httpOutgoing: {
            /** Enable monitoring. Default: true */
            enabled: boolean;
            /** Function to extract a sessionId from an incoming request */
            sessionExtractor?: (response: ClientRequest) => string;
        },
        /** Node Startup time monitoring. Default: true */
        startup: true,
        /** Node Process monitoring. Default: true */
        pid: boolean;
        /** OS monitoring (CPU, Memory). Default: true */
        os: boolean;
        /** Disk monitoring. Default: true */
        disk: boolean;
        /** Node Warning monitoring. Default: true */
        warning: boolean;
        /** Unhandled Promise Rejection count monitoring. Default: true */
        unhandledPromiseRejection: boolean;
        /** Event Loop Latency monitoring. Default: true */
        eventLoopLatency: boolean;
        /** Exit monitoring - when Node shuts down. Default: true */
        exit: boolean;
        /** Multiple Promise Resolve monitoring. Default: true */
        multiplePromiseResolves: boolean;
    },
    /** Logging configuration */
    logging: {
        /** Level of logging to enable. Default: 'info' */
        level: 'error' | 'warn' | 'info' | 'verbose' | 'debug',
        /** Filename to log to. Default: 'GermainAPM.log' */
        filename: string;
        /** Max number of rolling files to keep. Default: 10 */
        maxFiles: number;
        /** Max size of a single rolling log file. Default: 10Mb */
        maxSize: number;
    },
    /** Data sending settings */
    datapoints: {
        /** Whether to send data to the server or just discard. This is a debug setting as should always be set true. Default: true */
        sendData: boolean;
        /** Whether outgoing data should be compressed to reduce network overhead. Default: true */
        compress: boolean;
        /** Max number of datapoints to keep in-memory before sending to the server. Default: 250 */
        maxNumInMemory: number;
        /** Max time to wait between sending data to server. Default: 60 */
        maxFlushTimeSeconds: number;
    },
    /** Default data to be added to datapoints */
    defaults: {
        /** Default user */
        user?: UserDimension;
        /** Default system */
        system?: SystemDimension;
        /** Default application */
        application?: ApplicationDimension;
        /** Default pid */
        pid?: string;
    }
    /** Exclusions to be applied to collected datapoints */
    exclusions: FieldExclusionConfig[]
}