@salesforce/core 4.3.11 → 5.0.1-v5-beta.1

package/lib/logger/logger.js

@@ -0,0 +1,399 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LoggerLevel = void 0;
+/*
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+const os = require("os");
+const path = require("path");
+const pino_1 = require("pino");
+const kit_1 = require("@salesforce/kit");
+const ts_types_1 = require("@salesforce/ts-types");
+const global_1 = require("../global");
+const sfError_1 = require("../sfError");
+const unwrapArray_1 = require("../util/unwrapArray");
+const memoryLogger_1 = require("./memoryLogger");
+const cleanup_1 = require("./cleanup");
+/**
+ * Standard `Logger` levels.
+ *
+ * **See** {@link https://getpino.io/#/docs/api?id=logger-level |Logger Levels}
+ */
+var LoggerLevel;
+(function (LoggerLevel) {
+    LoggerLevel[LoggerLevel["TRACE"] = 10] = "TRACE";
+    LoggerLevel[LoggerLevel["DEBUG"] = 20] = "DEBUG";
+    LoggerLevel[LoggerLevel["INFO"] = 30] = "INFO";
+    LoggerLevel[LoggerLevel["WARN"] = 40] = "WARN";
+    LoggerLevel[LoggerLevel["ERROR"] = 50] = "ERROR";
+    LoggerLevel[LoggerLevel["FATAL"] = 60] = "FATAL";
+})(LoggerLevel = exports.LoggerLevel || (exports.LoggerLevel = {}));
+/**
+ * A logging abstraction powered by {@link https://github.com/pinojs/pino | Pino} that provides both a default
+ * logger configuration that will log to the default path, and a way to create custom loggers based on the same foundation.
+ *
+ * ```
+ * // Gets the root sfdx logger
+ * const logger = await Logger.root();
+ *
+ * // Creates a child logger of the root sfdx logger with custom fields applied
+ * const childLogger = await Logger.child('myRootChild', {tag: 'value'});
+ *
+ * // Creates a custom logger unaffiliated with the root logger
+ * const myCustomLogger = new Logger('myCustomLogger');
+ *
+ * // Creates a child of a custom logger unaffiliated with the root logger with custom fields applied
+ * const myCustomChildLogger = myCustomLogger.child('myCustomChild', {tag: 'value'});
+ *
+ * // get a raw pino logger from the root instance of Logger
+ * // you can use these to avoid constructing another Logger wrapper class and to get better type support
+ * const logger = Logger.getRawRootLogger().child({name: 'foo', otherProp: 'bar'});
+ * logger.info({some: 'stuff'}, 'a message');
+ *
+ *
+ * // get a raw pino logger from the current instance
+ * const childLogger = await Logger.child('myRootChild', {tag: 'value'});
+ * const logger = childLogger.getRawLogger();
+ * ```
+ *
+ * **See** https://developer.salesforce.com/docs/atlas.en-us.sfdx_setup.meta/sfdx_setup/sfdx_dev_cli_log_messages.htm
+ */
+class Logger {
+    /**
+     * Constructs a new `Logger`.
+     *
+     * @param optionsOrName A set of `LoggerOptions` or name to use with the default options.
+     *
+     * **Throws** *{@link SfError}{ name: 'RedundantRootLoggerError' }* More than one attempt is made to construct the root
+     * `Logger`.
+     */
+    constructor(optionsOrName) {
+        const options = typeof optionsOrName === 'string'
+            ? { name: optionsOrName, level: Logger.DEFAULT_LEVEL, fields: {} }
+            : optionsOrName;
+        if (Logger.rootLogger && options.name === Logger.ROOT_NAME) {
+            throw new sfError_1.SfError('Can not create another root logger.', 'RedundantRootLoggerError');
+        }
+        // if there is a rootLogger, use its Pino instance
+        if (Logger.rootLogger) {
+            this.pinoLogger = Logger.rootLogger.pinoLogger.child({ ...options.fields, name: options.name });
+            this.memoryLogger = Logger.rootLogger.memoryLogger; // if the root was constructed with memory logging, keep that
+            this.pinoLogger.trace(`Created '${options.name}' child logger instance`);
+        }
+        else {
+            const level = new kit_1.Env().getString('SF_LOG_LEVEL') ?? pino_1.pino.levels.labels[options.level ?? Logger.DEFAULT_LEVEL];
+            const commonOptions = {
+                name: options.name ?? Logger.ROOT_NAME,
+                base: options.fields ?? {},
+                level,
+                enabled: process.env.SFDX_DISABLE_LOG_FILE !== 'true' && process.env.SF_DISABLE_LOG_FILE !== 'true',
+            };
+            if (options.useMemoryLogger || global_1.Global.getEnvironmentMode() === global_1.Mode.TEST) {
+                this.memoryLogger = new memoryLogger_1.MemoryLogger();
+                this.pinoLogger = (0, pino_1.pino)({
+                    ...commonOptions,
+                    sync: true,
+                }, this.memoryLogger);
+            }
+            else {
+                this.pinoLogger = (0, pino_1.pino)({
+                    ...commonOptions,
+                    transport: {
+                        pipeline: [
+                            {
+                                target: path.join('..', '..', 'lib', 'logger', 'transformStream'),
+                            },
+                            getWriteStream(level),
+                        ],
+                    },
+                    sync: false,
+                });
+                // when a new file logger root is instantiated, we check for old log files.
+                // but we don't want to wait for it
+                // and it's async and we can't wait from a ctor anyway
+                void (0, cleanup_1.cleanup)();
+            }
+            Logger.rootLogger = this;
+        }
+    }
+    /**
+     *
+     * Gets the root logger.  It's a singleton
+     * See also getRawLogger if you don't need the root logger
+     */
+    static async root() {
+        return Promise.resolve(this.getRoot());
+    }
+    /**
+     * Gets the root logger.  It's a singleton
+     */
+    static getRoot() {
+        if (this.rootLogger) {
+            return this.rootLogger;
+        }
+        const rootLogger = (this.rootLogger = new Logger(Logger.ROOT_NAME));
+        return rootLogger;
+    }
+    /**
+     * Destroys the root `Logger`.
+     *
+     * @ignore
+     */
+    static destroyRoot() {
+        if (this.rootLogger) {
+            this.rootLogger = undefined;
+        }
+    }
+    /**
+     * Create a child of the root logger, inheriting this instance's configuration such as `level`, transports, etc.
+     *
+     * @param name The name of the child logger.
+     * @param fields Additional fields included in all log lines.
+     */
+    static async child(name, fields) {
+        return (await Logger.root()).child(name, fields);
+    }
+    /**
+     * Create a child of the root logger, inheriting this instance's configuration such as `level`, transports, etc.
+     *
+     * @param name The name of the child logger.
+     * @param fields Additional fields included in all log lines.
+     */
+    static childFromRoot(name, fields) {
+        return Logger.getRoot().child(name, fields);
+    }
+    /**
+     * Gets a numeric `LoggerLevel` value by string name.
+     *
+     * @param {string} levelName The level name to convert to a `LoggerLevel` enum value.
+     *
+     * **Throws** *{@link SfError}{ name: 'UnrecognizedLoggerLevelNameError' }* The level name was not case-insensitively recognized as a valid `LoggerLevel` value.
+     * @see {@Link LoggerLevel}
+     */
+    static getLevelByName(levelName) {
+        levelName = levelName.toUpperCase();
+        if (!(0, ts_types_1.isKeyOf)(LoggerLevel, levelName)) {
+            throw new sfError_1.SfError(`Invalid log level "${levelName}".`, 'UnrecognizedLoggerLevelNameError');
+        }
+        return LoggerLevel[levelName];
+    }
+    /** get the bare (pino) logger instead of using the class hierarchy */
+    static getRawRootLogger() {
+        return Logger.getRoot().pinoLogger;
+    }
+    /** get the bare (pino) logger instead of using the class hierarchy */
+    getRawLogger() {
+        return this.pinoLogger;
+    }
+    /**
+     * Gets the name of this logger.
+     */
+    getName() {
+        return this.pinoLogger.bindings().name ?? '';
+    }
+    /**
+     * Gets the current level of this logger.
+     */
+    getLevel() {
+        return this.pinoLogger.levelVal;
+    }
+    /**
+     * Set the logging level of all streams for this logger.  If a specific `level` is not provided, this method will
+     * attempt to read it from the environment variable `SFDX_LOG_LEVEL`, and if not found,
+     * {@link Logger.DEFAULT_LOG_LEVEL} will be used instead. For convenience `this` object is returned.
+     *
+     * @param {LoggerLevelValue} [level] The logger level.
+     *
+     * **Throws** *{@link SfError}{ name: 'UnrecognizedLoggerLevelNameError' }* A value of `level` read from `SFDX_LOG_LEVEL`
+     * was invalid.
+     *
+     * ```
+     * // Sets the level from the environment or default value
+     * logger.setLevel()
+     *
+     * // Set the level from the INFO enum
+     * logger.setLevel(LoggerLevel.INFO)
+     *
+     * // Sets the level case-insensitively from a string value
+     * logger.setLevel(Logger.getLevelByName('info'))
+     * ```
+     */
+    setLevel(level) {
+        if (level == null) {
+            const logLevelFromEnvVar = new kit_1.Env().getString('SF_LOG_LEVEL');
+            level = logLevelFromEnvVar ? Logger.getLevelByName(logLevelFromEnvVar) : Logger.DEFAULT_LEVEL;
+        }
+        this.pinoLogger.level = this.pinoLogger.levels.labels[level] ?? this.pinoLogger.levels.labels[Logger.DEFAULT_LEVEL];
+        return this;
+    }
+    /**
+     * Compares the requested log level with the current log level.  Returns true if
+     * the requested log level is greater than or equal to the current log level.
+     *
+     * @param level The requested log level to compare against the currently set log level.
+     */
+    shouldLog(level) {
+        return (typeof level === 'string' ? this.pinoLogger.levelVal : level) >= this.getLevel();
+    }
+    /**
+     * Gets an array of log line objects. Each element is an object that corresponds to a log line.
+     */
+    getBufferedRecords() {
+        if (!this.memoryLogger) {
+            throw new Error('getBufferedRecords is only supported when useMemoryLogging is true');
+        }
+        return this.memoryLogger?.loggedData ?? [];
+    }
+    /**
+     * Reads a text blob of all the log lines contained in memory or the log file.
+     */
+    readLogContentsAsText() {
+        if (this.memoryLogger) {
+            return this.memoryLogger.loggedData.reduce((accum, line) => {
+                accum += JSON.stringify(line) + os.EOL;
+                return accum;
+            }, '');
+        }
+        else {
+            this.pinoLogger.warn('readLogContentsAsText is not supported for file streams, only used when useMemoryLogging is true');
+            const content = '';
+            return content;
+        }
+    }
+    /**
+     * Create a child logger, typically to add a few log record fields. For convenience this object is returned.
+     *
+     * @param name The name of the child logger that is emitted w/ log line.  Will be prefixed with the parent logger name and `:`
+     * @param fields Additional fields included in all log lines for the child logger.
+     */
+    child(name, fields = {}) {
+        const fullName = `${this.getName()}:${name}`;
+        const child = new Logger({ name: fullName, fields });
+        this.pinoLogger.trace(`Setup child '${fullName}' logger instance`);
+        return child;
+    }
+    /**
+     * Add a field to all log lines for this logger. For convenience `this` object is returned.
+     *
+     * @param name The name of the field to add.
+     * @param value The value of the field to be logged.
+     */
+    addField(name, value) {
+        this.pinoLogger.setBindings({ ...this.pinoLogger.bindings(), [name]: value });
+        return this;
+    }
+    /**
+     * Logs at `trace` level with filtering applied. For convenience `this` object is returned.
+     *
+     * @param args Any number of arguments to be logged.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    trace(...args) {
+        this.pinoLogger.trace((0, unwrapArray_1.unwrapArray)(args));
+        return this;
+    }
+    /**
+     * Logs at `debug` level with filtering applied. For convenience `this` object is returned.
+     *
+     * @param args Any number of arguments to be logged.
+     */
+    debug(...args) {
+        this.pinoLogger.debug((0, unwrapArray_1.unwrapArray)(args));
+        return this;
+    }
+    /**
+     * Logs at `debug` level with filtering applied.
+     *
+     * @param cb A callback that returns on array objects to be logged.
+     */
+    // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
+    debugCallback(cb) { }
+    /**
+     * Logs at `info` level with filtering applied. For convenience `this` object is returned.
+     *
+     * @param args Any number of arguments to be logged.
+     */
+    info(...args) {
+        this.pinoLogger.info((0, unwrapArray_1.unwrapArray)(args));
+        return this;
+    }
+    /**
+     * Logs at `warn` level with filtering applied. For convenience `this` object is returned.
+     *
+     * @param args Any number of arguments to be logged.
+     */
+    warn(...args) {
+        this.pinoLogger.warn((0, unwrapArray_1.unwrapArray)(args));
+        return this;
+    }
+    /**
+     * Logs at `error` level with filtering applied. For convenience `this` object is returned.
+     *
+     * @param args Any number of arguments to be logged.
+     */
+    error(...args) {
+        this.pinoLogger.error((0, unwrapArray_1.unwrapArray)(args));
+        return this;
+    }
+    /**
+     * Logs at `fatal` level with filtering applied. For convenience `this` object is returned.
+     *
+     * @param args Any number of arguments to be logged.
+     */
+    fatal(...args) {
+        // always show fatal to stderr
+        // IMPORTANT:
+        // Do not use console.error() here, if fatal() is called from the uncaughtException handler, it
+        // will be re-thrown and caught again by the uncaughtException handler, causing an infinite loop.
+        console.log(...args); // eslint-disable-line no-console
+        this.pinoLogger.fatal((0, unwrapArray_1.unwrapArray)(args));
+        return this;
+    }
+}
+exports.Logger = Logger;
+/**
+ * The name of the root sfdx `Logger`.
+ */
+Logger.ROOT_NAME = 'sf';
+/**
+ * The default `LoggerLevel` when constructing new `Logger` instances.
+ */
+Logger.DEFAULT_LEVEL = LoggerLevel.WARN;
+/**
+ * A list of all lower case `LoggerLevel` names.
+ *
+ * **See** {@link LoggerLevel}
+ */
+Logger.LEVEL_NAMES = Object.values(LoggerLevel)
+    .filter(ts_types_1.isString)
+    .map((v) => v.toLowerCase());
+/** return various streams that the logger could send data to, depending on the options and env  */
+const getWriteStream = (level = 'warn') => {
+    // used when debug mode, writes to stdout (colorized)
+    if (process.env.DEBUG) {
+        return {
+            target: 'pino-pretty',
+            options: { colorize: true },
+        };
+    }
+    // default: we're writing to a rotating file
+    const rotator = new Map([
+        ['1m', new Date().toISOString().split(':').slice(0, 2).join('-')],
+        ['1h', new Date().toISOString().split(':').slice(0, 1).join('-')],
+        ['1d', new Date().toISOString().split('T')[0]],
+    ]);
+    const logRotationPeriod = new kit_1.Env().getString('SF_LOG_ROTATION_PERIOD') ?? '1d';
+    return {
+        // write to a rotating file
+        target: 'pino/file',
+        options: {
+            destination: path.join(global_1.Global.SF_DIR, `sf-${rotator.get(logRotationPeriod) ?? rotator.get('1d')}.log`),
+            mkdir: true,
+            level,
+        },
+    };
+};
+//# sourceMappingURL=logger.js.map

package/lib/logger/memoryLogger.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Writable } from 'stream';
+/**
+ * Used by test setup to keep UT from writing to disk.
+ */
+export declare class MemoryLogger extends Writable {
+    loggedData: Array<Record<string, unknown>>;
+    constructor();
+    _write(chunk: Record<string, unknown>, encoding: string, callback: (err?: Error) => void): void;
+}

package/lib/logger/memoryLogger.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryLogger = void 0;
+/*
+ * Copyright (c) 2023, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+const stream_1 = require("stream");
+const unwrapArray_1 = require("../util/unwrapArray");
+const filters_1 = require("./filters");
+/**
+ * Used by test setup to keep UT from writing to disk.
+ */
+class MemoryLogger extends stream_1.Writable {
+    constructor() {
+        super({ objectMode: true });
+        this.loggedData = [];
+    }
+    _write(chunk, encoding, callback) {
+        const filteredChunk = (0, unwrapArray_1.unwrapArray)((0, filters_1.filterSecrets)([chunk]));
+        this.loggedData.push(typeof filteredChunk === 'string'
+            ? JSON.parse(filteredChunk)
+            : filteredChunk);
+        callback();
+    }
+}
+exports.MemoryLogger = MemoryLogger;
+//# sourceMappingURL=memoryLogger.js.map

package/lib/logger/transformStream.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { Transform } from 'stream';
+export default function (): Transform;

package/lib/logger/transformStream.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * Copyright (c) 2023, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+const stream_1 = require("stream");
+const unwrapArray_1 = require("../util/unwrapArray");
+const filters_1 = require("./filters");
+// eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-assignment
+const build = require('pino-abstract-transport');
+function default_1() {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
+    return build(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (source) => {
+        const myTransportStream = new stream_1.Transform({
+            objectMode: true,
+            transform(chunk, enc, cb) {
+                if (debugAllows(chunk)) {
+                    // uses the original logger's filters.
+                    const filteredChunk = (0, unwrapArray_1.unwrapArray)((0, filters_1.filterSecrets)([chunk]));
+                    const stringified = JSON.stringify(filteredChunk);
+                    this.push(stringified.concat('\n'));
+                }
+                cb();
+            },
+        });
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        (0, stream_1.pipeline)(source, myTransportStream, () => { });
+        return myTransportStream;
+    }, {
+        // This is needed to be able to pipeline transports.
+        enablePipelining: true,
+    });
+}
+exports.default = default_1;
+/** if the DEBUG= is set, see if that matches the logger name.  If not, we don't want to keep going */
+const debugAllows = (chunk) => {
+    if (!process.env.DEBUG || process.env.DEBUG === '*')
+        return true;
+    if (typeof chunk.name !== 'string')
+        return true;
+    // turn wildcard patterns into regexes
+    const regexFromDebug = new RegExp(process.env.DEBUG.replace(/\*/g, '.*'));
+    if (!regexFromDebug.test(chunk.name)) {
+        // console.log(`no match : ${chunk.name} for ${process.env.DEBUG}`);
+        return false;
+    }
+    else {
+        // console.log(`match : ${chunk.name} for ${process.env.DEBUG}`);
+        return true;
+    }
+};
+//# sourceMappingURL=transformStream.js.map

package/lib/org/authInfo.js

@@ -19,7 +19,7 @@ const transport_1 = require("jsforce/lib/transport");
 const jwt = require("jsonwebtoken");
 const config_1 = require("../config/config");
 const configAggregator_1 = require("../config/configAggregator");
-const logger_1 = require("../logger");
+const logger_1 = require("../logger/logger");
 const sfError_1 = require("../sfError");
 const sfdc_1 = require("../util/sfdc");
 const stateAggregator_1 = require("../stateAggregator");

package/lib/org/authRemover.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthRemover = void 0;
 const kit_1 = require("@salesforce/kit");
 const configAggregator_1 = require("../config/configAggregator");
-const logger_1 = require("../logger");
+const logger_1 = require("../logger/logger");
 const messages_1 = require("../messages");
 const stateAggregator_1 = require("../stateAggregator");
 const orgConfigProperties_1 = require("./orgConfigProperties");

package/lib/org/connection.js

@@ -15,7 +15,7 @@ const jsforce_1 = require("jsforce");
 const tooling_1 = require("jsforce/lib/api/tooling");
 const myDomainResolver_1 = require("../status/myDomainResolver");
 const configAggregator_1 = require("../config/configAggregator");
-const logger_1 = require("../logger");
+const logger_1 = require("../logger/logger");
 const sfError_1 = require("../sfError");
 const sfdc_1 = require("../util/sfdc");
 const messages_1 = require("../messages");
@@ -149,7 +149,7 @@ class Connection extends jsforce_1.Connection {
             ...exports.SFDX_HTTP_HEADERS,
             ...lowercasedHeaders,
         };
-        this.logger.debug(`request: ${JSON.stringify(httpRequest)}`);
+        this.logger.getRawLogger().debug(httpRequest, 'request');
         return super.request(httpRequest, options);
     }
     /**