Software: Apache/2.4.41 (Ubuntu). PHP/8.0.30 uname -a: Linux apirnd 5.4.0-204-generic #224-Ubuntu SMP Thu Dec 5 13:38:28 UTC 2024 x86_64 uid=33(www-data) gid=33(www-data) groups=33(www-data) Safe-mode: OFF (not secure) /var/www/html/sync/node_modules/google-logging-utils/build/src/ drwxr-xr-x | |
| Viewing file: Select action/file-type: "use strict";
// Copyright 2021-2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.env = exports.DebugLogBackendBase = exports.placeholder = exports.AdhocDebugLogger = exports.LogSeverity = void 0;
exports.getNodeBackend = getNodeBackend;
exports.getDebugBackend = getDebugBackend;
exports.getStructuredBackend = getStructuredBackend;
exports.setBackend = setBackend;
exports.log = log;
const node_events_1 = require("node:events");
const process = __importStar(require("node:process"));
const util = __importStar(require("node:util"));
const colours_1 = require("./colours");
// Some functions (as noted) are based on the Node standard library, from
// the following file:
//
// https://github.com/nodejs/node/blob/main/lib/internal/util/debuglog.js
/**
* This module defines an ad-hoc debug logger for Google Cloud Platform
* client libraries in Node. An ad-hoc debug logger is a tool which lets
* users use an external, unified interface (in this case, environment
* variables) to determine what logging they want to see at runtime. This
* isn't necessarily fed into the console, but is meant to be under the
* control of the user. The kind of logging that will be produced by this
* is more like "call retry happened", not "event you'd want to record
* in Cloud Logger".
*
* More for Googlers implementing libraries with it:
* go/cloud-client-logging-design
*/
/**
* Possible log levels. These are a subset of Cloud Observability levels.
* https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#LogSeverity
*/
var LogSeverity;
(function (LogSeverity) {
LogSeverity["DEFAULT"] = "DEFAULT";
LogSeverity["DEBUG"] = "DEBUG";
LogSeverity["INFO"] = "INFO";
LogSeverity["WARNING"] = "WARNING";
LogSeverity["ERROR"] = "ERROR";
})(LogSeverity || (exports.LogSeverity = LogSeverity = {}));
/**
* Our logger instance. This actually contains the meat of dealing
* with log lines, including EventEmitter. This contains the function
* that will be passed back to users of the package.
*/
class AdhocDebugLogger extends node_events_1.EventEmitter {
/**
* @param upstream The backend will pass a function that will be
* called whenever our logger function is invoked.
*/
constructor(namespace, upstream) {
super();
this.namespace = namespace;
this.upstream = upstream;
this.func = Object.assign(this.invoke.bind(this), {
// Also add an instance pointer back to us.
instance: this,
// And pull over the EventEmitter functionality.
on: (event, listener) => this.on(event, listener),
});
// Convenience methods for log levels.
this.func.debug = (...args) => this.invokeSeverity(LogSeverity.DEBUG, ...args);
this.func.info = (...args) => this.invokeSeverity(LogSeverity.INFO, ...args);
this.func.warn = (...args) => this.invokeSeverity(LogSeverity.WARNING, ...args);
this.func.error = (...args) => this.invokeSeverity(LogSeverity.ERROR, ...args);
this.func.sublog = (namespace) => log(namespace, this.func);
}
invoke(fields, ...args) {
// Push out any upstream logger first.
if (this.upstream) {
this.upstream(fields, ...args);
}
// Emit sink events.
this.emit('log', fields, args);
}
invokeSeverity(severity, ...args) {
this.invoke({ severity }, ...args);
}
}
exports.AdhocDebugLogger = AdhocDebugLogger;
/**
* This can be used in place of a real logger while waiting for Promises or disabling logging.
*/
exports.placeholder = new AdhocDebugLogger('', () => { }).func;
/**
* The base class for debug logging backends. It's possible to use this, but the
* same non-guarantees above still apply (unstable interface, etc).
*
* @private
* @internal
*/
class DebugLogBackendBase {
constructor() {
var _a;
this.cached = new Map();
this.filters = [];
this.filtersSet = false;
// Look for the Node config variable for what systems to enable. We'll store
// these for the log method below, which will call setFilters() once.
let nodeFlag = (_a = process.env[exports.env.nodeEnables]) !== null && _a !== void 0 ? _a : '*';
if (nodeFlag === 'all') {
nodeFlag = '*';
}
this.filters = nodeFlag.split(',');
}
log(namespace, fields, ...args) {
try {
if (!this.filtersSet) {
this.setFilters();
this.filtersSet = true;
}
let logger = this.cached.get(namespace);
if (!logger) {
logger = this.makeLogger(namespace);
this.cached.set(namespace, logger);
}
logger(fields, ...args);
}
catch (e) {
// Silently ignore all errors; we don't want them to interfere with
// the user's running app.
// e;
console.error(e);
}
}
}
exports.DebugLogBackendBase = DebugLogBackendBase;
// The basic backend. This one definitely works, but it's less feature-filled.
//
// Rather than using util.debuglog, this implements the same basic logic directly.
// The reason for this decision is that debuglog checks the value of the
// NODE_DEBUG environment variable before any user code runs; we therefore
// can't pipe our own enables into it (and util.debuglog will never print unless
// the user duplicates it into NODE_DEBUG, which isn't reasonable).
//
class NodeBackend extends DebugLogBackendBase {
constructor() {
super(...arguments);
// Default to allowing all systems, since we gate earlier based on whether the
// variable is empty.
this.enabledRegexp = /.*/g;
}
isEnabled(namespace) {
return this.enabledRegexp.test(namespace);
}
makeLogger(namespace) {
if (!this.enabledRegexp.test(namespace)) {
return () => { };
}
return (fields, ...args) => {
var _a;
// TODO: `fields` needs to be turned into a string here, one way or another.
const nscolour = `${colours_1.Colours.green}${namespace}${colours_1.Colours.reset}`;
const pid = `${colours_1.Colours.yellow}${process.pid}${colours_1.Colours.reset}`;
let level;
switch (fields.severity) {
case LogSeverity.ERROR:
level = `${colours_1.Colours.red}${fields.severity}${colours_1.Colours.reset}`;
break;
case LogSeverity.INFO:
level = `${colours_1.Colours.magenta}${fields.severity}${colours_1.Colours.reset}`;
break;
case LogSeverity.WARNING:
level = `${colours_1.Colours.yellow}${fields.severity}${colours_1.Colours.reset}`;
break;
default:
level = (_a = fields.severity) !== null && _a !== void 0 ? _a : LogSeverity.DEFAULT;
break;
}
const msg = util.formatWithOptions({ colors: colours_1.Colours.enabled }, ...args);
const filteredFields = Object.assign({}, fields);
delete filteredFields.severity;
const fieldsJson = Object.getOwnPropertyNames(filteredFields).length
? JSON.stringify(filteredFields)
: '';
const fieldsColour = fieldsJson
? `${colours_1.Colours.grey}${fieldsJson}${colours_1.Colours.reset}`
: '';
console.error('%s [%s|%s] %s%s', pid, nscolour, level, msg, fieldsJson ? ` ${fieldsColour}` : '');
};
}
// Regexp patterns below are from here:
// https://github.com/nodejs/node/blob/c0aebed4b3395bd65d54b18d1fd00f071002ac20/lib/internal/util/debuglog.js#L36
setFilters() {
const totalFilters = this.filters.join(',');
const regexp = totalFilters
.replace(/[|\\{}()[\]^$+?.]/g, '\\$&')
.replace(/\*/g, '.*')
.replace(/,/g, '$|^');
this.enabledRegexp = new RegExp(`^${regexp}$`, 'i');
}
}
/**
* @returns A backend based on Node util.debuglog; this is the default.
*/
function getNodeBackend() {
return new NodeBackend();
}
class DebugBackend extends DebugLogBackendBase {
constructor(pkg) {
super();
this.debugPkg = pkg;
}
makeLogger(namespace) {
const debugLogger = this.debugPkg(namespace);
return (fields, ...args) => {
// TODO: `fields` needs to be turned into a string here.
debugLogger(args[0], ...args.slice(1));
};
}
setFilters() {
var _a;
const existingFilters = (_a = process.env['NODE_DEBUG']) !== null && _a !== void 0 ? _a : '';
process.env['NODE_DEBUG'] = `${existingFilters}${existingFilters ? ',' : ''}${this.filters.join(',')}`;
}
}
/**
* Creates a "debug" package backend. The user must call require('debug') and pass
* the resulting object to this function.
*
* ```
* setBackend(getDebugBackend(require('debug')))
* ```
*
* https://www.npmjs.com/package/debug
*
* Note: Google does not explicitly endorse or recommend this package; it's just
* being provided as an option.
*
* @returns A backend based on the npm "debug" package.
*/
function getDebugBackend(debugPkg) {
return new DebugBackend(debugPkg);
}
/**
* This pretty much works like the Node logger, but it outputs structured
* logging JSON matching Google Cloud's ingestion specs. Rather than handling
* its own output, it wraps another backend. The passed backend must be a subclass
* of `DebugLogBackendBase` (any of the backends exposed by this package will work).
*/
class StructuredBackend extends DebugLogBackendBase {
constructor(upstream) {
var _a;
super();
this.upstream = (_a = upstream) !== null && _a !== void 0 ? _a : new NodeBackend();
}
makeLogger(namespace) {
const debugLogger = this.upstream.makeLogger(namespace);
return (fields, ...args) => {
var _a;
const severity = (_a = fields.severity) !== null && _a !== void 0 ? _a : LogSeverity.INFO;
const json = Object.assign({
severity,
message: util.format(...args),
}, fields);
const jsonString = JSON.stringify(json);
debugLogger(fields, jsonString);
};
}
setFilters() {
this.upstream.setFilters();
}
}
/**
* Creates a "structured logging" backend. This pretty much works like the
* Node logger, but it outputs structured logging JSON matching Google
* Cloud's ingestion specs instead of plain text.
*
* ```
* setBackend(getStructuredBackend())
* ```
*
* @param upstream If you want to use something besides the Node backend to
* write the actual log lines into, pass that here.
* @returns A backend based on Google Cloud structured logging.
*/
function getStructuredBackend(upstream) {
return new StructuredBackend(upstream);
}
/**
* The environment variables that we standardized on, for all ad-hoc logging.
*/
exports.env = {
/**
* Filter wildcards specific to the Node syntax, and similar to the built-in
* utils.debuglog() environment variable. If missing, disables logging.
*/
nodeEnables: 'GOOGLE_SDK_NODE_LOGGING',
};
// Keep a copy of all namespaced loggers so users can reliably .on() them.
// Note that these cached functions will need to deal with changes in the backend.
const loggerCache = new Map();
// Our current global backend. This might be:
let cachedBackend = undefined;
/**
* Set the backend to use for our log output.
* - A backend object
* - null to disable logging
* - undefined for "nothing yet", defaults to the Node backend
*
* @param backend Results from one of the get*Backend() functions.
*/
function setBackend(backend) {
cachedBackend = backend;
loggerCache.clear();
}
/**
* Creates a logging function. Multiple calls to this with the same namespace
* will produce the same logger, with the same event emitter hooks.
*
* Namespaces can be a simple string ("system" name), or a qualified string
* (system:subsystem), which can be used for filtering, or for "system:*".
*
* @param namespace The namespace, a descriptive text string.
* @returns A function you can call that works similar to console.log().
*/
function log(namespace, parent) {
// If the enable flag isn't set, do nothing.
const enablesFlag = process.env[exports.env.nodeEnables];
if (!enablesFlag) {
return exports.placeholder;
}
// This might happen mostly if the typings are dropped in a user's code,
// or if they're calling from JavaScript.
if (!namespace) {
return exports.placeholder;
}
// Handle sub-loggers.
if (parent) {
namespace = `${parent.instance.namespace}:${namespace}`;
}
// Reuse loggers so things like event sinks are persistent.
const existing = loggerCache.get(namespace);
if (existing) {
return existing.func;
}
// Do we have a backend yet?
if (cachedBackend === null) {
// Explicitly disabled.
return exports.placeholder;
}
else if (cachedBackend === undefined) {
// One hasn't been made yet, so default to Node.
cachedBackend = getNodeBackend();
}
// The logger is further wrapped so we can handle the backend changing out.
const logger = (() => {
let previousBackend = undefined;
const newLogger = new AdhocDebugLogger(namespace, (fields, ...args) => {
if (previousBackend !== cachedBackend) {
// Did the user pass a custom backend?
if (cachedBackend === null) {
// Explicitly disabled.
return;
}
else if (cachedBackend === undefined) {
// One hasn't been made yet, so default to Node.
cachedBackend = getNodeBackend();
}
previousBackend = cachedBackend;
}
cachedBackend === null || cachedBackend === void 0 ? void 0 : cachedBackend.log(namespace, fields, ...args);
});
return newLogger;
})();
loggerCache.set(namespace, logger);
return logger.func;
}
//# sourceMappingURL=logging-utils.js.map |
:: Command execute :: | |
--[ c99shell v. 2.5 [PHP 8 Update] [24.05.2025] | Generation time: 0.0051 ]-- |