Socket
Socket
Sign inDemoInstall

electron-log

Package Overview
Dependencies
Maintainers
1
Versions
152
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

electron-log - npm Package Compare versions

Comparing version 2.2.17 to 3.0.0-beta

lib/transports/main-console.js
lib/utils.js

52

electron-log.d.ts

@@ -1,13 +0,25 @@

export type LogLevel = "error" | "warn" | "info" | "verbose" | "debug" |
export type ILogLevel = "error" | "warn" | "info" | "verbose" | "debug" |
"silly";
export type LevelOption = LogLevel | false;
export type ILevelOption = ILogLevel | false;
export type ILevels = Array<ILogLevel | string>;
export type IFormat = (msg: ILogMessage) => void;
export type FOpenFlags = "r" | "r+" | "rs+" | "w" | "wx" | "w+" | "wx+" |
export type IFOpenFlags = "r" | "r+" | "rs+" | "w" | "wx" | "w+" | "wx+" |
"a" | "ax" | "a+" | "ax+";
export type IHook = (
msg: ILogMessage,
selectedTransports?: ITransports,
) => ILogMessage | false;
export interface IVariables {
[name: string]: any;
}
export interface ILogMessage {
data: any[];
date: Date;
level: LogLevel;
level: ILogLevel;
variables?: IVariables;
}

@@ -17,3 +29,3 @@

(msg: ILogMessage): void;
level: LevelOption;
level: ILevelOption;
}

@@ -27,15 +39,16 @@

appName?: string;
bytesWritten: number;
file?: string;
fileName: string;
format: IFormat | string;
maxSize: number;
stream: any;
streamConfig?: {
flags?: FOpenFlags;
sync: boolean;
writeOptions?: {
flag?: IFOpenFlags;
mode?: number;
encoding?: string;
fd?: number;
mode?: number;
autoClose?: boolean;
start?: number;
};
findLogPath(appName?: string): string;
clear();
findLogPath(appName?: string, fileName?: string): string;
init();
}

@@ -53,3 +66,4 @@

logS: ILogSTransport;
rendererConsole: IConsoleTransport;
mainConsole?: ITransport;
rendererConsole?: ITransport;
[key: string]: ITransport;

@@ -60,2 +74,6 @@ }

transports: ITransports;
hooks: IHook[];
levels: ILevels;
variables: IVariables;
error(...params: any[]): void;

@@ -70,2 +88,7 @@ warn(...params: any[]): void;

export declare const transports: ITransports;
export declare const hooks: IHook[];
export declare const levels: ILevels;
export declare const variables: IVariables;
export declare function error(...params: any[]): void;

@@ -78,5 +101,4 @@ export declare function warn(...params: any[]): void;

export declare function log(...params: any[]): void;
export declare const transports: ITransports;
declare const _d: IElectronLog;
export default _d;

35

index.js
'use strict';
if (process.type === 'renderer') {
module.exports = require('./renderer');
} else {
module.exports = require('./main');
}
var log = require('./lib/log');
var transportConsole = require('./lib/transports/console');
var transportFile = require('./lib/transports/file');
var transportLogS = require('./lib/transports/log-s');
var transportMainConsole = require('./lib/transports/main-console');
var transportRendererConsole = require('./lib/transports/renderer-console');
var utils = require('./lib/utils');
module.exports = {
hooks: [],
isDev: utils.isDev(),
levels: ['error', 'warn', 'info', 'verbose', 'debug', 'silly'],
variables: {
processType: process.type
}
};
module.exports.transports = {
console: transportConsole(module.exports),
file: transportFile(module.exports),
logS: transportLogS(module.exports),
mainConsole: transportMainConsole(module.exports),
rendererConsole: transportRendererConsole(module.exports)
};
module.exports.levels.forEach(function (level) {
module.exports[level] = log.bind(null, module.exports, level);
});
module.exports.default = module.exports;

50

lib/format.js
'use strict';
var util = require('util');
var EOL = require('os').EOL;

@@ -10,13 +9,29 @@ module.exports = {

pad: pad,
stringifyArray: stringifyArray
stringifyObject: stringifyObject
};
function format(msg, formatter) {
/**
* Transform Message object to a string
* @param {object} msg
* @param {string|function} formatter
* @param {object} [electronLog]
* @return {string}
*/
function format(msg, formatter, electronLog) {
electronLog = electronLog || {};
if (typeof formatter === 'function') {
return formatter(msg);
return formatter(msg, electronLog);
}
var date = msg.date;
var date = new Date(msg.date || Date.now());
var variables = msg.variables;
var result = formatter;
return formatter
for (var i in variables) {
if (!variables.hasOwnProperty(i)) continue;
result = result.replace('{' + i + '}', variables[i]);
}
return result
.replace('{level}', msg.level)

@@ -35,8 +50,17 @@ .replace('{text}', stringifyArray(msg.data))

function stringifyArray(data) {
data = data.map(function formatErrors(arg) {
return arg instanceof Error ? arg.stack + EOL : arg;
});
return util.format.apply(util, data);
return util.format.apply(util, data.map(stringifyObject));
}
function stringifyObject(data) {
if (typeof data === 'function') {
return data.toString();
}
if (data instanceof Error) {
return data.stack;
}
return data;
}
function pad(number, zeros) {

@@ -49,5 +73,5 @@ zeros = zeros || 2;

var m = Math.abs(minutesOffset);
return (minutesOffset >= 0 ? '-' : '+') +
pad(Math.floor(m / 60)) + ':' +
pad(m % 60);
return (minutesOffset >= 0 ? '-' : '+')
+ pad(Math.floor(m / 60)) + ':'
+ pad(m % 60);
}

64

lib/log.js

@@ -1,42 +0,60 @@

// jshint -W040
'use strict';
var LEVELS = ['error', 'warn', 'info', 'verbose', 'debug', 'silly'];
log.compareLevels = compareLevels;
module.exports = log;
function log(transports, level, text) {
var data = Array.prototype.slice.call(arguments, 2);
var msg = {
data: data,
function log(electronLog, level) {
var transports = filterTransportsByLevel(electronLog, level);
var msg = transformMsgByHooks(electronLog, transports, {
data: Array.prototype.slice.call(arguments, 2),
date: new Date(),
level: level
};
level: level,
variables: electronLog.variables
});
if (!msg) return;
for (var i in transports) {
// jshint -W089
if (!transports.hasOwnProperty(i) || typeof transports[i] !== 'function') {
continue;
if (transports.hasOwnProperty(i) && typeof transports[i] === 'function') {
transports[i].call(null, msg);
}
}
}
var transport = transports[i];
function filterTransportsByLevel(electronLog, level) {
var transports = electronLog.transports;
var levels = electronLog.levels;
if (transport === false || !compareLevels(transport.level, level)) {
continue;
}
var filtered = {};
if (transport.level === false) continue;
for (var i in transports) {
if (!transports.hasOwnProperty(i)) continue;
if (!transports[i]) continue;
if (transports[i].level === false) continue;
if (!compareLevels(levels, transports[i].level, level)) continue;
transport.call(null, msg);
filtered[i] = transports[i];
}
return filtered;
}
function compareLevels(passLevel, checkLevel) {
var pass = LEVELS.indexOf(passLevel);
var check = LEVELS.indexOf(checkLevel);
function compareLevels(levels, passLevel, checkLevel) {
var pass = levels.indexOf(passLevel);
var check = levels.indexOf(checkLevel);
if (check === -1 || pass === -1) {
return true;
}
return check <= pass;
}
}
function transformMsgByHooks(electronLog, activeTransports, msg) {
if (!electronLog.hooks || !electronLog.hooks.length) {
return msg;
}
return electronLog.hooks.reduce(function logHook(prevMsg, hook) {
return prevMsg ? hook(prevMsg, activeTransports) : prevMsg;
}, msg);
}

24

lib/transports/console.js

@@ -6,15 +6,19 @@ 'use strict';

transport.level = 'silly';
transport.format = '[{h}:{i}:{s}.{ms}] [{level}] {text}';
module.exports = consoleTransportFactory;
module.exports = transport;
function consoleTransportFactory(electronLog) {
transport.level = 'silly';
transport.format = '[{h}:{i}:{s}.{ms}] [{level}] {text}';
function transport(msg) {
var text = format.format(msg, transport.format);
if (originalConsole[msg.level]) {
originalConsole[msg.level](text);
} else {
originalConsole.log(text);
return transport;
function transport(msg) {
var text = format.format(msg, transport.format, electronLog);
if (originalConsole[msg.level]) {
originalConsole[msg.level](text);
} else {
originalConsole.log(text);
}
}
}

52

lib/transports/file/find-log-path.js
'use strict';
var fs = require('fs');
var path = require('path');
var os = require('os');
var fs = require('fs');
var path = require('path');
var os = require('os');
var utils = require('../../utils');
var getAppName = require('./get-app-name');

@@ -13,25 +14,17 @@

* @param {string} [appName] Used to determine the last part of a log path
* @param {string} [fileName='log.log']
* @return {string|boolean}
*/
function findLogPath(appName) {
function findLogPath(appName, fileName) {
fileName = fileName || 'log.log';
var userData = appName ? null : utils.getUserData();
appName = appName || getAppName();
if (!appName) {
return false;
}
var homeDir = os.homedir ? os.homedir() : process.env['HOME'];
var homeDir = os.homedir ? os.homedir() : process.env.HOME;
var dir;
switch (process.platform) {
case 'linux': {
dir = prepareDir(process.env['XDG_CONFIG_HOME'], appName)
.or(homeDir, '.config', appName)
.or(process.env['XDG_DATA_HOME'], appName)
.or(homeDir, '.local', 'share', appName)
.result;
break;
}
case 'darwin': {
dir = prepareDir(homeDir, 'Library', 'Logs', appName)
.or(userData)
.or(homeDir, 'Library', 'Application Support', appName)

@@ -43,3 +36,4 @@ .result;

case 'win32': {
dir = prepareDir(process.env['APPDATA'], appName)
dir = prepareDir(userData)
.or(process.env.APPDATA, appName)
.or(homeDir, 'AppData', 'Roaming', appName)

@@ -49,15 +43,22 @@ .result;

}
default: {
dir = prepareDir(userData)
.or(process.env.XDG_CONFIG_HOME, appName)
.or(homeDir, '.config', appName)
.or(process.env.XDG_DATA_HOME, appName)
.or(homeDir, '.local', 'share', appName)
.result;
break;
}
}
if (dir) {
return path.join(dir, 'log.log');
} else {
return false;
return path.join(dir, fileName);
}
return false;
}
function prepareDir(dirPath) {
// jshint -W040
if (!this || this.or !== prepareDir || !this.result) {

@@ -68,3 +69,2 @@ if (!dirPath) {

//noinspection JSCheckFunctionSignatures
dirPath = path.join.apply(path, arguments);

@@ -71,0 +71,0 @@ mkDir(dirPath);

23

lib/transports/file/get-app-name.js

@@ -1,2 +0,1 @@

// jshint -W074
'use strict';

@@ -8,3 +7,3 @@

var path = require('path');
var consoleTransport = require('../console');
var utils = require('../../utils');

@@ -14,7 +13,13 @@ module.exports = getAppName;

function getAppName() {
var name = utils.getElectronAppName();
if (name) {
return name;
}
try {
var name = loadPackageName();
name = loadPackageName();
if (name) {
return name;
}
return warn('electron-log: unable to load the app name from package.json');

@@ -38,3 +43,5 @@ } catch (e) {

}
} catch (e) {}
} catch (e) {
packageFile = null;
}

@@ -89,7 +96,3 @@ if (!packageFile && process.resourcesPath) {

function warn(message) {
consoleTransport({
data: [message],
date: new Date(),
level: 'warn'
});
}
console.warn(message);
}

168

lib/transports/file/index.js
'use strict';
var fs = require('fs');
var EOL = require('os').EOL;
var format = require('../../format');
var consoleTransport = require('../console');
var findLogPath = require('./find-log-path');
var fs = require('fs');
var EOL = require('os').EOL;
var path = require('path');
var format = require('../../format');
var findLogPath = require('./find-log-path');
transport.findLogPath = findLogPath;
transport.format = '[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}] {text}';
transport.level = 'warn';
transport.maxSize = 1024 * 1024;
transport.streamConfig = undefined;
module.exports = fileTransportFactory;
module.exports = transport;
function fileTransportFactory(electronLog) {
transport.appName = null;
transport.bytesWritten = 0;
transport.file = null;
transport.fileName = 'log.log';
transport.fileSize = null;
transport.format = '[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}] {text}';
transport.level = 'silly';
transport.maxSize = 1024 * 1024;
transport.sync = false;
transport.writeOptions = {
flag: 'a',
mode: 438, // 0666
encoding: 'utf8'
};
function transport(msg) {
var text = format.format(msg, transport.format) + EOL;
transport.clear = clear;
transport.findLogPath = findCurrentLogPath.bind(null, transport);
transport.init = init;
if (transport.stream === undefined) {
initSteamConfig();
openStream();
}
return transport;
if (transport.level === false) {
return;
}
function transport(msg) {
if (transport.level === false) {
return;
}
var needLogRotation = transport.maxSize > 0 &&
getStreamSize(transport.stream) > transport.maxSize;
if (!transport.file || transport.fileSize === null) {
init(transport);
}
if (needLogRotation) {
archiveLog(transport.stream);
openStream();
var needLogRotation = transport.maxSize > 0
&& transport.fileSize + transport.bytesWritten > transport.maxSize;
if (needLogRotation) {
archiveLog(transport.file);
init(transport);
}
write(format.format(msg, transport.format) + EOL, transport);
}
transport.stream.write(text);
}
function init(transp) {
transp = transp || transport;
function initSteamConfig() {
transport.file = transport.file || findLogPath(transport.appName);
transp.file = findCurrentLogPath(transp);
if (!transport.file) {
transport.level = false;
logConsole('Could not set a log file');
if (!transp.file) {
transp.level = false;
logConsole('Could not set a log file');
return;
}
try {
transp.fileSize = fs.statSync(transp.file).size;
} catch (e) {
transp.fileSize = 0;
}
transp.bytesWritten = 0;
}
}
function openStream() {
if (transport.level === false) {
return;
function write(text, transp) {
if (transp.sync) {
try {
fs.writeFileSync(transp.file, text, transp.writeOptions);
incCounter(text, transp);
} catch (e) {
logConsole('Couldn\'t write to ' + transp.file, e);
}
} else {
fs.writeFile(transp.file, text, transp.writeOptions, function (e) {
if (e) {
logConsole('Couldn\'t write to ' + transp.file, e);
} else {
incCounter(text, transp);
}
});
}
}
transport.stream = fs.createWriteStream(
transport.file,
transport.streamConfig || { flags: 'a' }
);
}
function getStreamSize(stream) {
if (!stream) {
return 0;
function incCounter(text, transp) {
transp.bytesWritten += Buffer.byteLength(
text,
transp.writeOptions.encoding
);
}
if (stream.logSizeAtStart === undefined) {
function archiveLog(file) {
var info = path.parse(file);
try {
stream.logSizeAtStart = fs.statSync(stream.path).size;
fs.renameSync(file, path.join(info.dir, info.name + '.old' + info.ext));
} catch (e) {
stream.logSizeAtStart = 0;
logConsole('Could not rotate log', e);
}
}
return stream.logSizeAtStart + stream.bytesWritten;
}
function archiveLog(stream) {
if (stream.end) {
stream.end();
function clear() {
try {
fs.unlinkSync(transport.file);
} catch (e) {
logConsole('Could not clear log', e);
}
}
try {
fs.renameSync(stream.path, stream.path.replace(/log$/, 'old.log'));
} catch (e) {
logConsole('Could not rotate log', e);
function findCurrentLogPath(transp) {
return transp.file
|| findLogPath(transp.appName, transp.fileName);
}
}
function logConsole(message, error) {
var data = ['electron-log.transports.file: ' + message];
function logConsole(message, error) {
var data = ['electron-log.transports.file: ' + message];
if (error) {
data.push(error);
if (error) {
data.push(error);
}
electronLog.transports.console({
data: data,
date: new Date(),
level: 'warn'
});
}
consoleTransport({ data: data, date: new Date(), level: 'warn' });
}

34

lib/transports/log-s.js

@@ -1,2 +0,1 @@

// jshint -W074, -W089
'use strict';

@@ -8,9 +7,13 @@

transport.client = { name: 'electron-application' };
transport.depth = 6;
transport.level = false;
transport.url = null;
module.exports = logSTransportFactory;
module.exports = transport;
function logSTransportFactory() {
transport.client = { name: 'electron-application' };
transport.depth = 6;
transport.level = false;
transport.url = null;
return transport;
}
function transport(msg) {

@@ -31,3 +34,3 @@ if (!transport.url) return;

var urlObject = url.parse(serverUrl);
var transport = urlObject.protocol === 'https:' ? https : http;
var htTransport = urlObject.protocol === 'https:' ? https : http;

@@ -42,8 +45,8 @@ var body = JSON.stringify(data);

headers: {
'Content-Type': 'application/json',
'Content-Length': body.length
'Content-Length': body.length,
'Content-Type': 'application/json'
}
};
var request = transport.request(options);
var request = htTransport.request(options);
request.write(body);

@@ -55,4 +58,5 @@ request.end();

if (depth < 1) {
if (Array.isArray(json)) return '[array]';
if (typeof json === 'object') return '[object]';
if (Array.isArray(json)) return '[array]';
if (typeof json === 'object') return '[object]';
return json;

@@ -62,3 +66,3 @@ }

if (Array.isArray(json)) {
return json.map(function(child) {
return json.map(function (child) {
return jsonDepth(child, depth - 1);

@@ -83,3 +87,3 @@ });

for (var i in json) {
//noinspection JSUnfilteredForInLoop
if (!Object.prototype.hasOwnProperty.call(json, i)) continue;
newJson[i] = jsonDepth(json[i], depth - 1);

@@ -92,2 +96,2 @@ }

return json;
}
}

30

lib/transports/renderer-console.js
'use strict';
var BrowserWindow;
try {
BrowserWindow = require('electron').BrowserWindow;
} catch (e) {
BrowserWindow = null;
}
var format = require('../format');
var utils = require('../utils');
transport.level = BrowserWindow ? 'silly' : false;
transport.format = '[{h}:{i}:{s}.{ms}] {text}';
var IPC_EVENT = '__ELECTRON_LOG_RENDERER_CONSOLE__';
module.exports = transport;
module.exports = renderConsoleTransportFactory;
function transport(msg) {
if (!BrowserWindow) return;
function renderConsoleTransportFactory(electronLog) {
transport.level = electronLog.isDev ? 'silly' : false;
transport.format = '[{h}:{i}:{s}.{ms}] {text}';
var text = format.format(msg, transport.format);
BrowserWindow.getAllWindows().forEach(function(wnd) {
wnd.webContents.send('__ELECTRON_LOG_RENDERER__', msg.level, text);
utils.onIpcRenderer(IPC_EVENT, function (event, msg) {
electronLog.transports.console(msg);
});
return process.type === 'browser' ? transport : null;
function transport(msg) {
msg.data = msg.data.map(format.stringifyObject);
utils.sendIpcToRenderer(IPC_EVENT, msg);
}
}

50

main.js
'use strict';
var electron;
try {
electron = require('electron');
} catch (e) {
electron = null;
}
var log = require('./lib/log');
var transportConsole = require('./lib/transports/console');
var transportFile = require('./lib/transports/file');
var transportLogS = require('./lib/transports/log-s');
var transportRendererConsole = require('./lib/transports/renderer-console');
var transports = {
console: transportConsole,
file: transportFile,
logS: transportLogS,
rendererConsole: transportRendererConsole
};
module.exports = {
transports: transports,
error: log.bind(null, transports, 'error'),
warn: log.bind(null, transports, 'warn'),
info: log.bind(null, transports, 'info'),
verbose: log.bind(null, transports, 'verbose'),
debug: log.bind(null, transports, 'debug'),
silly: log.bind(null, transports, 'silly'),
log: log.bind(null, transports, 'info')
};
module.exports.default = module.exports;
if (electron && electron.ipcMain) {
electron.ipcMain.on('__ELECTRON_LOG__', onRendererLog);
var appName = electron.app.getName();
if (appName !== 'Electron') {
transportFile.appName = appName;
}
}
function onRendererLog(event, data) {
if (Array.isArray(data)) {
data.unshift(transports);
log.apply(null, data);
}
}
module.exports = require('./index');
console.warn('electron-log/main is deprecated and will be removed in v4');

41

package.json
{
"name": "electron-log",
"version": "2.2.17",
"version": "3.0.0-beta",
"description": "Just a very simple logging module for your Electron application",
"main": "./index.js",
"main": "index.js",
"scripts": {
"test": "npm run jshint && npm run jscs && npm run tslint && npm run mocha && npm run test-projects",
"mocha": "mocha index.spec.js lib/{,**/}{,**/}*.spec.js",
"test-projects": "mocha test-projects/**/*.spec.js",
"test-projects-install": "node test-projects/install.js",
"jscs": "jscs .",
"jshint": "jshint --exclude ./node_modules,./test-projects . --verbose",
"lint": "eslint '**/*.js' --ignore-pattern '**/dist/*.js'",
"mocha": "mocha '**/*.spec.js' --exclude 'test-projects/**' --exclude 'node_modules/**'",
"test": "npm run lint && npm run tslint && npm run mocha && npm run test-projects",
"test-projects": "mocha 'test-projects/**/*.spec.js'",
"tslint": "tslint electron-log.d.ts"
},
"typings": "./electron-log.d.ts",
"repository": {
"type": "git",
"url": "git+https://github.com/megahertz/electron-log.git"
},
"typings": "electron-log.d.ts",
"repository": "megahertz/electron-log",
"files": [

@@ -42,16 +37,20 @@ "index.js",

"license": "MIT",
"bugs": {
"url": "https://github.com/megahertz/electron-log/issues"
},
"bugs": "https://github.com/megahertz/electron-log/issues",
"homepage": "https://github.com/megahertz/electron-log#readme",
"devDependencies": {
"@babel/core": "*",
"@babel/preset-env": "*",
"babel-loader": "*",
"chai": "*",
"jscs": "*",
"jshint": "*",
"jshint-reporter-jscs": "*",
"electron": "*",
"eslint": "*",
"eslint-config-airbnb-base": "*",
"eslint-plugin-import": "*",
"mocha": "*",
"rewire": "*",
"nw": "0.31",
"tslint": "*",
"typescript": "*"
"typescript": "*",
"webpack": "*",
"webpack-cli": "*"
}
}

147

README.md

@@ -10,3 +10,3 @@ # electron-log

No dependencies. No complicated configuration. Just require and use.
It can be used without Electron.
Also, it can be used without Electron in any node

@@ -28,3 +28,3 @@ By default it writes logs to the following locations:

```js
var log = require('electron-log');
const log = require('electron-log');

@@ -34,5 +34,2 @@ log.info('Hello, log');

If you would like to use electron-log in a renderer process only, you
should require it in the main process too.
### Log levels

@@ -46,97 +43,101 @@

Transport is a simple function which requires an object which describes
a message. By default, two transports are active: console and file.
Transport is a simple function which does some work with log message.
By default, two transports are active: console and file.
**Please be aware that the file log level is 'warn' by default, so info
and debug messages won't be written to a log file.**
#### Console transport
The file path is dependent on the current platform.
Just prints a log message to application console (main process) or to
DevTool console (renderer process).
Transport config is available only inside the main process.
##### Options
#### Disable default transport:
- **[format](doc/format.md)**, default
``'[{h}:{i}:{s}.{ms}] [{level}] {text}'``
- **level**, default 'silly'
```js
log.transports.file.level = false;
log.transports.console.level = false;
```
#### File transport
#### Override transport:
The file transport writes log messages to a file.
```js
var format = require('util');
##### Options
log.transports.console = function(msg) {
var text = util.format.apply(util, msg.data);
console.log(`[${msg.date.toLocaleTimeString()} ${msg.level}] ${text}`);
};
```
Please be aware that if you override a transport function the default
transport options (like level or format) will be undefined.
- **appName** determines a location of log file, something like
`~/.config/<app name>/log.log` depending on OS. By default
electron-log reads this value from `name` or `productName` value in
`package.json`. In most cases you should keep default value.
#### Console Transport
- **file** - The full log file path. I can recommend to change this
value only if you strongly understand what are you doing. If set,
`appName` and `fileName` options are ignored.
```js
// Log level
log.transports.console.level = 'warn';
- **fileName**, default 'log.log'
- **[format](doc/format.md)**, default
``'[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}] {text}'``
- **level**, default 'silly'
- **maxSize** of log file in bytes, 1048576 (1mb) by default. When a
log file exceeds this limit, it will be moved to log.old.log file
and the current file will be cleared. You can set it to `0` to disable
this feature.
- **sync** allows to write a log file synchronously. Default to false.
- **writeOptions**
- **[flag](https://nodejs.org/api/fs.html#fs_file_system_flags)**,
default 'a'
- **mode**, default 0666
- **encoding**, default 'utf8'
/**
* Set output format template. Available variables:
* Main: {level}, {text}
* Date: {y},{m},{d},{h},{i},{s},{ms},{z}
*/
log.transports.console.format = '{h}:{i}:{s}:{ms} {text}';
##### Methods
// Set a function which formats output
log.transports.console.format = (msg) => util.format.apply(util, msg.data);
```
- **clear()** - Clear the current log file
- **findLogPath()** - Return full path of the current log file
- **init()** - In most cases, you don't need to call it manually. Try
to call only if you change `appName`, `file` or `fileName` property,
but it has no effect.
#### Renderer Console transport
Show logs in Chromium DevTools Console. It has the same options as
console transport.
#### Renderer console transport
#### File transport
When logging inside main process, it shows log in DevTools console too.
This transport can impact on performance, so it's disabled by default
for packaged application.
```js
// Same as for console transport
log.transports.file.level = 'warn';
log.transports.file.format = '{h}:{i}:{s}:{ms} {text}';
#### Main console transport
// Set approximate maximum log size in bytes. When it exceeds,
// the archived log will be saved as the log.old.log file
log.transports.file.maxSize = 5 * 1024 * 1024;
When logging inside renderer process, it shows log in application
console too. This transport can impact on performance, so it's disabled
by default for packaged application.
// Write to this file, must be set before first logging
log.transports.file.file = __dirname + '/log.txt';
#### Disable a transport
// fs.createWriteStream options, must be set before first logging
// you can find more information at
// https://nodejs.org/api/fs.html#fs_fs_createwritestream_path_options
log.transports.file.streamConfig = { flags: 'w' };
Just set level property to false, for example:
// set existed file stream
log.transports.file.stream = fs.createWriteStream('log.txt');
```js
log.transports.file.level = false;
log.transports.console.level = false;
```
By default, file transport reads a productName or name property from
package.json to determine a log path like
`~/.config/<app name>/log.log`. If you have no package.json or you want
to specify another path, just set the appName property:
#### [Override/add a custom transport](doc/extend.md#transport)
```js
log.transports.file.appName = 'test';
```
This value should be set before the first log method call.
Transport is just a function `(msg: ILogMessage) => void`, so you can
easily override/add your own transport.
[More info.](doc/extend.md#transport)
## Renderer process
### [Hooks](doc/extend.md#hooks)
Since version 2.0.0 this package works differently in main and renderer
processes. When it's included in a renderer process it sends logs to
the main process through IPC. There are no API changes, you can still
require the package by the same way both in main and renderer processes,
but please be aware that transport configuration is available only
inside the main process.
In some situations, you may want to get more control over logging. Hook
is a function which is called on each logging.
`(msg: ILogMessage, transports: ITransports) => ILogMessage`
[More info.](doc/extend.md#hooks)
## Change Log
**3.0.0-beta**
- Now IPC is used only for some transports, which are disabled for a
packaged application. So now electron-log works using almost the same
way in main and renderer processes. The reason - IPC is pretty slow
and can freeze an application when there are a lot of calls.
- File transport doesn't use stream.Writable anymore.
- New feature: hooks.
- New feature: log file clearing.
**2.1.0**

@@ -143,0 +144,0 @@ - Add Renderer Console transport

53

renderer.js
'use strict';
module.exports = null;
var ipcRenderer;
try {
ipcRenderer = require('electron').ipcRenderer;
} catch (e) {
ipcRenderer = null;
}
var originalConsole = require('./lib/original-console');
if (ipcRenderer) {
module.exports = {
error: log.bind(null, 'error'),
warn: log.bind(null, 'warn'),
info: log.bind(null, 'info'),
verbose: log.bind(null, 'verbose'),
debug: log.bind(null, 'debug'),
silly: log.bind(null, 'silly'),
log: log.bind(null, 'info')
};
module.exports.default = module.exports;
ipcRenderer.on('__ELECTRON_LOG_RENDERER__', function(event, level, data) {
if (level === 'verbose') {
level = 'log';
} else if (level === 'silly') {
level = 'debug';
}
originalConsole[level].apply(
originalConsole.context,
typeof data === 'string' ? [data] : data
);
});
}
function log() {
var data = Array.prototype.slice.call(arguments);
data = data.map(function(obj) {
if (obj instanceof Error) {
obj = obj.stack || obj;
}
return obj;
});
ipcRenderer.send('__ELECTRON_LOG__', data);
}
module.exports = require('./index');
console.warn('electron-log/renderer is deprecated and will be removed in v4');
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc