@ohos-ports/layer0-prefetch 4.20.0-beta.0 → 4.20.0-beta.1

package/node_modules/@layer0/core/lambda/innerHandler.d.ts

@@ -0,0 +1,7 @@
+import LambdaInstance from './lambdaInstance';
+/**
+ * This is the user lambda entry point
+ * @param event A lambda event
+ * @param instance The lambda instance
+ */
+export declare function handler(event: any, instance: LambdaInstance): Promise<any>;

package/node_modules/@layer0/core/lambda/innerHandler.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* istanbul ignore file */
+const constants_1 = require("../constants");
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const paths_1 = require("../deploy/paths");
+const timing_1 = require("../timing");
+const loadRouter_1 = __importDefault(require("../router/loadRouter"));
+const nonWebpackRequire_1 = __importDefault(require("../utils/nonWebpackRequire"));
+const reqResMapper_1 = __importDefault(require("./reqResMapper"));
+const stdStreamsWrapper_1 = __importStar(require("./stdStreamsWrapper"));
+const getBodyLoggingData_1 = __importDefault(require("./getBodyLoggingData"));
+const lambdaInstance_1 = require("./lambdaInstance");
+const config_1 = __importDefault(require("../config"));
+const router = loadRouter_1.default('./' + path_1.basename(config_1.default.get('routes')));
+/**
+ * This is the user lambda entry point
+ * @param event A lambda event
+ * @param instance The lambda instance
+ */
+async function handler(event, instance) {
+    // We always create a new lambda invocations, for all jobs so that we can accurately
+    // identify cold starts.
+    const invocation = new lambdaInstance_1.LambdaInvocation(instance);
+    invocation.start();
+    const driLogger = stdStreamsWrapper_1.deepRequestInspectionLogger(instance);
+    // Deployment actions: only for internal usage and is not exposed
+    switch (event.action) {
+        case 'getEdgeConfig':
+            return router.createEdgeConfig();
+        case 'getPreloadConfig':
+            return withLogging(() => router.createPreloadConfig());
+    }
+    let req, res, responsePromise;
+    try {
+        const reqResResult = reqResMapper_1.default(event, invocation, {
+            allowReqQueryDuplicates: router.allowReqQueryDuplicates,
+        });
+        req = reqResResult.req;
+        res = reqResResult.res;
+        responsePromise = reqResResult.responsePromise;
+    }
+    catch (e) {
+        return withLogging(() => {
+            console.log('Failed to parse the event to get request and response data:', e.message, e.stack);
+            return {
+                body: (Buffer.from('{"error":"Failed to parse the event to get request and response data"}')),
+                isBase64Encoded: true,
+                statusCode: 530,
+                statusMessage: 'Internal Layer0 Error',
+                multiValueHeaders: {},
+            };
+        });
+    }
+    // Handle web requests.
+    return await withLogging(async () => {
+        const headers = req.headers || {};
+        driLogger.logDownstreamRequestInfo({
+            method: req.method,
+            path: req.url,
+            host: headers['host'],
+            headers: headers,
+            // We keep the protocol format same as the internal Node format on protocol fields.
+            protocol: `${headers['x-0-protocol'] || 'https'}:`,
+            ...getBodyLoggingData_1.default(req._rawBodyBase64, req.headers),
+        });
+        try {
+            await ensureAppStarted(3001);
+        }
+        catch (error) {
+            console.error(error);
+            throw error;
+        }
+        timing_1.withTimings(() => router.run(req, res))();
+        return responsePromise.then((result) => {
+            const headers = res.headers || {};
+            driLogger.logDownstreamResponseInfo({
+                statusCode: res.statusCode,
+                statusMessage: res.statusMessage,
+                headers,
+                ...getBodyLoggingData_1.default(result.body, res.headers),
+            });
+            return result;
+        });
+    }, req, instance);
+}
+exports.handler = handler;
+async function startApp(port) {
+    const modulePath = path_1.join(process.cwd(), paths_1.pathForBackend(constants_1.BACKENDS.js));
+    if (fs_extra_1.existsSync(modulePath)) {
+        let prod = nonWebpackRequire_1.default(modulePath);
+        if (prod.default) {
+            prod = prod.default;
+        }
+        // load the prod entry point from the framework integration package
+        await prod(port);
+        // let the router know where to proxy SSR requests
+        router.setBackend(constants_1.BACKENDS.js, {
+            domainOrIp: constants_1.JS_BACKEND_HOSTNAME,
+            port,
+        });
+        // use default JS backend port when no port is provided
+        const imageOptimizerPort = process.env.LAYER0_IMAGE_OPTIMIZER_PORT;
+        // check if provided env variable port can be parsed
+        if (imageOptimizerPort && !/^\d+$/.test(imageOptimizerPort)) {
+            console.error('Error: LAYER0_IMAGE_OPTIMIZER_PORT is not valid number');
+            process.exit(1);
+        }
+        // let the router know where to proxy image optimizer requests
+        router.setBackend(constants_1.BACKENDS.imageOptimizer, {
+            domainOrIp: process.env.LAYER0_IMAGE_OPTIMIZER_HOST,
+            port: imageOptimizerPort ? parseInt(imageOptimizerPort) : undefined,
+        });
+    }
+}
+/**
+ * Starts the user's SSR app if it hasn't already been started
+ */
+let appStartedPromise;
+async function ensureAppStarted(port) {
+    if (!appStartedPromise) {
+        appStartedPromise = startApp(port);
+    }
+    return appStartedPromise;
+}
+// TODO: We need to implement a way to clearly split logs between:
+//       1) user code logs that needs to be JSON, flagged with { awsTag: 'userLogs' }
+//         and sent to STDOUT to be picked up by Cloudwatch and our Log Streamer
+//       2) our internal wrapper exception logs that needs to be forwarded and handled
+//         by XBP
+//
+//  1) is correctly implemented by stdStreamsWrapper, *but* we need to make sure that user code errors
+//     cannot be logged to stdoud past `stdStreamsWrapper.disable()` otherwise they would not appear in Log Streamer
+//
+//  2) https://moovweb.atlassian.net/browse/PC-1766, exception logging and shipping in XBP needs
+//     to be reviewed:
+//       - some exceptions are escaping (some unhandled promise rejection for example)
+//       - XBP is logging all access logs, but should only log exception traces (which should trigger alert)
+/**
+ * Starts collecting stdout
+ * @param req The web request, if we're serving one
+ */
+function startLogging(req, lambdaInstance) {
+    if (process.env.LAYER0_LOCAL !== 'true' || process.env.LAYER0_LOCAL_CONSOLE_WRAP === 'true') {
+        // don't enable logging when running in local production mode because it makes debug output harder to read
+        stdStreamsWrapper_1.default.enable({
+            clientIp: req && req.headers[constants_1.HTTP_HEADERS.x0ClientIp],
+            requestId: req && req.headers[constants_1.HTTP_HEADERS.xRequestId],
+            wi: lambdaInstance === null || lambdaInstance === void 0 ? void 0 : lambdaInstance.id,
+        });
+    }
+}
+/**
+ * Stops collecting stdout
+ */
+function stopLogging() {
+    stdStreamsWrapper_1.default.disable();
+}
+// this allows to call deploy action with streaming enabled. This is meant for internal functions such as getPreloadConfig
+// that is called after a deployment being successful. We don't need to wrap the edgeConfig call since it will never be available for the user
+// since it runs before the deployment has finished and user has no way to access those logs.
+async function withLogging(action, req, lambdaInstance) {
+    try {
+        startLogging(req, lambdaInstance);
+        return await action();
+    }
+    finally {
+        stopLogging();
+    }
+}

package/node_modules/@layer0/core/lambda/lambdaInstance.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Objects of this class represent a single instantiation of an AWS Lambda function.
+ */
+export default class LambdaInstance {
+    private readonly _id;
+    private readonly _spawnedAt;
+    private _invocationCounter;
+    private _lifetimeDuration;
+    get id(): string;
+    get age(): number;
+    get invocationCounter(): number;
+    get lifetimeDuration(): number;
+    startInvocation(): void;
+    stopInvocation(duration: number): void;
+}
+/**
+ * Objects of this class represent a single invocation of an AWS Lambda function.
+ */
+export declare class LambdaInvocation {
+    private readonly _startTime;
+    private _stopTime;
+    private readonly _lambda;
+    private _isRunning;
+    get lambda(): LambdaInstance;
+    get duration(): number;
+    constructor(lambda: LambdaInstance);
+    start(): void;
+    stop(): void;
+}

package/node_modules/@layer0/core/lambda/lambdaInstance.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const uuid = __importStar(require("uuid"));
+/**
+ * Objects of this class represent a single instantiation of an AWS Lambda function.
+ */
+class LambdaInstance {
+    constructor() {
+        this._id = uuid.v4().toString();
+        this._spawnedAt = Date.now();
+        this._invocationCounter = 0;
+        this._lifetimeDuration = 0;
+    }
+    get id() {
+        return this._id;
+    }
+    get age() {
+        return Date.now() - this._spawnedAt;
+    }
+    get invocationCounter() {
+        return this._invocationCounter;
+    }
+    get lifetimeDuration() {
+        return this._lifetimeDuration;
+    }
+    startInvocation() {
+        ++this._invocationCounter;
+    }
+    stopInvocation(duration) {
+        this._lifetimeDuration += duration;
+    }
+}
+exports.default = LambdaInstance;
+/**
+ * Objects of this class represent a single invocation of an AWS Lambda function.
+ */
+class LambdaInvocation {
+    constructor(lambda) {
+        this._startTime = Date.now();
+        this._isRunning = false;
+        this._lambda = lambda;
+        this._stopTime = this._startTime;
+    }
+    get lambda() {
+        return this._lambda;
+    }
+    get duration() {
+        return this._stopTime - this._startTime;
+    }
+    start() {
+        if (!this._isRunning) {
+            this._isRunning = true;
+            this._lambda.startInvocation();
+        }
+    }
+    stop() {
+        if (this._isRunning) {
+            this._isRunning = false;
+            this._stopTime = Date.now();
+            this._lambda.stopInvocation(this.duration);
+        }
+    }
+}
+exports.LambdaInvocation = LambdaInvocation;

package/node_modules/@layer0/core/lambda/reqResMapper.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This file is modified version of: https://github.com/danielcondemarin/serverless-next.js/blob/master/packages/next-aws-lambda/lib/compatLayer.js
+ *
+ * Mods:
+ * - getHeader were only able to read lower case headers, but it was able to set upper case headers as well with writeHead,
+ *   so all headers are converted to lowercase now.
+ *
+ * - Gzippes the response on response end if matches the content-type
+ *
+ * - Removed variable for base64 support since we always return base64 from the lambdas.
+ */
+import { LambdaInvocation } from './lambdaInstance';
+export interface ReqResMapperOptions {
+    /**
+     * If `true`, duplicate queries in request will not be transformed to array
+     */
+    allowReqQueryDuplicates?: boolean;
+}
+declare const _default: (event: any, invocation: LambdaInvocation, options?: ReqResMapperOptions) => {
+    req: any;
+    res: any;
+    responsePromise: Promise<unknown>;
+};
+export default _default;

package/node_modules/@layer0/core/lambda/reqResMapper.js

@@ -0,0 +1,286 @@
+"use strict";
+/**
+ * This file is modified version of: https://github.com/danielcondemarin/serverless-next.js/blob/master/packages/next-aws-lambda/lib/compatLayer.js
+ *
+ * Mods:
+ * - getHeader were only able to read lower case headers, but it was able to set upper case headers as well with writeHead,
+ *   so all headers are converted to lowercase now.
+ *
+ * - Gzippes the response on response end if matches the content-type
+ *
+ * - Removed variable for base64 support since we always return base64 from the lambdas.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const qs_1 = require("qs");
+const uuid_1 = require("uuid");
+const adaptResponseEncodingToDownstream_1 = __importDefault(require("./adaptResponseEncodingToDownstream"));
+const stream_1 = __importDefault(require("stream"));
+const environment_1 = require("../environment");
+/**
+ * Gets the version of @layer0/core.  For this to work in testing an entry needed
+ * to be added to moduleNameMapper in the jest config specifically for package.json
+ *
+ * Notes:
+ * - In this module there are multiple places that need to read Layer0 version.
+ * But elegantly and correctly offering a single function to read Layer0 version is hard
+ * because these different places are transpiled, bundled and invoked in different
+ * contexts. For example, if we try to replace this with reading version from
+ * DeploymentBuilder then bundling fails.
+ *
+ * @return {String}
+ */
+function getLayer0Version() {
+    return process.env[constants_1.LAYER0_ENV_VARIABLES.versionOverride] || require('../../package.json').version;
+}
+exports.default = (event, invocation, options = {
+    allowReqQueryDuplicates: false,
+}) => {
+    const response = {
+        body: Buffer.from(''),
+        isBase64Encoded: true,
+        statusCode: 200,
+        statusMessage: 'OK',
+        multiValueHeaders: {},
+    };
+    let responsePromise;
+    const req = new stream_1.default.Readable();
+    // we provide url, path, and query (decoded), to match how express works so that development and production environment behave the same
+    req.url = event.path;
+    req.path = event.path;
+    req.query = {};
+    req.method = event.httpMethod;
+    req.rawHeaders = [];
+    req.headers = {};
+    if (event.multiValueQueryStringParameters &&
+        Object.keys(event.multiValueQueryStringParameters).length) {
+        Object.keys(event.multiValueQueryStringParameters).forEach(key => {
+            // keep backwards compatibility so that arrays with a single value are
+            // converted to just be that value:
+            const curVal = event.multiValueQueryStringParameters[key];
+            if (Array.isArray(curVal) && curVal.length === 1) {
+                event.multiValueQueryStringParameters[key] = curVal[0];
+            }
+        });
+        const qs = qs_1.stringify(event.multiValueQueryStringParameters, {
+            indices: !options.allowReqQueryDuplicates,
+        });
+        req.url += `?${qs}`;
+        req.query = qs_1.parse(qs); // we stringify and reparse to ensure that query parameters with a single value are not provided as an array
+    }
+    const headers = event.multiValueHeaders || {};
+    for (const key of Object.keys(headers)) {
+        // Compatibility with https://nodejs.org/api/all.html#http_message_rawheaders
+        // Header names are not lower-cased to maintain Node compatibility.
+        for (const value of headers[key]) {
+            req.rawHeaders.push(key);
+            req.rawHeaders.push(value);
+        }
+        // Compatibility with https://nodejs.org/api/all.html#http_message_headers
+        // Header names *are* lower-cased to maintain Node compatibility.
+        req.headers[key.toLowerCase()] = headers[key].toString();
+    }
+    req.getHeader = (name) => req.headers[name.toLowerCase()];
+    req.getHeaders = () => req.headers;
+    req.setHeader = (name, value) => {
+        req.headers[name.toLowerCase()] = value;
+    };
+    req.removeHeader = (name) => {
+        delete req.headers[name.toLowerCase()];
+    };
+    req.connection = {};
+    // Capture the downstream `accept-encoding` because compute can modify the `req` object
+    // and we need the accept encoding post-user code to compress the response.
+    const downstreamAcceptEncoding = req.getHeader(constants_1.HTTP_HEADERS.acceptEncoding);
+    // req.secure is ExpressJS extension, set to false only when the app is running locally or the protocol is HTTP
+    // (so the default remains HTTPS which has historically been the only protocol we allowed)
+    req.secure = !environment_1.isLocal() && req.getHeader(constants_1.HTTP_HEADERS.x0Protocol) !== 'http';
+    // Depending on the version req.socket.encrypted is set to true by NodeJS when the protocol is HTTPS.
+    req.socket = {
+        encrypted: req.secure,
+    };
+    // Depending on the version req.connection.encrypted is set to true by NodeJS when the protocol is HTTPS.
+    req.connection = {
+        encrypted: req.secure,
+    };
+    req.protocol = req.secure ? 'https' : 'http';
+    // If the downstream has sent us request ID we use it, otherwise we generate a new one.
+    // We have to repeat this code here *and* in Router *and* in XBP *and* in edge because
+    // each one of these components may be the first to receive the request:
+    // - Router when using `layer0 run`
+    // - Handler when using `layer0 run --production`
+    // - XBP when making request to cloud
+    // - Edge when making request to edge
+    let newRequestId;
+    if (!req.headers[constants_1.HTTP_HEADERS.xRequestId]) {
+        newRequestId = uuid_1.v4();
+        req.headers[constants_1.HTTP_HEADERS.xRequestId] = newRequestId;
+    }
+    const res = new stream_1.default();
+    Object.defineProperty(res, 'statusCode', {
+        get() {
+            return response.statusCode;
+        },
+        set(statusCode) {
+            response.statusCode = statusCode;
+        },
+    });
+    Object.defineProperty(res, 'statusMessage', {
+        get() {
+            return response.statusMessage;
+        },
+        set(statusMessage) {
+            response.statusMessage = statusMessage;
+        },
+    });
+    res.headers = {};
+    res.writeHead = (status, statusMessage, headers) => {
+        response.statusCode = status;
+        if (typeof statusMessage === 'string') {
+            response.statusMessage = statusMessage;
+        }
+        else {
+            if (typeof statusMessage === 'object') {
+                headers = statusMessage;
+                statusMessage = undefined;
+            }
+        }
+        if (typeof headers === 'object') {
+            Object.entries(headers).forEach(([name, value]) => {
+                res.setHeader(name, value);
+            });
+        }
+        // If this component has generated the new request ID then
+        // it is also responsible for sending it downstream.
+        if (newRequestId) {
+            res.setHeader(constants_1.HTTP_HEADERS.xRequestId, newRequestId);
+        }
+    };
+    res.write = (chunk) => {
+        response.body = Buffer.concat([
+            response.body,
+            Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk),
+        ]);
+    };
+    res.setHeader = (name, value) => {
+        res.headers[name.toLowerCase()] = value;
+    };
+    res.removeHeader = (name) => {
+        delete res.headers[name.toLowerCase()];
+    };
+    res.getHeader = (name) => {
+        return res.headers[name.toLowerCase()];
+    };
+    res.getHeaders = () => {
+        return res.headers;
+    };
+    const onResEnd = (resolve) => (text) => {
+        if (text) {
+            res.write(text);
+        }
+        // Compress the response if needed.
+        adaptResponseEncodingToDownstream_1.default(downstreamAcceptEncoding, res, response);
+        // We always respond with base64 so that we can serve non-text assets like images.
+        response.body = response.body.toString('base64');
+        response.multiValueHeaders = res.headers;
+        invocation.stop();
+        logStatusCode(response);
+        logExecutionTime(response, invocation);
+        logComponentVersion(response, getLayer0Version(), invocation.lambda.id);
+        fixApiGatewayMultipleHeaders();
+        resolve(response);
+    };
+    responsePromise = new Promise(resolve => {
+        res.end = onResEnd(resolve);
+    });
+    if (event.body) {
+        // We allow two ways to read the body. One is through stream events and
+        // the other is directly on the request object. The 2nd one is used
+        // internally by logging. This does not consume additional memory as
+        // event.body is alive during the whole lambda lifetime anyways.
+        req.push(event.body, event.isBase64Encoded ? 'base64' : undefined);
+        req._rawBodyBase64 = event.body;
+    }
+    req.push(null);
+    function fixApiGatewayMultipleHeaders() {
+        for (const key of Object.keys(response.multiValueHeaders)) {
+            if (!Array.isArray(response.multiValueHeaders[key])) {
+                response.multiValueHeaders[key] = [response.multiValueHeaders[key]];
+            }
+        }
+    }
+    return { req, res, responsePromise };
+};
+/**
+ * Adds an `x-0-status` header to the response based on the status code.
+ *
+ * Notes:
+ * - If the `x-0-status` already exists then the status is prefixed to upstream value.
+ *
+ * @param response The response event
+ * @private
+ */
+function logStatusCode(response) {
+    prefixResponseHeader(response, constants_1.HTTP_HEADERS.x0Status, `w=${response.statusCode}`);
+}
+/**
+ * Adds an `x-0-t` header to the response based on the current time.
+ *
+ * Notes:
+ * - If the `x-0-t` already exists then the execution time is prefixed to upstream value.
+ * - `wt` stands for "worker time", the duration of the current execution
+ * - `wc` stands for "worker count", the number of times the lambda has been invoked,
+ *   with the first invoication having the count of *1* (same as `pc` counter in XBP)
+ * - `wg` stands for "worker age", the number of milliseconds since the lambda instances was spawned
+ *   (`wa` already stands for request transformation time)
+ * - `wl` stands for "worker lifetime", the total lifetime duration
+ *
+ * @param response The response event
+ * @param startTime The start time of the request
+ * @private
+ */
+function logExecutionTime(response, invocation) {
+    const lambda = invocation.lambda;
+    prefixResponseHeader(response, constants_1.HTTP_HEADERS.x0T, `wt=${invocation.duration},wc=${lambda.invocationCounter},wg=${lambda.age},wl=${lambda.lifetimeDuration}`);
+}
+/**
+ * Adds an `x-0-components` header to the response based on the current time.
+ *
+ * Notes:
+ * - If the `x-0-components` already exists then the version is prefixed to upstream value.
+ * - `w` stands for "worker" and has the Layer0 version of the worker
+ * - `wi` stands for "worker id"
+ *
+ * @param response The response event
+ * @param version The Layer0 version of the package
+ * @private
+ */
+function logComponentVersion(response, version, lambdaId) {
+    prefixResponseHeader(response, constants_1.HTTP_HEADERS.x0Components, `w=${version},wi=${lambdaId}`);
+}
+/**
+ * Sets the response header to a new value by prefixing it with the given value or,
+ * if it doesn't exist, by setting it to the given value,
+ *
+ * @param response The response event
+ * @param headerName The name of the header to prefix or set
+ * @param prefixValue The value of the prefix without trailing comma
+ * @private
+ */
+function prefixResponseHeader(response, headerName, prefixValue) {
+    const headerValue = response.multiValueHeaders[headerName];
+    if (headerValue) {
+        if (Array.isArray(headerValue)) {
+            headerValue[0] = `${prefixValue},${headerValue[0]}`;
+        }
+        else {
+            response.multiValueHeaders[headerName] = `${prefixValue},${headerValue}`;
+        }
+    }
+    else {
+        response.multiValueHeaders[headerName] = `${prefixValue}`;
+    }
+}

package/node_modules/@layer0/core/lambda/stdStreamsWrapper.d.ts

@@ -0,0 +1,31 @@
+import LambdaInstance from './lambdaInstance';
+export declare function deepRequestInspectionLogger(instance: LambdaInstance): {
+    logDownstreamRequestInfo: (data: any) => void;
+    logDownstreamResponseInfo: (data: any) => void;
+    logUpstreamRequestInfo: (data: any) => void;
+    logUpstreamResponseInfo: (data: any) => void;
+    logUpstreamResponseBodyInfo: (data: any) => void;
+};
+declare const stdStreamsWrapper: {
+    /**
+     * Wraps console.xxx methods AND standard streams into a JSON payload that will
+     * be sent back to the final user in the log streaming interface.
+     *
+     * Notes:
+     * - We have to wrap standard streams because some logging libraries (like 'consola')
+     *   writes to those directly without going through console.xxx
+     * - We have to wrap console.xxx methods too, as they don't seem to be bound to
+     *   standard streams in AWS Lambda Environment. That wrapper (using pino) streams
+     *   to process.stdout, leading to the point below.
+     * - Both notes above would result in a double json encapsulation when logging via
+     *   console.xxx methods. We prevent that in our standard stream wrapper by detecting
+     *   a json string that coming from pino logger.
+     */
+    enable: ({ clientIp, requestId, wi, }?: {
+        clientIp?: string | undefined;
+        requestId?: string | undefined;
+        wi?: string | undefined;
+    }) => void;
+    disable: () => void;
+};
+export default stdStreamsWrapper;