repo_name
stringclasses 28
values | pr_number
int64 8
3.71k
| pr_title
stringlengths 3
107
| pr_description
stringlengths 0
60.1k
| author
stringlengths 4
19
| date_created
unknown | date_merged
unknown | previous_commit
stringlengths 40
40
| pr_commit
stringlengths 40
40
| query
stringlengths 5
60.1k
| filepath
stringlengths 7
167
| before_content
stringlengths 0
103M
| after_content
stringlengths 0
103M
| label
int64 -1
1
|
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
log4js-node/log4js-node | 1,316 | FEAT: patternLayout function name, class name and function alias | Added to patternLayout the following fields:
- `%M` - function name of the caller issuing the logging request
- `%C` - class name of the caller issuing the logging request
- `%A` - function alias of the caller issuing the logging request
The first two come from log4j, and use the same field specifiers.
When called from method `bar` of a class `Foo`:
- `%M` will be replaced with `bar`
- `%C` will be replaced with `Foo`
- `%A` will be empty
When called from function foo:
- `%M` will be replaced with foo
- `%C` will be empty
- `%A` will be empty
`%A` will be non empty only if the call stack parsed to obtain the values contains string `[as foo]`.
This is the same behaviour as log4j (except for the `%A`).
Advise: would it make sense to also include something like `%F` for obtaining the full, unsplitted name?
------
Added table for clarity:
|Error Stacktrace|%M<br>function name|%C<br>class name|%A<br>alias name|%F<br>caller name|
|--|--|--|--|--|
|\<empty\>| | | | |
|`foo`|`foo`| | |`foo`|
|`foo [as bar]`|`foo`||`bar`|`foo [as bar]`|
|`Foo.bar`|`bar`|`Foo`||`Foo.bar`|
|`Foo.bar [as baz]`|`bar`|`Foo`|`baz`|`Foo.bar [as baz]`| | l0ner | "2022-08-27T20:07:39Z" | "2022-09-01T11:50:41Z" | 4e460ffc02d544bdc912cb0db7c6e0a1bd6e43a3 | be433f26c3169698aa7d8cd8b94584b6f0cb3ceb | FEAT: patternLayout function name, class name and function alias. Added to patternLayout the following fields:
- `%M` - function name of the caller issuing the logging request
- `%C` - class name of the caller issuing the logging request
- `%A` - function alias of the caller issuing the logging request
The first two come from log4j, and use the same field specifiers.
When called from method `bar` of a class `Foo`:
- `%M` will be replaced with `bar`
- `%C` will be replaced with `Foo`
- `%A` will be empty
When called from function foo:
- `%M` will be replaced with foo
- `%C` will be empty
- `%A` will be empty
`%A` will be non empty only if the call stack parsed to obtain the values contains string `[as foo]`.
This is the same behaviour as log4j (except for the `%A`).
Advise: would it make sense to also include something like `%F` for obtaining the full, unsplitted name?
------
Added table for clarity:
|Error Stacktrace|%M<br>function name|%C<br>class name|%A<br>alias name|%F<br>caller name|
|--|--|--|--|--|
|\<empty\>| | | | |
|`foo`|`foo`| | |`foo`|
|`foo [as bar]`|`foo`||`bar`|`foo [as bar]`|
|`Foo.bar`|`bar`|`Foo`||`Foo.bar`|
|`Foo.bar [as baz]`|`bar`|`Foo`|`baz`|`Foo.bar [as baz]`| | ./test/tap/noLogFilter-test.js | const { test } = require('tap');
const log4js = require('../../lib/log4js');
const recording = require('../../lib/appenders/recording');
/**
* test a simple regexp
*/
test('log4js noLogFilter', (batch) => {
batch.beforeEach((done) => {
recording.reset();
if (typeof done === 'function') {
done();
}
});
batch.test(
'appender should exclude events that match the regexp string',
(t) => {
log4js.configure({
appenders: {
recorder: { type: 'recording' },
filtered: {
type: 'noLogFilter',
exclude: 'This.*not',
appender: 'recorder',
},
},
categories: { default: { appenders: ['filtered'], level: 'DEBUG' } },
});
const logger = log4js.getLogger();
logger.debug('This should not get logged');
logger.debug('This should get logged');
logger.debug(
'Another case that not match the regex, so it should get logged'
);
const logEvents = recording.replay();
t.equal(logEvents.length, 2);
t.equal(logEvents[0].data[0], 'This should get logged');
t.equal(
logEvents[1].data[0],
'Another case that not match the regex, so it should get logged'
);
t.end();
}
);
/**
* test an array of regexp
*/
batch.test(
'appender should exclude events that match the regexp string contained in the array',
(t) => {
log4js.configure({
appenders: {
recorder: { type: 'recording' },
filtered: {
type: 'noLogFilter',
exclude: ['This.*not', 'instead'],
appender: 'recorder',
},
},
categories: { default: { appenders: ['filtered'], level: 'DEBUG' } },
});
const logger = log4js.getLogger();
logger.debug('This should not get logged');
logger.debug('This should get logged');
logger.debug(
'Another case that not match the regex, so it should get logged'
);
logger.debug('This case instead it should get logged');
logger.debug('The last that should get logged');
const logEvents = recording.replay();
t.equal(logEvents.length, 3);
t.equal(logEvents[0].data[0], 'This should get logged');
t.equal(
logEvents[1].data[0],
'Another case that not match the regex, so it should get logged'
);
t.equal(logEvents[2].data[0], 'The last that should get logged');
t.end();
}
);
/**
* test case insentitive regexp
*/
batch.test(
'appender should evaluate the regexp using incase sentitive option',
(t) => {
log4js.configure({
appenders: {
recorder: { type: 'recording' },
filtered: {
type: 'noLogFilter',
exclude: ['NOT', 'eX.*de'],
appender: 'recorder',
},
},
categories: { default: { appenders: ['filtered'], level: 'DEBUG' } },
});
const logger = log4js.getLogger();
logger.debug('This should not get logged');
logger.debug('This should get logged');
logger.debug('Exclude this string');
logger.debug('Include this string');
const logEvents = recording.replay();
t.equal(logEvents.length, 2);
t.equal(logEvents[0].data[0], 'This should get logged');
t.equal(logEvents[1].data[0], 'Include this string');
t.end();
}
);
/**
* test empty string or null regexp
*/
batch.test(
'appender should skip the match in case of empty or null regexp',
(t) => {
log4js.configure({
appenders: {
recorder: { type: 'recording' },
filtered: {
type: 'noLogFilter',
exclude: ['', null, undefined],
appender: 'recorder',
},
},
categories: { default: { appenders: ['filtered'], level: 'DEBUG' } },
});
const logger = log4js.getLogger();
logger.debug('This should get logged');
logger.debug('Another string that should get logged');
const logEvents = recording.replay();
t.equal(logEvents.length, 2);
t.equal(logEvents[0].data[0], 'This should get logged');
t.equal(logEvents[1].data[0], 'Another string that should get logged');
t.end();
}
);
/**
* test for excluding all the events that contains digits
*/
batch.test('appender should exclude the events that contains digits', (t) => {
log4js.configure({
appenders: {
recorder: { type: 'recording' },
filtered: {
type: 'noLogFilter',
exclude: '\\d',
appender: 'recorder',
},
},
categories: { default: { appenders: ['filtered'], level: 'DEBUG' } },
});
const logger = log4js.getLogger();
logger.debug('This should get logged');
logger.debug('The 2nd event should not get logged');
logger.debug('The 3rd event should not get logged, such as the 2nd');
const logEvents = recording.replay();
t.equal(logEvents.length, 1);
t.equal(logEvents[0].data[0], 'This should get logged');
t.end();
});
/**
* test the cases provided in the documentation
* https://log4js-node.github.io/log4js-node/noLogFilter.html
*/
batch.test(
'appender should exclude not valid events according to the documentation',
(t) => {
log4js.configure({
appenders: {
recorder: { type: 'recording' },
filtered: {
type: 'noLogFilter',
exclude: ['NOT', '\\d', ''],
appender: 'recorder',
},
},
categories: { default: { appenders: ['filtered'], level: 'DEBUG' } },
});
const logger = log4js.getLogger();
logger.debug('I will be logged in all-the-logs.log');
logger.debug('I will be not logged in all-the-logs.log');
logger.debug('A 2nd message that will be excluded in all-the-logs.log');
logger.debug('Hello again');
const logEvents = recording.replay();
t.equal(logEvents.length, 2);
t.equal(logEvents[0].data[0], 'I will be logged in all-the-logs.log');
t.equal(logEvents[1].data[0], 'Hello again');
t.end();
}
);
batch.end();
});
| const { test } = require('tap');
const log4js = require('../../lib/log4js');
const recording = require('../../lib/appenders/recording');
/**
* test a simple regexp
*/
test('log4js noLogFilter', (batch) => {
batch.beforeEach((done) => {
recording.reset();
if (typeof done === 'function') {
done();
}
});
batch.test(
'appender should exclude events that match the regexp string',
(t) => {
log4js.configure({
appenders: {
recorder: { type: 'recording' },
filtered: {
type: 'noLogFilter',
exclude: 'This.*not',
appender: 'recorder',
},
},
categories: { default: { appenders: ['filtered'], level: 'DEBUG' } },
});
const logger = log4js.getLogger();
logger.debug('This should not get logged');
logger.debug('This should get logged');
logger.debug(
'Another case that not match the regex, so it should get logged'
);
const logEvents = recording.replay();
t.equal(logEvents.length, 2);
t.equal(logEvents[0].data[0], 'This should get logged');
t.equal(
logEvents[1].data[0],
'Another case that not match the regex, so it should get logged'
);
t.end();
}
);
/**
* test an array of regexp
*/
batch.test(
'appender should exclude events that match the regexp string contained in the array',
(t) => {
log4js.configure({
appenders: {
recorder: { type: 'recording' },
filtered: {
type: 'noLogFilter',
exclude: ['This.*not', 'instead'],
appender: 'recorder',
},
},
categories: { default: { appenders: ['filtered'], level: 'DEBUG' } },
});
const logger = log4js.getLogger();
logger.debug('This should not get logged');
logger.debug('This should get logged');
logger.debug(
'Another case that not match the regex, so it should get logged'
);
logger.debug('This case instead it should get logged');
logger.debug('The last that should get logged');
const logEvents = recording.replay();
t.equal(logEvents.length, 3);
t.equal(logEvents[0].data[0], 'This should get logged');
t.equal(
logEvents[1].data[0],
'Another case that not match the regex, so it should get logged'
);
t.equal(logEvents[2].data[0], 'The last that should get logged');
t.end();
}
);
/**
* test case insentitive regexp
*/
batch.test(
'appender should evaluate the regexp using incase sentitive option',
(t) => {
log4js.configure({
appenders: {
recorder: { type: 'recording' },
filtered: {
type: 'noLogFilter',
exclude: ['NOT', 'eX.*de'],
appender: 'recorder',
},
},
categories: { default: { appenders: ['filtered'], level: 'DEBUG' } },
});
const logger = log4js.getLogger();
logger.debug('This should not get logged');
logger.debug('This should get logged');
logger.debug('Exclude this string');
logger.debug('Include this string');
const logEvents = recording.replay();
t.equal(logEvents.length, 2);
t.equal(logEvents[0].data[0], 'This should get logged');
t.equal(logEvents[1].data[0], 'Include this string');
t.end();
}
);
/**
* test empty string or null regexp
*/
batch.test(
'appender should skip the match in case of empty or null regexp',
(t) => {
log4js.configure({
appenders: {
recorder: { type: 'recording' },
filtered: {
type: 'noLogFilter',
exclude: ['', null, undefined],
appender: 'recorder',
},
},
categories: { default: { appenders: ['filtered'], level: 'DEBUG' } },
});
const logger = log4js.getLogger();
logger.debug('This should get logged');
logger.debug('Another string that should get logged');
const logEvents = recording.replay();
t.equal(logEvents.length, 2);
t.equal(logEvents[0].data[0], 'This should get logged');
t.equal(logEvents[1].data[0], 'Another string that should get logged');
t.end();
}
);
/**
* test for excluding all the events that contains digits
*/
batch.test('appender should exclude the events that contains digits', (t) => {
log4js.configure({
appenders: {
recorder: { type: 'recording' },
filtered: {
type: 'noLogFilter',
exclude: '\\d',
appender: 'recorder',
},
},
categories: { default: { appenders: ['filtered'], level: 'DEBUG' } },
});
const logger = log4js.getLogger();
logger.debug('This should get logged');
logger.debug('The 2nd event should not get logged');
logger.debug('The 3rd event should not get logged, such as the 2nd');
const logEvents = recording.replay();
t.equal(logEvents.length, 1);
t.equal(logEvents[0].data[0], 'This should get logged');
t.end();
});
/**
* test the cases provided in the documentation
* https://log4js-node.github.io/log4js-node/noLogFilter.html
*/
batch.test(
'appender should exclude not valid events according to the documentation',
(t) => {
log4js.configure({
appenders: {
recorder: { type: 'recording' },
filtered: {
type: 'noLogFilter',
exclude: ['NOT', '\\d', ''],
appender: 'recorder',
},
},
categories: { default: { appenders: ['filtered'], level: 'DEBUG' } },
});
const logger = log4js.getLogger();
logger.debug('I will be logged in all-the-logs.log');
logger.debug('I will be not logged in all-the-logs.log');
logger.debug('A 2nd message that will be excluded in all-the-logs.log');
logger.debug('Hello again');
const logEvents = recording.replay();
t.equal(logEvents.length, 2);
t.equal(logEvents[0].data[0], 'I will be logged in all-the-logs.log');
t.equal(logEvents[1].data[0], 'Hello again');
t.end();
}
);
batch.end();
});
| -1 |
log4js-node/log4js-node | 1,316 | FEAT: patternLayout function name, class name and function alias | Added to patternLayout the following fields:
- `%M` - function name of the caller issuing the logging request
- `%C` - class name of the caller issuing the logging request
- `%A` - function alias of the caller issuing the logging request
The first two come from log4j, and use the same field specifiers.
When called from method `bar` of a class `Foo`:
- `%M` will be replaced with `bar`
- `%C` will be replaced with `Foo`
- `%A` will be empty
When called from function foo:
- `%M` will be replaced with foo
- `%C` will be empty
- `%A` will be empty
`%A` will be non empty only if the call stack parsed to obtain the values contains string `[as foo]`.
This is the same behaviour as log4j (except for the `%A`).
Advise: would it make sense to also include something like `%F` for obtaining the full, unsplitted name?
------
Added table for clarity:
|Error Stacktrace|%M<br>function name|%C<br>class name|%A<br>alias name|%F<br>caller name|
|--|--|--|--|--|
|\<empty\>| | | | |
|`foo`|`foo`| | |`foo`|
|`foo [as bar]`|`foo`||`bar`|`foo [as bar]`|
|`Foo.bar`|`bar`|`Foo`||`Foo.bar`|
|`Foo.bar [as baz]`|`bar`|`Foo`|`baz`|`Foo.bar [as baz]`| | l0ner | "2022-08-27T20:07:39Z" | "2022-09-01T11:50:41Z" | 4e460ffc02d544bdc912cb0db7c6e0a1bd6e43a3 | be433f26c3169698aa7d8cd8b94584b6f0cb3ceb | FEAT: patternLayout function name, class name and function alias. Added to patternLayout the following fields:
- `%M` - function name of the caller issuing the logging request
- `%C` - class name of the caller issuing the logging request
- `%A` - function alias of the caller issuing the logging request
The first two come from log4j, and use the same field specifiers.
When called from method `bar` of a class `Foo`:
- `%M` will be replaced with `bar`
- `%C` will be replaced with `Foo`
- `%A` will be empty
When called from function foo:
- `%M` will be replaced with foo
- `%C` will be empty
- `%A` will be empty
`%A` will be non empty only if the call stack parsed to obtain the values contains string `[as foo]`.
This is the same behaviour as log4j (except for the `%A`).
Advise: would it make sense to also include something like `%F` for obtaining the full, unsplitted name?
------
Added table for clarity:
|Error Stacktrace|%M<br>function name|%C<br>class name|%A<br>alias name|%F<br>caller name|
|--|--|--|--|--|
|\<empty\>| | | | |
|`foo`|`foo`| | |`foo`|
|`foo [as bar]`|`foo`||`bar`|`foo [as bar]`|
|`Foo.bar`|`bar`|`Foo`||`Foo.bar`|
|`Foo.bar [as baz]`|`bar`|`Foo`|`baz`|`Foo.bar [as baz]`| | ./docs/_layouts/default.html | <!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta http-equiv="X-UA-Compatible" content="chrome=1" />
<title>
{{ site.title | default: site.github.repository_name }} by {{
site.github.owner_name }}
</title>
<link
rel="stylesheet"
href="{{ '/assets/css/style.css?v=' | append: site.github.build_revision | relative_url }}"
/>
<meta name="viewport" content="width=device-width" />
<!--[if lt IE 9]>
<script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
<![endif]-->
</head>
<body>
<div class="wrapper">
<header>
<h1>{{ site.title | default: site.github.repository_name }}</h1>
<p>{{ site.description | default: site.github.project_tagline }}</p>
{% if site.github.is_project_page %}
<p class="view">
<a href="{{ site.github.repository_url }}"
>View the Project on GitHub <small>{{ github_name }}</small></a
>
</p>
{% endif %}
<ul>
<li><a href="index.html">Home</a></li>
<li><a href="api.html">API</a></li>
<li><a href="appenders.html">Appenders</a></li>
<li><a href="categories.html">Categories</a></li>
<li><a href="layouts.html">Layouts</a></li>
<li><a href="terms.html">Terminology</a></li>
<li><a href="faq.html">FAQ</a></li>
<li><a href="contrib-guidelines.html">Want to help?</a></li>
<li><a href="contributors.html">Contributors</a></li>
</ul>
{% if site.github.is_user_page %}
<p class="view">
<a href="{{ site.github.owner_url }}">View My GitHub Profile</a>
</p>
{% endif %} {% if site.show_downloads %}
<ul>
<li>
<a href="{{ site.github.zip_url }}"
>Download <strong>ZIP File</strong></a
>
</li>
<li>
<a href="{{ site.github.tar_url }}"
>Download <strong>TAR Ball</strong></a
>
</li>
<li>
<a href="{{ site.github.repository_url }}"
>View On <strong>GitHub</strong></a
>
</li>
</ul>
{% endif %}
</header>
<section>{{ content }}</section>
<footer>
{% if site.github.is_project_page %}
<p>
This project is maintained by
<a href="{{ site.github.owner_url }}">{{ site.github.owner_name }}</a>
</p>
{% endif %}
<p>
<small
>Hosted on GitHub Pages — Theme by
<a href="https://github.com/orderedlist">orderedlist</a></small
>
</p>
</footer>
</div>
<script src="{{ '/assets/js/scale.fix.js' | relative_url }}"></script>
{% if site.google_analytics %}
<script>
(function(i, s, o, g, r, a, m) {
i["GoogleAnalyticsObject"] = r;
(i[r] =
i[r] ||
function() {
(i[r].q = i[r].q || []).push(arguments);
}),
(i[r].l = 1 * new Date());
(a = s.createElement(o)), (m = s.getElementsByTagName(o)[0]);
a.async = 1;
a.src = g;
m.parentNode.insertBefore(a, m);
})(
window,
document,
"script",
"https://www.google-analytics.com/analytics.js",
"ga"
);
ga("create", "{{ site.google_analytics }}", "auto");
ga("send", "pageview");
</script>
{% endif %}
</body>
</html>
| <!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta http-equiv="X-UA-Compatible" content="chrome=1" />
<title>
{{ site.title | default: site.github.repository_name }} by {{
site.github.owner_name }}
</title>
<link
rel="stylesheet"
href="{{ '/assets/css/style.css?v=' | append: site.github.build_revision | relative_url }}"
/>
<meta name="viewport" content="width=device-width" />
<!--[if lt IE 9]>
<script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
<![endif]-->
</head>
<body>
<div class="wrapper">
<header>
<h1>{{ site.title | default: site.github.repository_name }}</h1>
<p>{{ site.description | default: site.github.project_tagline }}</p>
{% if site.github.is_project_page %}
<p class="view">
<a href="{{ site.github.repository_url }}"
>View the Project on GitHub <small>{{ github_name }}</small></a
>
</p>
{% endif %}
<ul>
<li><a href="index.html">Home</a></li>
<li><a href="api.html">API</a></li>
<li><a href="appenders.html">Appenders</a></li>
<li><a href="categories.html">Categories</a></li>
<li><a href="layouts.html">Layouts</a></li>
<li><a href="terms.html">Terminology</a></li>
<li><a href="faq.html">FAQ</a></li>
<li><a href="contrib-guidelines.html">Want to help?</a></li>
<li><a href="contributors.html">Contributors</a></li>
</ul>
{% if site.github.is_user_page %}
<p class="view">
<a href="{{ site.github.owner_url }}">View My GitHub Profile</a>
</p>
{% endif %} {% if site.show_downloads %}
<ul>
<li>
<a href="{{ site.github.zip_url }}"
>Download <strong>ZIP File</strong></a
>
</li>
<li>
<a href="{{ site.github.tar_url }}"
>Download <strong>TAR Ball</strong></a
>
</li>
<li>
<a href="{{ site.github.repository_url }}"
>View On <strong>GitHub</strong></a
>
</li>
</ul>
{% endif %}
</header>
<section>{{ content }}</section>
<footer>
{% if site.github.is_project_page %}
<p>
This project is maintained by
<a href="{{ site.github.owner_url }}">{{ site.github.owner_name }}</a>
</p>
{% endif %}
<p>
<small
>Hosted on GitHub Pages — Theme by
<a href="https://github.com/orderedlist">orderedlist</a></small
>
</p>
</footer>
</div>
<script src="{{ '/assets/js/scale.fix.js' | relative_url }}"></script>
{% if site.google_analytics %}
<script>
(function(i, s, o, g, r, a, m) {
i["GoogleAnalyticsObject"] = r;
(i[r] =
i[r] ||
function() {
(i[r].q = i[r].q || []).push(arguments);
}),
(i[r].l = 1 * new Date());
(a = s.createElement(o)), (m = s.getElementsByTagName(o)[0]);
a.async = 1;
a.src = g;
m.parentNode.insertBefore(a, m);
})(
window,
document,
"script",
"https://www.google-analytics.com/analytics.js",
"ga"
);
ga("create", "{{ site.google_analytics }}", "auto");
ga("send", "pageview");
</script>
{% endif %}
</body>
</html>
| -1 |
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/dateFileAppender-test.js | /* eslint max-classes-per-file: ["error", 3] */
const { test } = require('tap');
const path = require('path');
const fs = require('fs');
const EOL = require('os').EOL || '\n';
const format = require('date-format');
const sandbox = require('@log4js-node/sandboxed-module');
const log4js = require('../../lib/log4js');
function removeFile(filename) {
try {
fs.unlinkSync(path.join(__dirname, filename));
} catch (e) {
// doesn't matter
}
}
test('../../lib/appenders/dateFile', (batch) => {
batch.test('with default settings', (t) => {
const testFile = path.join(__dirname, 'date-appender-default.log');
log4js.configure({
appenders: { date: { type: 'dateFile', filename: testFile } },
categories: { default: { appenders: ['date'], level: 'DEBUG' } },
});
const logger = log4js.getLogger('default-settings');
logger.info('This should be in the file.');
t.teardown(() => {
removeFile('date-appender-default.log');
});
setTimeout(() => {
fs.readFile(testFile, 'utf8', (err, contents) => {
t.match(contents, 'This should be in the file');
t.match(
contents,
/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}] \[INFO] default-settings - /
);
t.end();
});
}, 100);
});
batch.test('configure with dateFileAppender', (t) => {
log4js.configure({
appenders: {
date: {
type: 'dateFile',
filename: 'test/tap/date-file-test.log',
pattern: '-yyyy-MM-dd',
layout: { type: 'messagePassThrough' },
},
},
categories: { default: { appenders: ['date'], level: 'WARN' } },
});
const logger = log4js.getLogger('tests');
logger.info('this should not be written to the file');
logger.warn('this should be written to the file');
log4js.shutdown(() => {
fs.readFile(
path.join(__dirname, 'date-file-test.log'),
'utf8',
(err, contents) => {
t.match(contents, `this should be written to the file${EOL}`);
t.equal(
contents.indexOf('this should not be written to the file'),
-1
);
t.end();
}
);
});
t.teardown(() => {
removeFile('date-file-test.log');
});
});
batch.test('configure with options.alwaysIncludePattern', (t) => {
const options = {
appenders: {
date: {
category: 'tests',
type: 'dateFile',
filename: 'test/tap/date-file-test',
pattern: 'yyyy-MM-dd.log',
alwaysIncludePattern: true,
layout: {
type: 'messagePassThrough',
},
},
},
categories: { default: { appenders: ['date'], level: 'debug' } },
};
const thisTime = format.asString(
options.appenders.date.pattern,
new Date()
);
const testFile = `date-file-test.${thisTime}`;
const existingFile = path.join(__dirname, testFile);
fs.writeFileSync(existingFile, `this is existing data${EOL}`, 'utf8');
log4js.configure(options);
const logger = log4js.getLogger('tests');
logger.warn('this should be written to the file with the appended date');
t.teardown(() => {
removeFile(testFile);
});
// wait for filesystem to catch up
log4js.shutdown(() => {
fs.readFile(existingFile, 'utf8', (err, contents) => {
t.match(
contents,
'this is existing data',
'should not overwrite the file on open (issue #132)'
);
t.match(
contents,
'this should be written to the file with the appended date'
);
t.end();
});
});
});
batch.test('should flush logs on shutdown', (t) => {
const testFile = path.join(__dirname, 'date-appender-flush.log');
log4js.configure({
appenders: { test: { type: 'dateFile', filename: testFile } },
categories: { default: { appenders: ['test'], level: 'trace' } },
});
const logger = log4js.getLogger('default-settings');
logger.info('1');
logger.info('2');
logger.info('3');
t.teardown(() => {
removeFile('date-appender-flush.log');
});
log4js.shutdown(() => {
fs.readFile(testFile, 'utf8', (err, fileContents) => {
// 3 lines of output, plus the trailing newline.
t.equal(fileContents.split(EOL).length, 4);
t.match(
fileContents,
/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}] \[INFO] default-settings - /
);
t.end();
});
});
});
batch.test('should map maxLogSize to maxSize', (t) => {
const fakeStreamroller = {};
class DateRollingFileStream {
constructor(filename, pattern, options) {
fakeStreamroller.filename = filename;
fakeStreamroller.pattern = pattern;
fakeStreamroller.options = options;
}
on() {} // eslint-disable-line class-methods-use-this
}
fakeStreamroller.DateRollingFileStream = DateRollingFileStream;
const dateFileAppenderModule = sandbox.require(
'../../lib/appenders/dateFile',
{
requires: { streamroller: fakeStreamroller },
}
);
dateFileAppenderModule.configure(
{
filename: 'cheese.log',
pattern: 'yyyy',
maxLogSize: 100,
},
{ basicLayout: () => {} }
);
t.equal(fakeStreamroller.options.maxSize, 100);
t.end();
});
batch.test('handling of writer.writable', (t) => {
const output = [];
let writable = true;
const DateRollingFileStream = class {
write(loggingEvent) {
output.push(loggingEvent);
this.written = true;
return true;
}
// eslint-disable-next-line class-methods-use-this
on() {}
// eslint-disable-next-line class-methods-use-this
get writable() {
return writable;
}
};
const dateFileAppender = sandbox.require('../../lib/appenders/dateFile', {
requires: {
streamroller: {
DateRollingFileStream,
},
},
});
const appender = dateFileAppender.configure(
{ filename: 'test1.log', maxLogSize: 100 },
{
basicLayout(loggingEvent) {
return loggingEvent.data;
},
}
);
t.test('should log when writer.writable=true', (assert) => {
writable = true;
appender({ data: 'something to log' });
assert.ok(output.length, 1);
assert.match(output[output.length - 1], 'something to log');
assert.end();
});
t.test('should not log when writer.writable=false', (assert) => {
writable = false;
appender({ data: 'this should not be logged' });
assert.ok(output.length, 1);
assert.notMatch(output[output.length - 1], 'this should not be logged');
assert.end();
});
t.end();
});
batch.test('when underlying stream errors', (t) => {
let consoleArgs;
let errorHandler;
const DateRollingFileStream = class {
end() {
this.ended = true;
}
on(evt, cb) {
if (evt === 'error') {
this.errored = true;
errorHandler = cb;
}
}
write() {
this.written = true;
return true;
}
};
const dateFileAppender = sandbox.require('../../lib/appenders/dateFile', {
globals: {
console: {
error(...args) {
consoleArgs = args;
},
},
},
requires: {
streamroller: {
DateRollingFileStream,
},
},
});
dateFileAppender.configure(
{ filename: 'test1.log', maxLogSize: 100 },
{ basicLayout() {} }
);
errorHandler({ error: 'aargh' });
t.test('should log the error to console.error', (assert) => {
assert.ok(consoleArgs);
assert.equal(
consoleArgs[0],
'log4js.dateFileAppender - Writing to file %s, error happened '
);
assert.equal(consoleArgs[1], 'test1.log');
assert.equal(consoleArgs[2].error, 'aargh');
assert.end();
});
t.end();
});
batch.end();
});
| /* eslint max-classes-per-file: ["error", 3] */
const { test } = require('tap');
const path = require('path');
const fs = require('fs');
const EOL = require('os').EOL || '\n';
const format = require('date-format');
const sandbox = require('@log4js-node/sandboxed-module');
const log4js = require('../../lib/log4js');
const osDelay = process.platform === 'win32' ? 400 : 200;
function removeFile(filename) {
try {
fs.unlinkSync(path.join(__dirname, filename));
} catch (e) {
// doesn't matter
}
}
test('../../lib/appenders/dateFile', (batch) => {
batch.test('with default settings', (t) => {
const testFile = path.join(__dirname, 'date-appender-default.log');
log4js.configure({
appenders: { date: { type: 'dateFile', filename: testFile } },
categories: { default: { appenders: ['date'], level: 'DEBUG' } },
});
const logger = log4js.getLogger('default-settings');
logger.info('This should be in the file.');
t.teardown(() => {
removeFile('date-appender-default.log');
});
setTimeout(() => {
fs.readFile(testFile, 'utf8', (err, contents) => {
t.match(contents, 'This should be in the file');
t.match(
contents,
/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}] \[INFO] default-settings - /
);
t.end();
});
}, osDelay);
});
batch.test('configure with dateFileAppender', (t) => {
log4js.configure({
appenders: {
date: {
type: 'dateFile',
filename: 'test/tap/date-file-test.log',
pattern: '-yyyy-MM-dd',
layout: { type: 'messagePassThrough' },
},
},
categories: { default: { appenders: ['date'], level: 'WARN' } },
});
const logger = log4js.getLogger('tests');
logger.info('this should not be written to the file');
logger.warn('this should be written to the file');
log4js.shutdown(() => {
fs.readFile(
path.join(__dirname, 'date-file-test.log'),
'utf8',
(err, contents) => {
t.match(contents, `this should be written to the file${EOL}`);
t.equal(
contents.indexOf('this should not be written to the file'),
-1
);
t.end();
}
);
});
t.teardown(() => {
removeFile('date-file-test.log');
});
});
batch.test('configure with options.alwaysIncludePattern', (t) => {
const options = {
appenders: {
date: {
category: 'tests',
type: 'dateFile',
filename: 'test/tap/date-file-test',
pattern: 'yyyy-MM-dd.log',
alwaysIncludePattern: true,
layout: {
type: 'messagePassThrough',
},
},
},
categories: { default: { appenders: ['date'], level: 'debug' } },
};
const thisTime = format.asString(
options.appenders.date.pattern,
new Date()
);
const testFile = `date-file-test.${thisTime}`;
const existingFile = path.join(__dirname, testFile);
fs.writeFileSync(existingFile, `this is existing data${EOL}`, 'utf8');
log4js.configure(options);
const logger = log4js.getLogger('tests');
logger.warn('this should be written to the file with the appended date');
t.teardown(() => {
removeFile(testFile);
});
// wait for filesystem to catch up
log4js.shutdown(() => {
fs.readFile(existingFile, 'utf8', (err, contents) => {
t.match(
contents,
'this is existing data',
'should not overwrite the file on open (issue #132)'
);
t.match(
contents,
'this should be written to the file with the appended date'
);
t.end();
});
});
});
batch.test('should flush logs on shutdown', (t) => {
const testFile = path.join(__dirname, 'date-appender-flush.log');
log4js.configure({
appenders: { test: { type: 'dateFile', filename: testFile } },
categories: { default: { appenders: ['test'], level: 'trace' } },
});
const logger = log4js.getLogger('default-settings');
logger.info('1');
logger.info('2');
logger.info('3');
t.teardown(() => {
removeFile('date-appender-flush.log');
});
log4js.shutdown(() => {
fs.readFile(testFile, 'utf8', (err, fileContents) => {
// 3 lines of output, plus the trailing newline.
t.equal(fileContents.split(EOL).length, 4);
t.match(
fileContents,
/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}] \[INFO] default-settings - /
);
t.end();
});
});
});
batch.test('should map maxLogSize to maxSize', (t) => {
const fakeStreamroller = {};
class DateRollingFileStream {
constructor(filename, pattern, options) {
fakeStreamroller.filename = filename;
fakeStreamroller.pattern = pattern;
fakeStreamroller.options = options;
}
on() {} // eslint-disable-line class-methods-use-this
}
fakeStreamroller.DateRollingFileStream = DateRollingFileStream;
const dateFileAppenderModule = sandbox.require(
'../../lib/appenders/dateFile',
{
requires: { streamroller: fakeStreamroller },
}
);
dateFileAppenderModule.configure(
{
filename: 'cheese.log',
pattern: 'yyyy',
maxLogSize: 100,
},
{ basicLayout: () => {} }
);
t.equal(fakeStreamroller.options.maxSize, 100);
t.end();
});
batch.test('handling of writer.writable', (t) => {
const output = [];
let writable = true;
const DateRollingFileStream = class {
write(loggingEvent) {
output.push(loggingEvent);
this.written = true;
return true;
}
// eslint-disable-next-line class-methods-use-this
on() {}
// eslint-disable-next-line class-methods-use-this
get writable() {
return writable;
}
};
const dateFileAppender = sandbox.require('../../lib/appenders/dateFile', {
requires: {
streamroller: {
DateRollingFileStream,
},
},
});
const appender = dateFileAppender.configure(
{ filename: 'test1.log', maxLogSize: 100 },
{
basicLayout(loggingEvent) {
return loggingEvent.data;
},
}
);
t.test('should log when writer.writable=true', (assert) => {
writable = true;
appender({ data: 'something to log' });
assert.ok(output.length, 1);
assert.match(output[output.length - 1], 'something to log');
assert.end();
});
t.test('should not log when writer.writable=false', (assert) => {
writable = false;
appender({ data: 'this should not be logged' });
assert.ok(output.length, 1);
assert.notMatch(output[output.length - 1], 'this should not be logged');
assert.end();
});
t.end();
});
batch.test('when underlying stream errors', (t) => {
let consoleArgs;
let errorHandler;
const DateRollingFileStream = class {
end() {
this.ended = true;
}
on(evt, cb) {
if (evt === 'error') {
this.errored = true;
errorHandler = cb;
}
}
write() {
this.written = true;
return true;
}
};
const dateFileAppender = sandbox.require('../../lib/appenders/dateFile', {
globals: {
console: {
error(...args) {
consoleArgs = args;
},
},
},
requires: {
streamroller: {
DateRollingFileStream,
},
},
});
dateFileAppender.configure(
{ filename: 'test1.log', maxLogSize: 100 },
{ basicLayout() {} }
);
errorHandler({ error: 'aargh' });
t.test('should log the error to console.error', (assert) => {
assert.ok(consoleArgs);
assert.equal(
consoleArgs[0],
'log4js.dateFileAppender - Writing to file %s, error happened '
);
assert.equal(consoleArgs[1], 'test1.log');
assert.equal(consoleArgs[2].error, 'aargh');
assert.end();
});
t.end();
});
batch.end();
});
| 1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/file-descriptor-leak-test.js | const { test } = require('tap');
const fs = require('fs');
const path = require('path');
const log4js = require('../../lib/log4js');
const removeFiles = async (filenames) => {
if (!Array.isArray(filenames)) filenames = [filenames];
const promises = filenames.map((filename) => fs.promises.unlink(filename));
await Promise.allSettled(promises);
};
// no file descriptors on Windows, so don't run the tests
if (process.platform !== 'win32') {
test('multiple log4js configure fd leak test', (batch) => {
const config = {
appenders: {},
categories: {
default: { appenders: [], level: 'debug' },
},
};
// create 11 appenders
const numOfAppenders = 11;
for (let i = 1; i <= numOfAppenders; i++) {
config.appenders[`app${i}`] = {
type: 'file',
filename: path.join(__dirname, `file${i}.log`),
};
config.categories.default.appenders.push(`app${i}`);
}
const initialFd = fs.readdirSync('/proc/self/fd').length;
let loadedFd;
batch.test(
'initial log4js configure to increase file descriptor count',
(t) => {
log4js.configure(config);
// wait for the file system to catch up
setTimeout(() => {
loadedFd = fs.readdirSync('/proc/self/fd').length;
t.equal(
loadedFd,
initialFd + numOfAppenders,
`file descriptor count should increase by ${numOfAppenders} after 1st configure() call`
);
t.end();
}, 250);
}
);
batch.test(
'repeated log4js configure to not increase file descriptor count',
(t) => {
log4js.configure(config);
log4js.configure(config);
log4js.configure(config);
// wait for the file system to catch up
setTimeout(() => {
t.equal(
fs.readdirSync('/proc/self/fd').length,
loadedFd,
`file descriptor count should be identical after repeated configure() calls`
);
t.end();
}, 250);
}
);
batch.test(
'file descriptor count should return back to initial count',
(t) => {
log4js.shutdown();
// wait for the file system to catch up
setTimeout(() => {
t.equal(
fs.readdirSync('/proc/self/fd').length,
initialFd,
`file descriptor count should be back to initial`
);
t.end();
}, 250);
}
);
batch.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
const filenames = Object.values(config.appenders).map(
(appender) => appender.filename
);
await removeFiles(filenames);
});
batch.end();
});
}
| const { test } = require('tap');
const fs = require('fs');
const path = require('path');
const log4js = require('../../lib/log4js');
const osDelay = process.platform === 'win32' ? 400 : 200;
const removeFiles = async (filenames) => {
if (!Array.isArray(filenames)) filenames = [filenames];
const promises = filenames.map((filename) => fs.promises.unlink(filename));
await Promise.allSettled(promises);
};
// no file descriptors on Windows, so don't run the tests
if (process.platform !== 'win32') {
test('multiple log4js configure fd leak test', (batch) => {
const config = {
appenders: {},
categories: {
default: { appenders: [], level: 'debug' },
},
};
// create 11 appenders
const numOfAppenders = 11;
for (let i = 1; i <= numOfAppenders; i++) {
config.appenders[`app${i}`] = {
type: 'file',
filename: path.join(__dirname, `file${i}.log`),
};
config.categories.default.appenders.push(`app${i}`);
}
const initialFd = fs.readdirSync('/proc/self/fd').length;
let loadedFd;
batch.test(
'initial log4js configure to increase file descriptor count',
(t) => {
log4js.configure(config);
// wait for the file system to catch up
setTimeout(() => {
loadedFd = fs.readdirSync('/proc/self/fd').length;
t.equal(
loadedFd,
initialFd + numOfAppenders,
`file descriptor count should increase by ${numOfAppenders} after 1st configure() call`
);
t.end();
}, osDelay);
}
);
batch.test(
'repeated log4js configure to not increase file descriptor count',
(t) => {
log4js.configure(config);
log4js.configure(config);
log4js.configure(config);
// wait for the file system to catch up
setTimeout(() => {
t.equal(
fs.readdirSync('/proc/self/fd').length,
loadedFd,
`file descriptor count should be identical after repeated configure() calls`
);
t.end();
}, osDelay);
}
);
batch.test(
'file descriptor count should return back to initial count',
(t) => {
log4js.shutdown();
// wait for the file system to catch up
setTimeout(() => {
t.equal(
fs.readdirSync('/proc/self/fd').length,
initialFd,
`file descriptor count should be back to initial`
);
t.end();
}, osDelay);
}
);
batch.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
const filenames = Object.values(config.appenders).map(
(appender) => appender.filename
);
await removeFiles(filenames);
});
batch.end();
});
}
| 1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/file-sighup-test.js | const { test } = require('tap');
const path = require('path');
const fs = require('fs');
const sandbox = require('@log4js-node/sandboxed-module');
const removeFiles = async (filenames) => {
if (!Array.isArray(filenames)) filenames = [filenames];
const promises = filenames.map((filename) => fs.promises.unlink(filename));
await Promise.allSettled(promises);
};
test('file appender single SIGHUP handler', (t) => {
const initialListeners = process.listenerCount('SIGHUP');
let warning;
const originalListener = process.listeners('warning')[
process.listeners('warning').length - 1
];
const warningListener = (error) => {
if (
error.type === 'SIGHUP' &&
error.name === 'MaxListenersExceededWarning'
) {
warning = error;
return;
}
originalListener(error);
};
process.off('warning', originalListener);
process.on('warning', warningListener);
const config = {
appenders: {},
categories: {
default: { appenders: [], level: 'debug' },
},
};
// create 11 appenders to make nodejs warn for >10 max listeners
const numOfAppenders = 11;
for (let i = 1; i <= numOfAppenders; i++) {
config.appenders[`app${i}`] = {
type: 'file',
filename: path.join(__dirname, `file${i}.log`),
};
config.categories.default.appenders.push(`app${i}`);
}
const log4js = require('../../lib/log4js');
log4js.configure(config);
t.teardown(async () => {
// next event loop so that past warnings will not be printed
setImmediate(() => {
process.off('warning', warningListener);
process.on('warning', originalListener);
});
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
const filenames = Object.values(config.appenders).map(
(appender) => appender.filename
);
await removeFiles(filenames);
});
t.plan(2);
// next event loop to allow event emitter/listener to happen
setImmediate(() => {
t.notOk(warning, 'should not have MaxListenersExceededWarning for SIGHUP');
t.equal(
process.listenerCount('SIGHUP') - initialListeners,
1,
'should be 1 SIGHUP listener'
);
t.end();
});
});
test('file appender SIGHUP', (t) => {
let closeCalled = 0;
let openCalled = 0;
sandbox
.require('../../lib/appenders/file', {
requires: {
streamroller: {
RollingFileStream: class RollingFileStream {
constructor() {
openCalled++;
this.ended = false;
}
on() {
this.dummy = 'easier than turning off lint rule';
}
end(cb) {
this.ended = true;
closeCalled++;
cb();
}
write() {
if (this.ended) {
throw new Error('write after end');
}
return true;
}
},
},
},
})
.configure(
{ type: 'file', filename: 'sighup-test-file' },
{
basicLayout() {
return 'whatever';
},
}
);
process.emit('SIGHUP', 'SIGHUP', 1);
t.plan(2);
setTimeout(() => {
t.equal(openCalled, 2, 'open should be called twice');
t.equal(closeCalled, 1, 'close should be called once');
t.end();
}, 100);
});
test('file appender SIGHUP handler leak', (t) => {
const log4js = require('../../lib/log4js');
const initialListeners = process.listenerCount('SIGHUP');
log4js.configure({
appenders: {
file: { type: 'file', filename: 'test.log' },
},
categories: { default: { appenders: ['file'], level: 'info' } },
});
t.teardown(async () => {
await removeFiles('test.log');
});
t.plan(2);
t.equal(process.listenerCount('SIGHUP'), initialListeners + 1);
log4js.shutdown(() => {
t.equal(process.listenerCount('SIGHUP'), initialListeners);
t.end();
});
});
| const { test } = require('tap');
const path = require('path');
const fs = require('fs');
const sandbox = require('@log4js-node/sandboxed-module');
const osDelay = process.platform === 'win32' ? 400 : 200;
const removeFiles = async (filenames) => {
if (!Array.isArray(filenames)) filenames = [filenames];
const promises = filenames.map((filename) => fs.promises.unlink(filename));
await Promise.allSettled(promises);
};
test('file appender single SIGHUP handler', (t) => {
const initialListeners = process.listenerCount('SIGHUP');
let warning;
const originalListener = process.listeners('warning')[
process.listeners('warning').length - 1
];
const warningListener = (error) => {
if (
error.type === 'SIGHUP' &&
error.name === 'MaxListenersExceededWarning'
) {
warning = error;
return;
}
originalListener(error);
};
process.off('warning', originalListener);
process.on('warning', warningListener);
const config = {
appenders: {},
categories: {
default: { appenders: [], level: 'debug' },
},
};
// create 11 appenders to make nodejs warn for >10 max listeners
const numOfAppenders = 11;
for (let i = 1; i <= numOfAppenders; i++) {
config.appenders[`app${i}`] = {
type: 'file',
filename: path.join(__dirname, `file${i}.log`),
};
config.categories.default.appenders.push(`app${i}`);
}
const log4js = require('../../lib/log4js');
log4js.configure(config);
t.teardown(async () => {
// next event loop so that past warnings will not be printed
setImmediate(() => {
process.off('warning', warningListener);
process.on('warning', originalListener);
});
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
const filenames = Object.values(config.appenders).map(
(appender) => appender.filename
);
await removeFiles(filenames);
});
t.plan(2);
// next event loop to allow event emitter/listener to happen
setImmediate(() => {
t.notOk(warning, 'should not have MaxListenersExceededWarning for SIGHUP');
t.equal(
process.listenerCount('SIGHUP') - initialListeners,
1,
'should be 1 SIGHUP listener'
);
t.end();
});
});
test('file appender SIGHUP', (t) => {
let closeCalled = 0;
let openCalled = 0;
sandbox
.require('../../lib/appenders/file', {
requires: {
streamroller: {
RollingFileStream: class RollingFileStream {
constructor() {
openCalled++;
this.ended = false;
}
on() {
this.dummy = 'easier than turning off lint rule';
}
end(cb) {
this.ended = true;
closeCalled++;
cb();
}
write() {
if (this.ended) {
throw new Error('write after end');
}
return true;
}
},
},
},
})
.configure(
{ type: 'file', filename: 'sighup-test-file' },
{
basicLayout() {
return 'whatever';
},
}
);
process.emit('SIGHUP', 'SIGHUP', 1);
t.plan(2);
setTimeout(() => {
t.equal(openCalled, 2, 'open should be called twice');
t.equal(closeCalled, 1, 'close should be called once');
t.end();
}, osDelay);
});
test('file appender SIGHUP handler leak', (t) => {
const log4js = require('../../lib/log4js');
const initialListeners = process.listenerCount('SIGHUP');
log4js.configure({
appenders: {
file: { type: 'file', filename: 'test.log' },
},
categories: { default: { appenders: ['file'], level: 'info' } },
});
t.teardown(async () => {
await removeFiles('test.log');
});
t.plan(2);
t.equal(process.listenerCount('SIGHUP'), initialListeners + 1);
log4js.shutdown(() => {
t.equal(process.listenerCount('SIGHUP'), initialListeners);
t.end();
});
});
| 1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/fileAppender-test.js | /* eslint max-classes-per-file: ["error", 2] */
const { test } = require('tap');
const fs = require('fs-extra');
const path = require('path');
const sandbox = require('@log4js-node/sandboxed-module');
const zlib = require('zlib');
const util = require('util');
const sleep = util.promisify(setTimeout);
const gunzip = util.promisify(zlib.gunzip);
const EOL = require('os').EOL || '\n';
const log4js = require('../../lib/log4js');
const removeFile = async (filename) => {
try {
await fs.unlink(filename);
} catch (e) {
// let's pretend this never happened
}
};
test('log4js fileAppender', (batch) => {
batch.test('with default fileAppender settings', async (t) => {
const testFile = path.join(__dirname, 'fa-default-test.log');
const logger = log4js.getLogger('default-settings');
await removeFile(testFile);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await removeFile(testFile);
});
log4js.configure({
appenders: { file: { type: 'file', filename: testFile } },
categories: { default: { appenders: ['file'], level: 'debug' } },
});
logger.info('This should be in the file.');
await sleep(250);
const fileContents = await fs.readFile(testFile, 'utf8');
t.match(fileContents, `This should be in the file.${EOL}`);
t.match(
fileContents,
/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}] \[INFO] default-settings - /
);
t.end();
});
batch.test('should give error if invalid filename', async (t) => {
const file = '';
t.throws(
() =>
log4js.configure({
appenders: {
file: {
type: 'file',
filename: file,
},
},
categories: {
default: { appenders: ['file'], level: 'debug' },
},
}),
new Error(`Invalid filename: ${file}`)
);
const dir = `.${path.sep}`;
t.throws(
() =>
log4js.configure({
appenders: {
file: {
type: 'file',
filename: dir,
},
},
categories: {
default: { appenders: ['file'], level: 'debug' },
},
}),
new Error(`Filename is a directory: ${dir}`)
);
t.end();
});
batch.test('should flush logs on shutdown', async (t) => {
const testFile = path.join(__dirname, 'fa-default-test.log');
const logger = log4js.getLogger('default-settings');
await removeFile(testFile);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await removeFile(testFile);
});
log4js.configure({
appenders: { test: { type: 'file', filename: testFile } },
categories: { default: { appenders: ['test'], level: 'trace' } },
});
logger.info('1');
logger.info('2');
logger.info('3');
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
const fileContents = await fs.readFile(testFile, 'utf8');
// 3 lines of output, plus the trailing newline.
t.equal(fileContents.split(EOL).length, 4);
t.match(
fileContents,
/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}] \[INFO] default-settings - /
);
t.end();
});
batch.test('with a max file size and no backups', async (t) => {
const testFile = path.join(__dirname, 'fa-maxFileSize-test.log');
const logger = log4js.getLogger('max-file-size');
await removeFile(testFile);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await removeFile(testFile);
});
// log file of 100 bytes maximum, no backups
log4js.configure({
appenders: {
file: {
type: 'file',
filename: testFile,
maxLogSize: 100,
backups: 0,
},
},
categories: {
default: { appenders: ['file'], level: 'debug' },
},
});
logger.info('This is the first log message.');
logger.info('This is an intermediate log message.');
logger.info('This is the second log message.');
// wait for the file system to catch up
await sleep(250);
const fileContents = await fs.readFile(testFile, 'utf8');
t.match(fileContents, 'This is the second log message.');
t.equal(fileContents.indexOf('This is the first log message.'), -1);
const files = await fs.readdir(__dirname);
const logFiles = files.filter((file) =>
file.includes('fa-maxFileSize-test.log')
);
t.equal(logFiles.length, 1, 'should be 1 file');
t.end();
});
batch.test('with a max file size in wrong unit mode', async (t) => {
const invalidUnit = '1Z';
const expectedError = new Error(`maxLogSize: "${invalidUnit}" is invalid`);
t.throws(
() =>
log4js.configure({
appenders: {
file: {
type: 'file',
maxLogSize: invalidUnit,
},
},
categories: {
default: { appenders: ['file'], level: 'debug' },
},
}),
expectedError
);
t.end();
});
batch.test('with a max file size in unit mode and no backups', async (t) => {
const testFile = path.join(__dirname, 'fa-maxFileSize-unit-test.log');
const logger = log4js.getLogger('max-file-size-unit');
await Promise.all([removeFile(testFile), removeFile(`${testFile}.1`)]);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await Promise.all([removeFile(testFile), removeFile(`${testFile}.1`)]);
});
// log file of 1K = 1024 bytes maximum, no backups
log4js.configure({
appenders: {
file: {
type: 'file',
filename: testFile,
maxLogSize: '1K',
backups: 0,
layout: { type: 'messagePassThrough' },
},
},
categories: {
default: { appenders: ['file'], level: 'debug' },
},
});
const maxLine = 22; // 1024 max file size / 47 bytes per line
for (let i = 0; i < maxLine; i++) {
logger.info('These are the log messages for the first file.'); // 46 bytes per line + '\n'
}
logger.info('This is the second log message.');
// wait for the file system to catch up
await sleep(250);
const fileContents = await fs.readFile(testFile, 'utf8');
t.match(fileContents, 'This is the second log message.');
t.notMatch(fileContents, 'These are the log messages for the first file.');
const files = await fs.readdir(__dirname);
const logFiles = files.filter((file) =>
file.includes('fa-maxFileSize-unit-test.log')
);
t.equal(logFiles.length, 1, 'should be 1 file');
t.end();
});
batch.test('with a max file size and 2 backups', async (t) => {
const testFile = path.join(
__dirname,
'fa-maxFileSize-with-backups-test.log'
);
const logger = log4js.getLogger('max-file-size-backups');
await Promise.all([
removeFile(testFile),
removeFile(`${testFile}.1`),
removeFile(`${testFile}.2`),
]);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await Promise.all([
removeFile(testFile),
removeFile(`${testFile}.1`),
removeFile(`${testFile}.2`),
]);
});
// log file of 50 bytes maximum, 2 backups
log4js.configure({
appenders: {
file: {
type: 'file',
filename: testFile,
maxLogSize: 50,
backups: 2,
},
},
categories: { default: { appenders: ['file'], level: 'debug' } },
});
logger.info('This is the first log message.');
logger.info('This is the second log message.');
logger.info('This is the third log message.');
logger.info('This is the fourth log message.');
// give the system a chance to open the stream
await sleep(250);
const files = await fs.readdir(__dirname);
const logFiles = files
.sort()
.filter((file) => file.includes('fa-maxFileSize-with-backups-test.log'));
t.equal(logFiles.length, 3);
t.same(logFiles, [
'fa-maxFileSize-with-backups-test.log',
'fa-maxFileSize-with-backups-test.log.1',
'fa-maxFileSize-with-backups-test.log.2',
]);
let contents = await fs.readFile(path.join(__dirname, logFiles[0]), 'utf8');
t.match(contents, 'This is the fourth log message.');
contents = await fs.readFile(path.join(__dirname, logFiles[1]), 'utf8');
t.match(contents, 'This is the third log message.');
contents = await fs.readFile(path.join(__dirname, logFiles[2]), 'utf8');
t.match(contents, 'This is the second log message.');
t.end();
});
batch.test('with a max file size and 2 compressed backups', async (t) => {
const testFile = path.join(
__dirname,
'fa-maxFileSize-with-backups-compressed-test.log'
);
const logger = log4js.getLogger('max-file-size-backups');
await Promise.all([
removeFile(testFile),
removeFile(`${testFile}.1.gz`),
removeFile(`${testFile}.2.gz`),
]);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await Promise.all([
removeFile(testFile),
removeFile(`${testFile}.1.gz`),
removeFile(`${testFile}.2.gz`),
]);
});
// log file of 50 bytes maximum, 2 backups
log4js.configure({
appenders: {
file: {
type: 'file',
filename: testFile,
maxLogSize: 50,
backups: 2,
compress: true,
},
},
categories: { default: { appenders: ['file'], level: 'debug' } },
});
logger.info('This is the first log message.');
logger.info('This is the second log message.');
logger.info('This is the third log message.');
logger.info('This is the fourth log message.');
// give the system a chance to open the stream
await sleep(250);
const files = await fs.readdir(__dirname);
const logFiles = files
.sort()
.filter((file) =>
file.includes('fa-maxFileSize-with-backups-compressed-test.log')
);
t.equal(logFiles.length, 3, 'should be 3 files');
t.same(logFiles, [
'fa-maxFileSize-with-backups-compressed-test.log',
'fa-maxFileSize-with-backups-compressed-test.log.1.gz',
'fa-maxFileSize-with-backups-compressed-test.log.2.gz',
]);
let contents = await fs.readFile(path.join(__dirname, logFiles[0]), 'utf8');
t.match(contents, 'This is the fourth log message.');
contents = await gunzip(
await fs.readFile(path.join(__dirname, logFiles[1]))
);
t.match(contents.toString('utf8'), 'This is the third log message.');
contents = await gunzip(
await fs.readFile(path.join(__dirname, logFiles[2]))
);
t.match(contents.toString('utf8'), 'This is the second log message.');
t.end();
});
batch.test('handling of writer.writable', (t) => {
const output = [];
let writable = true;
const RollingFileStream = class {
write(loggingEvent) {
output.push(loggingEvent);
this.written = true;
return true;
}
// eslint-disable-next-line class-methods-use-this
on() {}
// eslint-disable-next-line class-methods-use-this
get writable() {
return writable;
}
};
const fileAppender = sandbox.require('../../lib/appenders/file', {
requires: {
streamroller: {
RollingFileStream,
},
},
});
const appender = fileAppender.configure(
{ filename: 'test1.log', maxLogSize: 100 },
{
basicLayout(loggingEvent) {
return loggingEvent.data;
},
}
);
t.test('should log when writer.writable=true', (assert) => {
writable = true;
appender({ data: 'something to log' });
assert.ok(output.length, 1);
assert.match(output[output.length - 1], 'something to log');
assert.end();
});
t.test('should not log when writer.writable=false', (assert) => {
writable = false;
appender({ data: 'this should not be logged' });
assert.ok(output.length, 1);
assert.notMatch(output[output.length - 1], 'this should not be logged');
assert.end();
});
t.end();
});
batch.test('when underlying stream errors', (t) => {
let consoleArgs;
let errorHandler;
const RollingFileStream = class {
end() {
this.ended = true;
}
on(evt, cb) {
if (evt === 'error') {
this.errored = true;
errorHandler = cb;
}
}
write() {
this.written = true;
return true;
}
};
const fileAppender = sandbox.require('../../lib/appenders/file', {
globals: {
console: {
error(...args) {
consoleArgs = args;
},
},
},
requires: {
streamroller: {
RollingFileStream,
},
},
});
fileAppender.configure(
{ filename: 'test1.log', maxLogSize: 100 },
{ basicLayout() {} }
);
errorHandler({ error: 'aargh' });
t.test('should log the error to console.error', (assert) => {
assert.ok(consoleArgs);
assert.equal(
consoleArgs[0],
'log4js.fileAppender - Writing to file %s, error happened '
);
assert.equal(consoleArgs[1], 'test1.log');
assert.equal(consoleArgs[2].error, 'aargh');
assert.end();
});
t.end();
});
batch.test('with removeColor fileAppender settings', async (t) => {
const testFilePlain = path.join(__dirname, 'fa-removeColor-test.log');
const testFileAsIs = path.join(__dirname, 'fa-asIs-test.log');
const logger = log4js.getLogger('default-settings');
await removeFile(testFilePlain);
await removeFile(testFileAsIs);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await removeFile(testFilePlain);
await removeFile(testFileAsIs);
});
log4js.configure({
appenders: {
plainFile: { type: 'file', filename: testFilePlain, removeColor: true },
asIsFile: { type: 'file', filename: testFileAsIs, removeColor: false },
},
categories: {
default: { appenders: ['plainFile', 'asIsFile'], level: 'debug' },
},
});
logger.info(
'This should be in the file.',
'\x1b[33mColor\x1b[0m \x1b[93;41mshould\x1b[0m be \x1b[38;5;8mplain\x1b[0m.',
{},
[]
);
await sleep(250);
let fileContents = await fs.readFile(testFilePlain, 'utf8');
t.match(
fileContents,
`This should be in the file. Color should be plain. {} []${EOL}`
);
t.match(
fileContents,
/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}] \[INFO] default-settings - /
);
fileContents = await fs.readFile(testFileAsIs, 'utf8');
t.match(
fileContents,
'This should be in the file.',
`\x1b[33mColor\x1b[0m \x1b[93;41mshould\x1b[0m be \x1b[38;5;8mplain\x1b[0m. {} []${EOL}`
);
t.match(
fileContents,
/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}] \[INFO] default-settings - /
);
t.end();
});
batch.end();
});
| /* eslint max-classes-per-file: ["error", 2] */
const { test } = require('tap');
const fs = require('fs-extra');
const path = require('path');
const sandbox = require('@log4js-node/sandboxed-module');
const zlib = require('zlib');
const util = require('util');
const osDelay = process.platform === 'win32' ? 400 : 200;
const sleep = util.promisify(setTimeout);
const gunzip = util.promisify(zlib.gunzip);
const EOL = require('os').EOL || '\n';
const log4js = require('../../lib/log4js');
const removeFile = async (filename) => {
try {
await fs.unlink(filename);
} catch (e) {
// let's pretend this never happened
}
};
test('log4js fileAppender', (batch) => {
batch.test('with default fileAppender settings', async (t) => {
const testFile = path.join(__dirname, 'fa-default-test.log');
const logger = log4js.getLogger('default-settings');
await removeFile(testFile);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await removeFile(testFile);
});
log4js.configure({
appenders: { file: { type: 'file', filename: testFile } },
categories: { default: { appenders: ['file'], level: 'debug' } },
});
logger.info('This should be in the file.');
await sleep(osDelay);
const fileContents = await fs.readFile(testFile, 'utf8');
t.match(fileContents, `This should be in the file.${EOL}`);
t.match(
fileContents,
/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}] \[INFO] default-settings - /
);
t.end();
});
batch.test('should give error if invalid filename', async (t) => {
const file = '';
t.throws(
() =>
log4js.configure({
appenders: {
file: {
type: 'file',
filename: file,
},
},
categories: {
default: { appenders: ['file'], level: 'debug' },
},
}),
new Error(`Invalid filename: ${file}`)
);
const dir = `.${path.sep}`;
t.throws(
() =>
log4js.configure({
appenders: {
file: {
type: 'file',
filename: dir,
},
},
categories: {
default: { appenders: ['file'], level: 'debug' },
},
}),
new Error(`Filename is a directory: ${dir}`)
);
t.end();
});
batch.test('should flush logs on shutdown', async (t) => {
const testFile = path.join(__dirname, 'fa-default-test.log');
const logger = log4js.getLogger('default-settings');
await removeFile(testFile);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await removeFile(testFile);
});
log4js.configure({
appenders: { test: { type: 'file', filename: testFile } },
categories: { default: { appenders: ['test'], level: 'trace' } },
});
logger.info('1');
logger.info('2');
logger.info('3');
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
const fileContents = await fs.readFile(testFile, 'utf8');
// 3 lines of output, plus the trailing newline.
t.equal(fileContents.split(EOL).length, 4);
t.match(
fileContents,
/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}] \[INFO] default-settings - /
);
t.end();
});
batch.test('with a max file size and no backups', async (t) => {
const testFile = path.join(__dirname, 'fa-maxFileSize-test.log');
const logger = log4js.getLogger('max-file-size');
await removeFile(testFile);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await removeFile(testFile);
});
// log file of 100 bytes maximum, no backups
log4js.configure({
appenders: {
file: {
type: 'file',
filename: testFile,
maxLogSize: 100,
backups: 0,
},
},
categories: {
default: { appenders: ['file'], level: 'debug' },
},
});
logger.info('This is the first log message.');
logger.info('This is an intermediate log message.');
logger.info('This is the second log message.');
// wait for the file system to catch up
await sleep(osDelay * 2);
const fileContents = await fs.readFile(testFile, 'utf8');
t.match(fileContents, 'This is the second log message.');
t.equal(fileContents.indexOf('This is the first log message.'), -1);
const files = await fs.readdir(__dirname);
const logFiles = files.filter((file) =>
file.includes('fa-maxFileSize-test.log')
);
t.equal(logFiles.length, 1, 'should be 1 file');
t.end();
});
batch.test('with a max file size in wrong unit mode', async (t) => {
const invalidUnit = '1Z';
const expectedError = new Error(`maxLogSize: "${invalidUnit}" is invalid`);
t.throws(
() =>
log4js.configure({
appenders: {
file: {
type: 'file',
maxLogSize: invalidUnit,
},
},
categories: {
default: { appenders: ['file'], level: 'debug' },
},
}),
expectedError
);
t.end();
});
batch.test('with a max file size in unit mode and no backups', async (t) => {
const testFile = path.join(__dirname, 'fa-maxFileSize-unit-test.log');
const logger = log4js.getLogger('max-file-size-unit');
await Promise.all([removeFile(testFile), removeFile(`${testFile}.1`)]);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await Promise.all([removeFile(testFile), removeFile(`${testFile}.1`)]);
});
// log file of 1K = 1024 bytes maximum, no backups
log4js.configure({
appenders: {
file: {
type: 'file',
filename: testFile,
maxLogSize: '1K',
backups: 0,
layout: { type: 'messagePassThrough' },
},
},
categories: {
default: { appenders: ['file'], level: 'debug' },
},
});
const maxLine = 22; // 1024 max file size / 47 bytes per line
for (let i = 0; i < maxLine; i++) {
logger.info('These are the log messages for the first file.'); // 46 bytes per line + '\n'
}
logger.info('This is the second log message.');
// wait for the file system to catch up
await sleep(osDelay);
const fileContents = await fs.readFile(testFile, 'utf8');
t.match(fileContents, 'This is the second log message.');
t.notMatch(fileContents, 'These are the log messages for the first file.');
const files = await fs.readdir(__dirname);
const logFiles = files.filter((file) =>
file.includes('fa-maxFileSize-unit-test.log')
);
t.equal(logFiles.length, 1, 'should be 1 file');
t.end();
});
batch.test('with a max file size and 2 backups', async (t) => {
const testFile = path.join(
__dirname,
'fa-maxFileSize-with-backups-test.log'
);
const logger = log4js.getLogger('max-file-size-backups');
await Promise.all([
removeFile(testFile),
removeFile(`${testFile}.1`),
removeFile(`${testFile}.2`),
]);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await Promise.all([
removeFile(testFile),
removeFile(`${testFile}.1`),
removeFile(`${testFile}.2`),
]);
});
// log file of 50 bytes maximum, 2 backups
log4js.configure({
appenders: {
file: {
type: 'file',
filename: testFile,
maxLogSize: 50,
backups: 2,
},
},
categories: { default: { appenders: ['file'], level: 'debug' } },
});
logger.info('This is the first log message.');
logger.info('This is the second log message.');
logger.info('This is the third log message.');
logger.info('This is the fourth log message.');
// give the system a chance to open the stream
await sleep(osDelay);
const files = await fs.readdir(__dirname);
const logFiles = files
.sort()
.filter((file) => file.includes('fa-maxFileSize-with-backups-test.log'));
t.equal(logFiles.length, 3);
t.same(logFiles, [
'fa-maxFileSize-with-backups-test.log',
'fa-maxFileSize-with-backups-test.log.1',
'fa-maxFileSize-with-backups-test.log.2',
]);
let contents = await fs.readFile(path.join(__dirname, logFiles[0]), 'utf8');
t.match(contents, 'This is the fourth log message.');
contents = await fs.readFile(path.join(__dirname, logFiles[1]), 'utf8');
t.match(contents, 'This is the third log message.');
contents = await fs.readFile(path.join(__dirname, logFiles[2]), 'utf8');
t.match(contents, 'This is the second log message.');
t.end();
});
batch.test('with a max file size and 2 compressed backups', async (t) => {
const testFile = path.join(
__dirname,
'fa-maxFileSize-with-backups-compressed-test.log'
);
const logger = log4js.getLogger('max-file-size-backups');
await Promise.all([
removeFile(testFile),
removeFile(`${testFile}.1.gz`),
removeFile(`${testFile}.2.gz`),
]);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await Promise.all([
removeFile(testFile),
removeFile(`${testFile}.1.gz`),
removeFile(`${testFile}.2.gz`),
]);
});
// log file of 50 bytes maximum, 2 backups
log4js.configure({
appenders: {
file: {
type: 'file',
filename: testFile,
maxLogSize: 50,
backups: 2,
compress: true,
},
},
categories: { default: { appenders: ['file'], level: 'debug' } },
});
logger.info('This is the first log message.');
logger.info('This is the second log message.');
logger.info('This is the third log message.');
logger.info('This is the fourth log message.');
// give the system a chance to open the stream
await sleep(osDelay);
const files = await fs.readdir(__dirname);
const logFiles = files
.sort()
.filter((file) =>
file.includes('fa-maxFileSize-with-backups-compressed-test.log')
);
t.equal(logFiles.length, 3, 'should be 3 files');
t.same(logFiles, [
'fa-maxFileSize-with-backups-compressed-test.log',
'fa-maxFileSize-with-backups-compressed-test.log.1.gz',
'fa-maxFileSize-with-backups-compressed-test.log.2.gz',
]);
let contents = await fs.readFile(path.join(__dirname, logFiles[0]), 'utf8');
t.match(contents, 'This is the fourth log message.');
contents = await gunzip(
await fs.readFile(path.join(__dirname, logFiles[1]))
);
t.match(contents.toString('utf8'), 'This is the third log message.');
contents = await gunzip(
await fs.readFile(path.join(__dirname, logFiles[2]))
);
t.match(contents.toString('utf8'), 'This is the second log message.');
t.end();
});
batch.test('handling of writer.writable', (t) => {
const output = [];
let writable = true;
const RollingFileStream = class {
write(loggingEvent) {
output.push(loggingEvent);
this.written = true;
return true;
}
// eslint-disable-next-line class-methods-use-this
on() {}
// eslint-disable-next-line class-methods-use-this
get writable() {
return writable;
}
};
const fileAppender = sandbox.require('../../lib/appenders/file', {
requires: {
streamroller: {
RollingFileStream,
},
},
});
const appender = fileAppender.configure(
{ filename: 'test1.log', maxLogSize: 100 },
{
basicLayout(loggingEvent) {
return loggingEvent.data;
},
}
);
t.test('should log when writer.writable=true', (assert) => {
writable = true;
appender({ data: 'something to log' });
assert.ok(output.length, 1);
assert.match(output[output.length - 1], 'something to log');
assert.end();
});
t.test('should not log when writer.writable=false', (assert) => {
writable = false;
appender({ data: 'this should not be logged' });
assert.ok(output.length, 1);
assert.notMatch(output[output.length - 1], 'this should not be logged');
assert.end();
});
t.end();
});
batch.test('when underlying stream errors', (t) => {
let consoleArgs;
let errorHandler;
const RollingFileStream = class {
end() {
this.ended = true;
}
on(evt, cb) {
if (evt === 'error') {
this.errored = true;
errorHandler = cb;
}
}
write() {
this.written = true;
return true;
}
};
const fileAppender = sandbox.require('../../lib/appenders/file', {
globals: {
console: {
error(...args) {
consoleArgs = args;
},
},
},
requires: {
streamroller: {
RollingFileStream,
},
},
});
fileAppender.configure(
{ filename: 'test1.log', maxLogSize: 100 },
{ basicLayout() {} }
);
errorHandler({ error: 'aargh' });
t.test('should log the error to console.error', (assert) => {
assert.ok(consoleArgs);
assert.equal(
consoleArgs[0],
'log4js.fileAppender - Writing to file %s, error happened '
);
assert.equal(consoleArgs[1], 'test1.log');
assert.equal(consoleArgs[2].error, 'aargh');
assert.end();
});
t.end();
});
batch.test('with removeColor fileAppender settings', async (t) => {
const testFilePlain = path.join(__dirname, 'fa-removeColor-test.log');
const testFileAsIs = path.join(__dirname, 'fa-asIs-test.log');
const logger = log4js.getLogger('default-settings');
await removeFile(testFilePlain);
await removeFile(testFileAsIs);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await removeFile(testFilePlain);
await removeFile(testFileAsIs);
});
log4js.configure({
appenders: {
plainFile: { type: 'file', filename: testFilePlain, removeColor: true },
asIsFile: { type: 'file', filename: testFileAsIs, removeColor: false },
},
categories: {
default: { appenders: ['plainFile', 'asIsFile'], level: 'debug' },
},
});
logger.info(
'This should be in the file.',
'\x1b[33mColor\x1b[0m \x1b[93;41mshould\x1b[0m be \x1b[38;5;8mplain\x1b[0m.',
{},
[]
);
await sleep(osDelay);
let fileContents = await fs.readFile(testFilePlain, 'utf8');
t.match(
fileContents,
`This should be in the file. Color should be plain. {} []${EOL}`
);
t.match(
fileContents,
/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}] \[INFO] default-settings - /
);
fileContents = await fs.readFile(testFileAsIs, 'utf8');
t.match(
fileContents,
'This should be in the file.',
`\x1b[33mColor\x1b[0m \x1b[93;41mshould\x1b[0m be \x1b[38;5;8mplain\x1b[0m. {} []${EOL}`
);
t.match(
fileContents,
/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}] \[INFO] default-settings - /
);
t.end();
});
batch.end();
});
| 1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/logLevelFilter-test.js | const { test } = require('tap');
const fs = require('fs');
const os = require('os');
const EOL = os.EOL || '\n';
function remove(filename) {
try {
fs.unlinkSync(filename);
} catch (e) {
// doesn't really matter if it failed
}
}
test('log4js logLevelFilter', (batch) => {
batch.test('appender', (t) => {
const log4js = require('../../lib/log4js');
const recording = require('../../lib/appenders/recording');
log4js.configure({
appenders: {
recorder: { type: 'recording' },
filtered: {
type: 'logLevelFilter',
appender: 'recorder',
level: 'ERROR',
},
},
categories: {
default: { appenders: ['filtered'], level: 'debug' },
},
});
const logger = log4js.getLogger('logLevelTest');
logger.debug('this should not trigger an event');
logger.warn('neither should this');
logger.error('this should, though');
logger.fatal('so should this');
const logEvents = recording.replay();
t.test(
'should only pass log events greater than or equal to its own level',
(assert) => {
assert.equal(logEvents.length, 2);
assert.equal(logEvents[0].data[0], 'this should, though');
assert.equal(logEvents[1].data[0], 'so should this');
assert.end();
}
);
t.end();
});
batch.test('configure', (t) => {
const log4js = require('../../lib/log4js');
remove(`${__dirname}/logLevelFilter.log`);
remove(`${__dirname}/logLevelFilter-warnings.log`);
remove(`${__dirname}/logLevelFilter-debugs.log`);
t.teardown(() => {
remove(`${__dirname}/logLevelFilter.log`);
remove(`${__dirname}/logLevelFilter-warnings.log`);
remove(`${__dirname}/logLevelFilter-debugs.log`);
});
log4js.configure({
appenders: {
'warning-file': {
type: 'file',
filename: 'test/tap/logLevelFilter-warnings.log',
layout: { type: 'messagePassThrough' },
},
warnings: {
type: 'logLevelFilter',
level: 'WARN',
appender: 'warning-file',
},
'debug-file': {
type: 'file',
filename: 'test/tap/logLevelFilter-debugs.log',
layout: { type: 'messagePassThrough' },
},
debugs: {
type: 'logLevelFilter',
level: 'TRACE',
maxLevel: 'DEBUG',
appender: 'debug-file',
},
tests: {
type: 'file',
filename: 'test/tap/logLevelFilter.log',
layout: {
type: 'messagePassThrough',
},
},
},
categories: {
default: { appenders: ['tests', 'warnings', 'debugs'], level: 'trace' },
},
});
const logger = log4js.getLogger('tests');
logger.debug('debug');
logger.info('info');
logger.error('error');
logger.warn('warn');
logger.debug('debug');
logger.trace('trace');
// wait for the file system to catch up
setTimeout(() => {
t.test('tmp-tests.log should contain all log messages', (assert) => {
fs.readFile(
`${__dirname}/logLevelFilter.log`,
'utf8',
(err, contents) => {
const messages = contents.trim().split(EOL);
assert.same(messages, [
'debug',
'info',
'error',
'warn',
'debug',
'trace',
]);
assert.end();
}
);
});
t.test(
'tmp-tests-warnings.log should contain only error and warning logs',
(assert) => {
fs.readFile(
`${__dirname}/logLevelFilter-warnings.log`,
'utf8',
(err, contents) => {
const messages = contents.trim().split(EOL);
assert.same(messages, ['error', 'warn']);
assert.end();
}
);
}
);
t.test(
'tmp-tests-debugs.log should contain only trace and debug logs',
(assert) => {
fs.readFile(
`${__dirname}/logLevelFilter-debugs.log`,
'utf8',
(err, contents) => {
const messages = contents.trim().split(EOL);
assert.same(messages, ['debug', 'debug', 'trace']);
assert.end();
}
);
}
);
t.end();
}, 500);
});
batch.end();
});
| const { test } = require('tap');
const fs = require('fs');
const os = require('os');
const EOL = os.EOL || '\n';
const osDelay = process.platform === 'win32' ? 400 : 200;
function remove(filename) {
try {
fs.unlinkSync(filename);
} catch (e) {
// doesn't really matter if it failed
}
}
test('log4js logLevelFilter', (batch) => {
batch.test('appender', (t) => {
const log4js = require('../../lib/log4js');
const recording = require('../../lib/appenders/recording');
log4js.configure({
appenders: {
recorder: { type: 'recording' },
filtered: {
type: 'logLevelFilter',
appender: 'recorder',
level: 'ERROR',
},
},
categories: {
default: { appenders: ['filtered'], level: 'debug' },
},
});
const logger = log4js.getLogger('logLevelTest');
logger.debug('this should not trigger an event');
logger.warn('neither should this');
logger.error('this should, though');
logger.fatal('so should this');
const logEvents = recording.replay();
t.test(
'should only pass log events greater than or equal to its own level',
(assert) => {
assert.equal(logEvents.length, 2);
assert.equal(logEvents[0].data[0], 'this should, though');
assert.equal(logEvents[1].data[0], 'so should this');
assert.end();
}
);
t.end();
});
batch.test('configure', (t) => {
const log4js = require('../../lib/log4js');
remove(`${__dirname}/logLevelFilter.log`);
remove(`${__dirname}/logLevelFilter-warnings.log`);
remove(`${__dirname}/logLevelFilter-debugs.log`);
t.teardown(() => {
remove(`${__dirname}/logLevelFilter.log`);
remove(`${__dirname}/logLevelFilter-warnings.log`);
remove(`${__dirname}/logLevelFilter-debugs.log`);
});
log4js.configure({
appenders: {
'warning-file': {
type: 'file',
filename: 'test/tap/logLevelFilter-warnings.log',
layout: { type: 'messagePassThrough' },
},
warnings: {
type: 'logLevelFilter',
level: 'WARN',
appender: 'warning-file',
},
'debug-file': {
type: 'file',
filename: 'test/tap/logLevelFilter-debugs.log',
layout: { type: 'messagePassThrough' },
},
debugs: {
type: 'logLevelFilter',
level: 'TRACE',
maxLevel: 'DEBUG',
appender: 'debug-file',
},
tests: {
type: 'file',
filename: 'test/tap/logLevelFilter.log',
layout: {
type: 'messagePassThrough',
},
},
},
categories: {
default: { appenders: ['tests', 'warnings', 'debugs'], level: 'trace' },
},
});
const logger = log4js.getLogger('tests');
logger.debug('debug');
logger.info('info');
logger.error('error');
logger.warn('warn');
logger.debug('debug');
logger.trace('trace');
// wait for the file system to catch up
setTimeout(() => {
t.test('tmp-tests.log should contain all log messages', (assert) => {
fs.readFile(
`${__dirname}/logLevelFilter.log`,
'utf8',
(err, contents) => {
const messages = contents.trim().split(EOL);
assert.same(messages, [
'debug',
'info',
'error',
'warn',
'debug',
'trace',
]);
assert.end();
}
);
});
t.test(
'tmp-tests-warnings.log should contain only error and warning logs',
(assert) => {
fs.readFile(
`${__dirname}/logLevelFilter-warnings.log`,
'utf8',
(err, contents) => {
const messages = contents.trim().split(EOL);
assert.same(messages, ['error', 'warn']);
assert.end();
}
);
}
);
t.test(
'tmp-tests-debugs.log should contain only trace and debug logs',
(assert) => {
fs.readFile(
`${__dirname}/logLevelFilter-debugs.log`,
'utf8',
(err, contents) => {
const messages = contents.trim().split(EOL);
assert.same(messages, ['debug', 'debug', 'trace']);
assert.end();
}
);
}
);
t.end();
}, osDelay);
});
batch.end();
});
| 1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/multi-file-appender-test.js | const process = require('process');
const { test } = require('tap');
const debug = require('debug');
const fs = require('fs');
const sandbox = require('@log4js-node/sandboxed-module');
const log4js = require('../../lib/log4js');
const removeFiles = async (filenames) => {
if (!Array.isArray(filenames)) filenames = [filenames];
const promises = filenames.map((filename) => fs.promises.unlink(filename));
await Promise.allSettled(promises);
};
test('multiFile appender', (batch) => {
batch.test(
'should write to multiple files based on the loggingEvent property',
(t) => {
t.teardown(async () => {
await removeFiles(['logs/A.log', 'logs/B.log']);
});
log4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'categoryName',
extension: '.log',
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerA = log4js.getLogger('A');
const loggerB = log4js.getLogger('B');
loggerA.info('I am in logger A');
loggerB.info('I am in logger B');
log4js.shutdown(() => {
t.match(fs.readFileSync('logs/A.log', 'utf-8'), 'I am in logger A');
t.match(fs.readFileSync('logs/B.log', 'utf-8'), 'I am in logger B');
t.end();
});
}
);
batch.test(
'should write to multiple files based on loggingEvent.context properties',
(t) => {
t.teardown(async () => {
await removeFiles(['logs/C.log', 'logs/D.log']);
});
log4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'label',
extension: '.log',
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerC = log4js.getLogger('cheese');
const loggerD = log4js.getLogger('biscuits');
loggerC.addContext('label', 'C');
loggerD.addContext('label', 'D');
loggerC.info('I am in logger C');
loggerD.info('I am in logger D');
log4js.shutdown(() => {
t.match(fs.readFileSync('logs/C.log', 'utf-8'), 'I am in logger C');
t.match(fs.readFileSync('logs/D.log', 'utf-8'), 'I am in logger D');
t.end();
});
}
);
batch.test('should close file after timeout', (t) => {
/* checking that the file is closed after a timeout is done by looking at the debug logs
since detecting file locks with node.js is platform specific.
*/
const debugWasEnabled = debug.enabled('log4js:multiFile');
const debugLogs = [];
const originalWrite = process.stderr.write;
process.stderr.write = (string, encoding, fd) => {
debugLogs.push(string);
if (debugWasEnabled) {
originalWrite.apply(process.stderr, [string, encoding, fd]);
}
};
const originalNamespace = debug.disable();
debug.enable(`${originalNamespace}, log4js:multiFile`);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await removeFiles('logs/C.log');
process.stderr.write = originalWrite;
debug.enable(originalNamespace);
});
const timeoutMs = 25;
log4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'label',
extension: '.log',
timeout: timeoutMs,
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerC = log4js.getLogger('cheese');
loggerC.addContext('label', 'C');
loggerC.info('I am in logger C');
setTimeout(() => {
t.match(
debugLogs[debugLogs.length - 1],
`C not used for > ${timeoutMs} ms => close`,
'(timeout1) should have closed'
);
t.end();
}, timeoutMs * 1 + 50); // add a 50 ms delay
});
batch.test('should close file safely after timeout', (t) => {
const error = new Error('fileAppender shutdown error');
const sandboxedLog4js = sandbox.require('../../lib/log4js', {
requires: {
'./appenders/file': {
configure(config, layouts) {
const fileAppender = require('../../lib/appenders/file').configure(
config,
layouts
);
const originalShutdown = fileAppender.shutdown;
fileAppender.shutdown = function(complete) {
const onCallback = function() {
complete(error);
};
originalShutdown(onCallback);
};
return fileAppender;
},
},
debug,
},
});
/* checking that the file is closed after a timeout is done by looking at the debug logs
since detecting file locks with node.js is platform specific.
*/
const debugWasEnabled = debug.enabled('log4js:multiFile');
const debugLogs = [];
const originalWrite = process.stderr.write;
process.stderr.write = (string, encoding, fd) => {
debugLogs.push(string);
if (debugWasEnabled) {
originalWrite.apply(process.stderr, [string, encoding, fd]);
}
};
const originalNamespace = debug.disable();
debug.enable(`${originalNamespace}, log4js:multiFile`);
t.teardown(async () => {
await new Promise((resolve) => {
sandboxedLog4js.shutdown(resolve);
});
await removeFiles('logs/C.log');
process.stderr.write = originalWrite;
debug.enable(originalNamespace);
});
const timeoutMs = 25;
sandboxedLog4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'label',
extension: '.log',
timeout: timeoutMs,
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerC = sandboxedLog4js.getLogger('cheese');
loggerC.addContext('label', 'C');
loggerC.info('I am in logger C');
setTimeout(() => {
t.match(
debugLogs[debugLogs.length - 2],
`C not used for > ${timeoutMs} ms => close`,
'(timeout1) should have closed'
);
t.match(
debugLogs[debugLogs.length - 1],
`ignore error on file shutdown: ${error.message}`,
'safely shutdown'
);
t.end();
}, timeoutMs * 1 + 50); // add a 50 ms delay
});
batch.test('should close file after extended timeout', (t) => {
/* checking that the file is closed after a timeout is done by looking at the debug logs
since detecting file locks with node.js is platform specific.
*/
const debugWasEnabled = debug.enabled('log4js:multiFile');
const debugLogs = [];
const originalWrite = process.stderr.write;
process.stderr.write = (string, encoding, fd) => {
debugLogs.push(string);
if (debugWasEnabled) {
originalWrite.apply(process.stderr, [string, encoding, fd]);
}
};
const originalNamespace = debug.disable();
debug.enable(`${originalNamespace}, log4js:multiFile`);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await removeFiles('logs/D.log');
process.stderr.write = originalWrite;
debug.enable(originalNamespace);
});
const timeoutMs = 100;
log4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'label',
extension: '.log',
timeout: timeoutMs,
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerD = log4js.getLogger('cheese');
loggerD.addContext('label', 'D');
loggerD.info('I am in logger D');
setTimeout(() => {
loggerD.info('extending activity!');
t.match(
debugLogs[debugLogs.length - 1],
'D extending activity',
'should have extended'
);
}, timeoutMs / 2);
setTimeout(() => {
t.notOk(
debugLogs.some(
(s) => s.indexOf(`D not used for > ${timeoutMs} ms => close`) !== -1
),
'(timeout1) should not have closed'
);
}, timeoutMs * 1 + 50); // add a 50 ms delay
setTimeout(() => {
t.match(
debugLogs[debugLogs.length - 1],
`D not used for > ${timeoutMs} ms => close`,
'(timeout2) should have closed'
);
t.end();
}, timeoutMs * 2 + 50); // add a 50 ms delay
});
batch.test('should clear interval for active timers on shutdown', (t) => {
/* checking that the file is closed after a timeout is done by looking at the debug logs
since detecting file locks with node.js is platform specific.
*/
const debugWasEnabled = debug.enabled('log4js:multiFile');
const debugLogs = [];
const originalWrite = process.stderr.write;
process.stderr.write = (string, encoding, fd) => {
debugLogs.push(string);
if (debugWasEnabled) {
originalWrite.apply(process.stderr, [string, encoding, fd]);
}
};
const originalNamespace = debug.disable();
debug.enable(`${originalNamespace}, log4js:multiFile`);
t.teardown(async () => {
await removeFiles('logs/D.log');
process.stderr.write = originalWrite;
debug.enable(originalNamespace);
});
const timeoutMs = 100;
log4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'label',
extension: '.log',
timeout: timeoutMs,
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerD = log4js.getLogger('cheese');
loggerD.addContext('label', 'D');
loggerD.info('I am in logger D');
log4js.shutdown(() => {
t.notOk(
debugLogs.some(
(s) => s.indexOf(`D not used for > ${timeoutMs} ms => close`) !== -1
),
'should not have closed'
);
t.ok(
debugLogs.some((s) => s.indexOf('clearing timer for D') !== -1),
'should have cleared timers'
);
t.match(
debugLogs[debugLogs.length - 1],
'calling shutdown for D',
'should have called shutdown'
);
t.end();
});
});
batch.test(
'should fail silently if loggingEvent property has no value',
(t) => {
t.teardown(async () => {
await removeFiles('logs/E.log');
});
log4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'label',
extension: '.log',
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerE = log4js.getLogger();
loggerE.addContext('label', 'E');
loggerE.info('I am in logger E');
loggerE.removeContext('label');
loggerE.info('I am not in logger E');
loggerE.addContext('label', null);
loggerE.info('I am also not in logger E');
log4js.shutdown(() => {
const contents = fs.readFileSync('logs/E.log', 'utf-8');
t.match(contents, 'I am in logger E');
t.notMatch(contents, 'I am not in logger E');
t.notMatch(contents, 'I am also not in logger E');
t.end();
});
}
);
batch.test('should pass options to rolling file stream', (t) => {
t.teardown(async () => {
await removeFiles(['logs/F.log', 'logs/F.log.1', 'logs/F.log.2']);
});
log4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'label',
extension: '.log',
maxLogSize: 30,
backups: 2,
layout: { type: 'messagePassThrough' },
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerF = log4js.getLogger();
loggerF.addContext('label', 'F');
loggerF.info('Being in logger F is the best.');
loggerF.info('I am also in logger F, awesome');
loggerF.info('I am in logger F');
log4js.shutdown(() => {
let contents = fs.readFileSync('logs/F.log', 'utf-8');
t.match(contents, 'I am in logger F');
contents = fs.readFileSync('logs/F.log.1', 'utf-8');
t.match(contents, 'I am also in logger F');
contents = fs.readFileSync('logs/F.log.2', 'utf-8');
t.match(contents, 'Being in logger F is the best');
t.end();
});
});
batch.test('should inherit config from category hierarchy', (t) => {
t.teardown(async () => {
await removeFiles('logs/test.someTest.log');
});
log4js.configure({
appenders: {
out: { type: 'stdout' },
test: {
type: 'multiFile',
base: 'logs/',
property: 'categoryName',
extension: '.log',
},
},
categories: {
default: { appenders: ['out'], level: 'info' },
test: { appenders: ['test'], level: 'debug' },
},
});
const testLogger = log4js.getLogger('test.someTest');
testLogger.debug('This should go to the file');
log4js.shutdown(() => {
const contents = fs.readFileSync('logs/test.someTest.log', 'utf-8');
t.match(contents, 'This should go to the file');
t.end();
});
});
batch.test('should shutdown safely even if it is not used', (t) => {
log4js.configure({
appenders: {
out: { type: 'stdout' },
test: {
type: 'multiFile',
base: 'logs/',
property: 'categoryName',
extension: '.log',
},
},
categories: {
default: { appenders: ['out'], level: 'info' },
test: { appenders: ['test'], level: 'debug' },
},
});
log4js.shutdown(() => {
t.ok('callback is called');
t.end();
});
});
batch.teardown(async () => {
try {
const files = fs.readdirSync('logs');
await removeFiles(files.map((filename) => `logs/${filename}`));
fs.rmdirSync('logs');
} catch (e) {
// doesn't matter
}
});
batch.end();
});
| const process = require('process');
const { test } = require('tap');
const debug = require('debug');
const fs = require('fs');
const sandbox = require('@log4js-node/sandboxed-module');
const log4js = require('../../lib/log4js');
const removeFiles = async (filenames) => {
if (!Array.isArray(filenames)) filenames = [filenames];
const promises = filenames.map((filename) => fs.promises.unlink(filename));
await Promise.allSettled(promises);
};
test('multiFile appender', (batch) => {
batch.test(
'should write to multiple files based on the loggingEvent property',
(t) => {
t.teardown(async () => {
await removeFiles(['logs/A.log', 'logs/B.log']);
});
log4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'categoryName',
extension: '.log',
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerA = log4js.getLogger('A');
const loggerB = log4js.getLogger('B');
loggerA.info('I am in logger A');
loggerB.info('I am in logger B');
log4js.shutdown(() => {
t.match(fs.readFileSync('logs/A.log', 'utf-8'), 'I am in logger A');
t.match(fs.readFileSync('logs/B.log', 'utf-8'), 'I am in logger B');
t.end();
});
}
);
batch.test(
'should write to multiple files based on loggingEvent.context properties',
(t) => {
t.teardown(async () => {
await removeFiles(['logs/C.log', 'logs/D.log']);
});
log4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'label',
extension: '.log',
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerC = log4js.getLogger('cheese');
const loggerD = log4js.getLogger('biscuits');
loggerC.addContext('label', 'C');
loggerD.addContext('label', 'D');
loggerC.info('I am in logger C');
loggerD.info('I am in logger D');
log4js.shutdown(() => {
t.match(fs.readFileSync('logs/C.log', 'utf-8'), 'I am in logger C');
t.match(fs.readFileSync('logs/D.log', 'utf-8'), 'I am in logger D');
t.end();
});
}
);
batch.test('should close file after timeout', (t) => {
/* checking that the file is closed after a timeout is done by looking at the debug logs
since detecting file locks with node.js is platform specific.
*/
const debugWasEnabled = debug.enabled('log4js:multiFile');
const debugLogs = [];
const originalWrite = process.stderr.write;
process.stderr.write = (string, encoding, fd) => {
debugLogs.push(string);
if (debugWasEnabled) {
originalWrite.apply(process.stderr, [string, encoding, fd]);
}
};
const originalNamespace = debug.disable();
debug.enable(`${originalNamespace}, log4js:multiFile`);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await removeFiles('logs/C.log');
process.stderr.write = originalWrite;
debug.enable(originalNamespace);
});
const timeoutMs = 25;
log4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'label',
extension: '.log',
timeout: timeoutMs,
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerC = log4js.getLogger('cheese');
loggerC.addContext('label', 'C');
loggerC.info('I am in logger C');
setTimeout(() => {
t.match(
debugLogs[debugLogs.length - 1],
`C not used for > ${timeoutMs} ms => close`,
'(timeout1) should have closed'
);
t.end();
}, timeoutMs * 1 + 50); // add a 50 ms delay
});
batch.test('should close file safely after timeout', (t) => {
const error = new Error('fileAppender shutdown error');
const sandboxedLog4js = sandbox.require('../../lib/log4js', {
requires: {
'./appenders/file': {
configure(config, layouts) {
const fileAppender = require('../../lib/appenders/file').configure(
config,
layouts
);
const originalShutdown = fileAppender.shutdown;
fileAppender.shutdown = function(complete) {
const onCallback = function() {
complete(error);
};
originalShutdown(onCallback);
};
return fileAppender;
},
},
debug,
},
});
/* checking that the file is closed after a timeout is done by looking at the debug logs
since detecting file locks with node.js is platform specific.
*/
const debugWasEnabled = debug.enabled('log4js:multiFile');
const debugLogs = [];
const originalWrite = process.stderr.write;
process.stderr.write = (string, encoding, fd) => {
debugLogs.push(string);
if (debugWasEnabled) {
originalWrite.apply(process.stderr, [string, encoding, fd]);
}
};
const originalNamespace = debug.disable();
debug.enable(`${originalNamespace}, log4js:multiFile`);
t.teardown(async () => {
await new Promise((resolve) => {
sandboxedLog4js.shutdown(resolve);
});
await removeFiles('logs/C.log');
process.stderr.write = originalWrite;
debug.enable(originalNamespace);
});
const timeoutMs = 25;
sandboxedLog4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'label',
extension: '.log',
timeout: timeoutMs,
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerC = sandboxedLog4js.getLogger('cheese');
loggerC.addContext('label', 'C');
loggerC.info('I am in logger C');
setTimeout(() => {
t.match(
debugLogs[debugLogs.length - 2],
`C not used for > ${timeoutMs} ms => close`,
'(timeout1) should have closed'
);
t.match(
debugLogs[debugLogs.length - 1],
`ignore error on file shutdown: ${error.message}`,
'safely shutdown'
);
t.end();
}, timeoutMs * 1 + 50); // add a 50 ms delay
});
batch.test('should close file after extended timeout', (t) => {
/* checking that the file is closed after a timeout is done by looking at the debug logs
since detecting file locks with node.js is platform specific.
*/
const debugWasEnabled = debug.enabled('log4js:multiFile');
const debugLogs = [];
const originalWrite = process.stderr.write;
process.stderr.write = (string, encoding, fd) => {
debugLogs.push(string);
if (debugWasEnabled) {
originalWrite.apply(process.stderr, [string, encoding, fd]);
}
};
const originalNamespace = debug.disable();
debug.enable(`${originalNamespace}, log4js:multiFile`);
t.teardown(async () => {
await new Promise((resolve) => {
log4js.shutdown(resolve);
});
await removeFiles('logs/D.log');
process.stderr.write = originalWrite;
debug.enable(originalNamespace);
});
const timeoutMs = 200;
log4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'label',
extension: '.log',
timeout: timeoutMs,
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerD = log4js.getLogger('cheese');
loggerD.addContext('label', 'D');
loggerD.info('I am in logger D');
setTimeout(() => {
loggerD.info('extending activity!');
t.match(
debugLogs[debugLogs.length - 1],
'D extending activity',
'should have extended'
);
}, timeoutMs / 2);
setTimeout(() => {
t.notOk(
debugLogs.some(
(s) => s.indexOf(`D not used for > ${timeoutMs} ms => close`) !== -1
),
'(timeout1) should not have closed'
);
}, timeoutMs * 1 + 50); // add a 50 ms delay
setTimeout(() => {
t.match(
debugLogs[debugLogs.length - 1],
`D not used for > ${timeoutMs} ms => close`,
'(timeout2) should have closed'
);
t.end();
}, timeoutMs * 2 + 50); // add a 50 ms delay
});
batch.test('should clear interval for active timers on shutdown', (t) => {
/* checking that the file is closed after a timeout is done by looking at the debug logs
since detecting file locks with node.js is platform specific.
*/
const debugWasEnabled = debug.enabled('log4js:multiFile');
const debugLogs = [];
const originalWrite = process.stderr.write;
process.stderr.write = (string, encoding, fd) => {
debugLogs.push(string);
if (debugWasEnabled) {
originalWrite.apply(process.stderr, [string, encoding, fd]);
}
};
const originalNamespace = debug.disable();
debug.enable(`${originalNamespace}, log4js:multiFile`);
t.teardown(async () => {
await removeFiles('logs/D.log');
process.stderr.write = originalWrite;
debug.enable(originalNamespace);
});
const timeoutMs = 100;
log4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'label',
extension: '.log',
timeout: timeoutMs,
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerD = log4js.getLogger('cheese');
loggerD.addContext('label', 'D');
loggerD.info('I am in logger D');
log4js.shutdown(() => {
t.notOk(
debugLogs.some(
(s) => s.indexOf(`D not used for > ${timeoutMs} ms => close`) !== -1
),
'should not have closed'
);
t.ok(
debugLogs.some((s) => s.indexOf('clearing timer for D') !== -1),
'should have cleared timers'
);
t.match(
debugLogs[debugLogs.length - 1],
'calling shutdown for D',
'should have called shutdown'
);
t.end();
});
});
batch.test(
'should fail silently if loggingEvent property has no value',
(t) => {
t.teardown(async () => {
await removeFiles('logs/E.log');
});
log4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'label',
extension: '.log',
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerE = log4js.getLogger();
loggerE.addContext('label', 'E');
loggerE.info('I am in logger E');
loggerE.removeContext('label');
loggerE.info('I am not in logger E');
loggerE.addContext('label', null);
loggerE.info('I am also not in logger E');
log4js.shutdown(() => {
const contents = fs.readFileSync('logs/E.log', 'utf-8');
t.match(contents, 'I am in logger E');
t.notMatch(contents, 'I am not in logger E');
t.notMatch(contents, 'I am also not in logger E');
t.end();
});
}
);
batch.test('should pass options to rolling file stream', (t) => {
t.teardown(async () => {
await removeFiles(['logs/F.log', 'logs/F.log.1', 'logs/F.log.2']);
});
log4js.configure({
appenders: {
multi: {
type: 'multiFile',
base: 'logs/',
property: 'label',
extension: '.log',
maxLogSize: 30,
backups: 2,
layout: { type: 'messagePassThrough' },
},
},
categories: { default: { appenders: ['multi'], level: 'info' } },
});
const loggerF = log4js.getLogger();
loggerF.addContext('label', 'F');
loggerF.info('Being in logger F is the best.');
loggerF.info('I am also in logger F, awesome');
loggerF.info('I am in logger F');
log4js.shutdown(() => {
let contents = fs.readFileSync('logs/F.log', 'utf-8');
t.match(contents, 'I am in logger F');
contents = fs.readFileSync('logs/F.log.1', 'utf-8');
t.match(contents, 'I am also in logger F');
contents = fs.readFileSync('logs/F.log.2', 'utf-8');
t.match(contents, 'Being in logger F is the best');
t.end();
});
});
batch.test('should inherit config from category hierarchy', (t) => {
t.teardown(async () => {
await removeFiles('logs/test.someTest.log');
});
log4js.configure({
appenders: {
out: { type: 'stdout' },
test: {
type: 'multiFile',
base: 'logs/',
property: 'categoryName',
extension: '.log',
},
},
categories: {
default: { appenders: ['out'], level: 'info' },
test: { appenders: ['test'], level: 'debug' },
},
});
const testLogger = log4js.getLogger('test.someTest');
testLogger.debug('This should go to the file');
log4js.shutdown(() => {
const contents = fs.readFileSync('logs/test.someTest.log', 'utf-8');
t.match(contents, 'This should go to the file');
t.end();
});
});
batch.test('should shutdown safely even if it is not used', (t) => {
log4js.configure({
appenders: {
out: { type: 'stdout' },
test: {
type: 'multiFile',
base: 'logs/',
property: 'categoryName',
extension: '.log',
},
},
categories: {
default: { appenders: ['out'], level: 'info' },
test: { appenders: ['test'], level: 'debug' },
},
});
log4js.shutdown(() => {
t.ok('callback is called');
t.end();
});
});
batch.teardown(async () => {
try {
const files = fs.readdirSync('logs');
await removeFiles(files.map((filename) => `logs/${filename}`));
fs.rmdirSync('logs');
} catch (e) {
// doesn't matter
}
});
batch.end();
});
| 1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./examples/memory-test.js | const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
logs: {
type: 'file',
filename: 'memory-test.log',
},
console: {
type: 'stdout',
},
file: {
type: 'file',
filename: 'memory-usage.log',
layout: {
type: 'messagePassThrough',
},
},
},
categories: {
default: { appenders: ['console'], level: 'info' },
'memory-test': { appenders: ['logs'], level: 'info' },
'memory-usage': { appenders: ['console', 'file'], level: 'info' },
},
});
const logger = log4js.getLogger('memory-test');
const usage = log4js.getLogger('memory-usage');
for (let i = 0; i < 1000000; i += 1) {
if (i % 5000 === 0) {
usage.info('%d %d', i, process.memoryUsage().rss);
}
logger.info('Doing something.');
}
log4js.shutdown(() => {});
| const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
logs: {
type: 'file',
filename: 'memory-test.log',
},
console: {
type: 'stdout',
},
file: {
type: 'file',
filename: 'memory-usage.log',
layout: {
type: 'messagePassThrough',
},
},
},
categories: {
default: { appenders: ['console'], level: 'info' },
'memory-test': { appenders: ['logs'], level: 'info' },
'memory-usage': { appenders: ['console', 'file'], level: 'info' },
},
});
const logger = log4js.getLogger('memory-test');
const usage = log4js.getLogger('memory-usage');
for (let i = 0; i < 1000000; i += 1) {
if (i % 5000 === 0) {
usage.info('%d %d', i, process.memoryUsage().rss);
}
logger.info('Doing something.');
}
log4js.shutdown(() => {});
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./lib/appenders/fileSync.js | const debug = require('debug')('log4js:fileSync');
const path = require('path');
const fs = require('fs');
const os = require('os');
const eol = os.EOL;
function touchFile(file, options) {
// attempt to create the directory
const mkdir = (dir) => {
try {
return fs.mkdirSync(dir, { recursive: true });
} catch (e) {
// backward-compatible fs.mkdirSync for nodejs pre-10.12.0 (without recursive option)
// recursive creation of parent first
if (e.code === 'ENOENT') {
mkdir(path.dirname(dir));
return mkdir(dir);
}
// throw error for all except EEXIST and EROFS (read-only filesystem)
if (e.code !== 'EEXIST' && e.code !== 'EROFS') {
throw e;
}
// EEXIST: throw if file and not directory
// EROFS : throw if directory not found
else {
try {
if (fs.statSync(dir).isDirectory()) {
return dir;
}
throw e;
} catch (err) {
throw e;
}
}
}
};
mkdir(path.dirname(file));
// try to throw EISDIR, EROFS, EACCES
fs.appendFileSync(file, '', { mode: options.mode, flag: options.flags });
}
class RollingFileSync {
constructor(filename, maxLogSize, backups, options) {
debug('In RollingFileStream');
if (maxLogSize < 0) {
throw new Error(`maxLogSize (${maxLogSize}) should be > 0`);
}
this.filename = filename;
this.size = maxLogSize;
this.backups = backups;
this.options = options;
this.currentSize = 0;
function currentFileSize(file) {
let fileSize = 0;
try {
fileSize = fs.statSync(file).size;
} catch (e) {
// file does not exist
touchFile(file, options);
}
return fileSize;
}
this.currentSize = currentFileSize(this.filename);
}
shouldRoll() {
debug(
'should roll with current size %d, and max size %d',
this.currentSize,
this.size
);
return this.currentSize >= this.size;
}
roll(filename) {
const that = this;
const nameMatcher = new RegExp(`^${path.basename(filename)}`);
function justTheseFiles(item) {
return nameMatcher.test(item);
}
function index(filename_) {
return (
parseInt(filename_.slice(`${path.basename(filename)}.`.length), 10) || 0
);
}
function byIndex(a, b) {
return index(a) - index(b);
}
function increaseFileIndex(fileToRename) {
const idx = index(fileToRename);
debug(`Index of ${fileToRename} is ${idx}`);
if (that.backups === 0) {
fs.truncateSync(filename, 0);
} else if (idx < that.backups) {
// on windows, you can get a EEXIST error if you rename a file to an existing file
// so, we'll try to delete the file we're renaming to first
try {
fs.unlinkSync(`${filename}.${idx + 1}`);
} catch (e) {
// ignore err: if we could not delete, it's most likely that it doesn't exist
}
debug(`Renaming ${fileToRename} -> ${filename}.${idx + 1}`);
fs.renameSync(
path.join(path.dirname(filename), fileToRename),
`${filename}.${idx + 1}`
);
}
}
function renameTheFiles() {
// roll the backups (rename file.n to file.n+1, where n <= numBackups)
debug('Renaming the old files');
const files = fs.readdirSync(path.dirname(filename));
files
.filter(justTheseFiles)
.sort(byIndex)
.reverse()
.forEach(increaseFileIndex);
}
debug('Rolling, rolling, rolling');
renameTheFiles();
}
// eslint-disable-next-line no-unused-vars
write(chunk, encoding) {
const that = this;
function writeTheChunk() {
debug('writing the chunk to the file');
that.currentSize += chunk.length;
fs.appendFileSync(that.filename, chunk);
}
debug('in write');
if (this.shouldRoll()) {
this.currentSize = 0;
this.roll(this.filename);
}
writeTheChunk();
}
}
/**
* File Appender writing the logs to a text file. Supports rolling of logs by size.
*
* @param file the file log messages will be written to
* @param layout a function that takes a logevent and returns a string
* (defaults to basicLayout).
* @param logSize - the maximum size (in bytes) for a log file,
* if not provided then logs won't be rotated.
* @param numBackups - the number of log files to keep after logSize
* has been reached (default 5)
* @param options - options to be passed to the underlying stream
* @param timezoneOffset - optional timezone offset in minutes (default system local)
*/
function fileAppender(
file,
layout,
logSize,
numBackups,
options,
timezoneOffset
) {
if (typeof file !== 'string' || file.length === 0) {
throw new Error(`Invalid filename: ${file}`);
} else if (file.endsWith(path.sep)) {
throw new Error(`Filename is a directory: ${file}`);
} else {
// handle ~ expansion: https://github.com/nodejs/node/issues/684
// exclude ~ and ~filename as these can be valid files
file = file.replace(new RegExp(`^~(?=${path.sep}.+)`), os.homedir());
}
file = path.normalize(file);
numBackups = !numBackups && numBackups !== 0 ? 5 : numBackups;
debug(
'Creating fileSync appender (',
file,
', ',
logSize,
', ',
numBackups,
', ',
options,
', ',
timezoneOffset,
')'
);
function openTheStream(filePath, fileSize, numFiles) {
let stream;
if (fileSize) {
stream = new RollingFileSync(filePath, fileSize, numFiles, options);
} else {
stream = ((f) => {
// touch the file to apply flags (like w to truncate the file)
touchFile(f, options);
return {
write(data) {
fs.appendFileSync(f, data);
},
};
})(filePath);
}
return stream;
}
const logFile = openTheStream(file, logSize, numBackups);
return (loggingEvent) => {
logFile.write(layout(loggingEvent, timezoneOffset) + eol);
};
}
function configure(config, layouts) {
let layout = layouts.basicLayout;
if (config.layout) {
layout = layouts.layout(config.layout.type, config.layout);
}
const options = {
flags: config.flags || 'a',
encoding: config.encoding || 'utf8',
mode: config.mode || 0o600,
};
return fileAppender(
config.filename,
layout,
config.maxLogSize,
config.backups,
options,
config.timezoneOffset
);
}
module.exports.configure = configure;
| const debug = require('debug')('log4js:fileSync');
const path = require('path');
const fs = require('fs');
const os = require('os');
const eol = os.EOL;
function touchFile(file, options) {
// attempt to create the directory
const mkdir = (dir) => {
try {
return fs.mkdirSync(dir, { recursive: true });
} catch (e) {
// backward-compatible fs.mkdirSync for nodejs pre-10.12.0 (without recursive option)
// recursive creation of parent first
if (e.code === 'ENOENT') {
mkdir(path.dirname(dir));
return mkdir(dir);
}
// throw error for all except EEXIST and EROFS (read-only filesystem)
if (e.code !== 'EEXIST' && e.code !== 'EROFS') {
throw e;
}
// EEXIST: throw if file and not directory
// EROFS : throw if directory not found
else {
try {
if (fs.statSync(dir).isDirectory()) {
return dir;
}
throw e;
} catch (err) {
throw e;
}
}
}
};
mkdir(path.dirname(file));
// try to throw EISDIR, EROFS, EACCES
fs.appendFileSync(file, '', { mode: options.mode, flag: options.flags });
}
class RollingFileSync {
constructor(filename, maxLogSize, backups, options) {
debug('In RollingFileStream');
if (maxLogSize < 0) {
throw new Error(`maxLogSize (${maxLogSize}) should be > 0`);
}
this.filename = filename;
this.size = maxLogSize;
this.backups = backups;
this.options = options;
this.currentSize = 0;
function currentFileSize(file) {
let fileSize = 0;
try {
fileSize = fs.statSync(file).size;
} catch (e) {
// file does not exist
touchFile(file, options);
}
return fileSize;
}
this.currentSize = currentFileSize(this.filename);
}
shouldRoll() {
debug(
'should roll with current size %d, and max size %d',
this.currentSize,
this.size
);
return this.currentSize >= this.size;
}
roll(filename) {
const that = this;
const nameMatcher = new RegExp(`^${path.basename(filename)}`);
function justTheseFiles(item) {
return nameMatcher.test(item);
}
function index(filename_) {
return (
parseInt(filename_.slice(`${path.basename(filename)}.`.length), 10) || 0
);
}
function byIndex(a, b) {
return index(a) - index(b);
}
function increaseFileIndex(fileToRename) {
const idx = index(fileToRename);
debug(`Index of ${fileToRename} is ${idx}`);
if (that.backups === 0) {
fs.truncateSync(filename, 0);
} else if (idx < that.backups) {
// on windows, you can get a EEXIST error if you rename a file to an existing file
// so, we'll try to delete the file we're renaming to first
try {
fs.unlinkSync(`${filename}.${idx + 1}`);
} catch (e) {
// ignore err: if we could not delete, it's most likely that it doesn't exist
}
debug(`Renaming ${fileToRename} -> ${filename}.${idx + 1}`);
fs.renameSync(
path.join(path.dirname(filename), fileToRename),
`${filename}.${idx + 1}`
);
}
}
function renameTheFiles() {
// roll the backups (rename file.n to file.n+1, where n <= numBackups)
debug('Renaming the old files');
const files = fs.readdirSync(path.dirname(filename));
files
.filter(justTheseFiles)
.sort(byIndex)
.reverse()
.forEach(increaseFileIndex);
}
debug('Rolling, rolling, rolling');
renameTheFiles();
}
// eslint-disable-next-line no-unused-vars
write(chunk, encoding) {
const that = this;
function writeTheChunk() {
debug('writing the chunk to the file');
that.currentSize += chunk.length;
fs.appendFileSync(that.filename, chunk);
}
debug('in write');
if (this.shouldRoll()) {
this.currentSize = 0;
this.roll(this.filename);
}
writeTheChunk();
}
}
/**
* File Appender writing the logs to a text file. Supports rolling of logs by size.
*
* @param file the file log messages will be written to
* @param layout a function that takes a logevent and returns a string
* (defaults to basicLayout).
* @param logSize - the maximum size (in bytes) for a log file,
* if not provided then logs won't be rotated.
* @param numBackups - the number of log files to keep after logSize
* has been reached (default 5)
* @param options - options to be passed to the underlying stream
* @param timezoneOffset - optional timezone offset in minutes (default system local)
*/
function fileAppender(
file,
layout,
logSize,
numBackups,
options,
timezoneOffset
) {
if (typeof file !== 'string' || file.length === 0) {
throw new Error(`Invalid filename: ${file}`);
} else if (file.endsWith(path.sep)) {
throw new Error(`Filename is a directory: ${file}`);
} else {
// handle ~ expansion: https://github.com/nodejs/node/issues/684
// exclude ~ and ~filename as these can be valid files
file = file.replace(new RegExp(`^~(?=${path.sep}.+)`), os.homedir());
}
file = path.normalize(file);
numBackups = !numBackups && numBackups !== 0 ? 5 : numBackups;
debug(
'Creating fileSync appender (',
file,
', ',
logSize,
', ',
numBackups,
', ',
options,
', ',
timezoneOffset,
')'
);
function openTheStream(filePath, fileSize, numFiles) {
let stream;
if (fileSize) {
stream = new RollingFileSync(filePath, fileSize, numFiles, options);
} else {
stream = ((f) => {
// touch the file to apply flags (like w to truncate the file)
touchFile(f, options);
return {
write(data) {
fs.appendFileSync(f, data);
},
};
})(filePath);
}
return stream;
}
const logFile = openTheStream(file, logSize, numBackups);
return (loggingEvent) => {
logFile.write(layout(loggingEvent, timezoneOffset) + eol);
};
}
function configure(config, layouts) {
let layout = layouts.basicLayout;
if (config.layout) {
layout = layouts.layout(config.layout.type, config.layout);
}
const options = {
flags: config.flags || 'a',
encoding: config.encoding || 'utf8',
mode: config.mode || 0o600,
};
return fileAppender(
config.filename,
layout,
config.maxLogSize,
config.backups,
options,
config.timezoneOffset
);
}
module.exports.configure = configure;
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/consoleAppender-test.js | const { test } = require('tap');
const sandbox = require('@log4js-node/sandboxed-module');
const consoleAppender = require('../../lib/appenders/console');
test('log4js console appender', (batch) => {
batch.test('should export a configure function', (t) => {
t.type(consoleAppender.configure, 'function');
t.end();
});
batch.test('should use default layout if none specified', (t) => {
const messages = [];
const fakeConsole = {
log(msg) {
messages.push(msg);
},
};
const log4js = sandbox.require('../../lib/log4js', {
globals: {
console: fakeConsole,
},
});
log4js.configure({
appenders: { console: { type: 'console' } },
categories: { default: { appenders: ['console'], level: 'DEBUG' } },
});
log4js.getLogger().info('blah');
t.match(messages[0], /.*default.*blah/);
t.end();
});
batch.test('should output to console', (t) => {
const messages = [];
const fakeConsole = {
log(msg) {
messages.push(msg);
},
};
const log4js = sandbox.require('../../lib/log4js', {
globals: {
console: fakeConsole,
},
});
log4js.configure({
appenders: {
console: { type: 'console', layout: { type: 'messagePassThrough' } },
},
categories: { default: { appenders: ['console'], level: 'DEBUG' } },
});
log4js.getLogger().info('blah');
t.equal(messages[0], 'blah');
t.end();
});
batch.end();
});
| const { test } = require('tap');
const sandbox = require('@log4js-node/sandboxed-module');
const consoleAppender = require('../../lib/appenders/console');
test('log4js console appender', (batch) => {
batch.test('should export a configure function', (t) => {
t.type(consoleAppender.configure, 'function');
t.end();
});
batch.test('should use default layout if none specified', (t) => {
const messages = [];
const fakeConsole = {
log(msg) {
messages.push(msg);
},
};
const log4js = sandbox.require('../../lib/log4js', {
globals: {
console: fakeConsole,
},
});
log4js.configure({
appenders: { console: { type: 'console' } },
categories: { default: { appenders: ['console'], level: 'DEBUG' } },
});
log4js.getLogger().info('blah');
t.match(messages[0], /.*default.*blah/);
t.end();
});
batch.test('should output to console', (t) => {
const messages = [];
const fakeConsole = {
log(msg) {
messages.push(msg);
},
};
const log4js = sandbox.require('../../lib/log4js', {
globals: {
console: fakeConsole,
},
});
log4js.configure({
appenders: {
console: { type: 'console', layout: { type: 'messagePassThrough' } },
},
categories: { default: { appenders: ['console'], level: 'DEBUG' } },
});
log4js.getLogger().info('blah');
t.equal(messages[0], 'blah');
t.end();
});
batch.end();
});
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./lib/appenders/categoryFilter.js | const debug = require('debug')('log4js:categoryFilter');
function categoryFilter(excludes, appender) {
if (typeof excludes === 'string') excludes = [excludes];
return (logEvent) => {
debug(`Checking ${logEvent.categoryName} against ${excludes}`);
if (excludes.indexOf(logEvent.categoryName) === -1) {
debug('Not excluded, sending to appender');
appender(logEvent);
}
};
}
function configure(config, layouts, findAppender) {
const appender = findAppender(config.appender);
return categoryFilter(config.exclude, appender);
}
module.exports.configure = configure;
| const debug = require('debug')('log4js:categoryFilter');
function categoryFilter(excludes, appender) {
if (typeof excludes === 'string') excludes = [excludes];
return (logEvent) => {
debug(`Checking ${logEvent.categoryName} against ${excludes}`);
if (excludes.indexOf(logEvent.categoryName) === -1) {
debug('Not excluded, sending to appender');
appender(logEvent);
}
};
}
function configure(config, layouts, findAppender) {
const appender = findAppender(config.appender);
return categoryFilter(config.exclude, appender);
}
module.exports.configure = configure;
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/newLevel-test.js | const { test } = require('tap');
const log4js = require('../../lib/log4js');
const recording = require('../../lib/appenders/recording');
test('../../lib/logger', (batch) => {
batch.beforeEach((done) => {
recording.reset();
if (typeof done === 'function') {
done();
}
});
batch.test('creating a new log level', (t) => {
log4js.configure({
levels: {
DIAG: { value: 6000, colour: 'green' },
},
appenders: {
stdout: { type: 'stdout' },
},
categories: {
default: { appenders: ['stdout'], level: 'trace' },
},
});
const logger = log4js.getLogger();
t.test('should export new log level in levels module', (assert) => {
assert.ok(log4js.levels.DIAG);
assert.equal(log4js.levels.DIAG.levelStr, 'DIAG');
assert.equal(log4js.levels.DIAG.level, 6000);
assert.equal(log4js.levels.DIAG.colour, 'green');
assert.end();
});
t.type(
logger.diag,
'function',
'should create named function on logger prototype'
);
t.type(
logger.isDiagEnabled,
'function',
'should create isLevelEnabled function on logger prototype'
);
t.type(logger.info, 'function', 'should retain default levels');
t.end();
});
batch.test('creating a new log level with underscores', (t) => {
log4js.configure({
levels: {
NEW_LEVEL_OTHER: { value: 6000, colour: 'blue' },
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
const logger = log4js.getLogger();
t.test('should export new log level to levels module', (assert) => {
assert.ok(log4js.levels.NEW_LEVEL_OTHER);
assert.equal(log4js.levels.NEW_LEVEL_OTHER.levelStr, 'NEW_LEVEL_OTHER');
assert.equal(log4js.levels.NEW_LEVEL_OTHER.level, 6000);
assert.equal(log4js.levels.NEW_LEVEL_OTHER.colour, 'blue');
assert.end();
});
t.type(
logger.newLevelOther,
'function',
'should create named function on logger prototype in camel case'
);
t.type(
logger.isNewLevelOtherEnabled,
'function',
'should create named isLevelEnabled function on logger prototype in camel case'
);
t.end();
});
batch.test('creating log events containing newly created log level', (t) => {
log4js.configure({
levels: {
LVL1: { value: 6000, colour: 'grey' },
LVL2: { value: 5000, colour: 'magenta' },
},
appenders: { recorder: { type: 'recording' } },
categories: {
default: { appenders: ['recorder'], level: 'LVL1' },
},
});
const logger = log4js.getLogger();
logger.log(log4js.levels.getLevel('LVL1', log4js.levels.DEBUG), 'Event 1');
logger.log(log4js.levels.getLevel('LVL1'), 'Event 2');
logger.log('LVL1', 'Event 3');
logger.lvl1('Event 4');
logger.lvl2('Event 5');
const events = recording.replay();
t.test('should show log events with new log level', (assert) => {
assert.equal(events[0].level.toString(), 'LVL1');
assert.equal(events[0].data[0], 'Event 1');
assert.equal(events[1].level.toString(), 'LVL1');
assert.equal(events[1].data[0], 'Event 2');
assert.equal(events[2].level.toString(), 'LVL1');
assert.equal(events[2].data[0], 'Event 3');
assert.equal(events[3].level.toString(), 'LVL1');
assert.equal(events[3].data[0], 'Event 4');
assert.end();
});
t.equal(
events.length,
4,
'should not be present if min log level is greater than newly created level'
);
t.end();
});
batch.test('creating a new log level with incorrect parameters', (t) => {
t.throws(() => {
log4js.configure({
levels: {
cheese: { value: 'biscuits' },
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level "cheese".value must have an integer value');
t.throws(() => {
log4js.configure({
levels: {
cheese: 'biscuits',
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level "cheese" must be an object');
t.throws(() => {
log4js.configure({
levels: {
cheese: { thing: 'biscuits' },
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level "cheese" must have a \'value\' property');
t.throws(() => {
log4js.configure({
levels: {
cheese: { value: 3 },
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level "cheese" must have a \'colour\' property');
t.throws(() => {
log4js.configure({
levels: {
cheese: { value: 3, colour: 'pants' },
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level "cheese".colour must be one of white, grey, black, blue, cyan, green, magenta, red, yellow');
t.throws(() => {
log4js.configure({
levels: {
'#pants': 3,
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level name "#pants" is not a valid identifier (must start with a letter, only contain A-Z,a-z,0-9,_)');
t.throws(() => {
log4js.configure({
levels: {
'thing#pants': 3,
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level name "thing#pants" is not a valid identifier (must start with a letter, only contain A-Z,a-z,0-9,_)');
t.throws(() => {
log4js.configure({
levels: {
'1pants': 3,
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level name "1pants" is not a valid identifier (must start with a letter, only contain A-Z,a-z,0-9,_)');
t.throws(() => {
log4js.configure({
levels: {
2: 3,
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level name "2" is not a valid identifier (must start with a letter, only contain A-Z,a-z,0-9,_)');
t.throws(() => {
log4js.configure({
levels: {
'cheese!': 3,
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level name "cheese!" is not a valid identifier (must start with a letter, only contain A-Z,a-z,0-9,_)');
t.end();
});
batch.test('calling log with an undefined log level', (t) => {
log4js.configure({
appenders: { recorder: { type: 'recording' } },
categories: { default: { appenders: ['recorder'], level: 'trace' } },
});
const logger = log4js.getLogger();
// fallback behavior
logger.log('LEVEL_DOES_NOT_EXIST', 'Event 1');
logger.log(
log4js.levels.getLevel('LEVEL_DOES_NOT_EXIST'),
'Event 2',
'2 Text'
);
// synonym behavior
logger.log('Event 3');
logger.log('Event 4', '4 Text');
const events = recording.replay();
t.equal(events[0].level.toString(), 'WARN', 'should log warning');
t.equal(
events[0].data[0],
'log4js:logger.log: valid log-level not found as first parameter given:'
);
t.equal(events[0].data[1], 'LEVEL_DOES_NOT_EXIST');
t.equal(events[1].level.toString(), 'INFO', 'should fall back to INFO');
t.equal(events[1].data[0], '[LEVEL_DOES_NOT_EXIST]');
t.equal(events[1].data[1], 'Event 1');
t.equal(events[2].level.toString(), 'WARN', 'should log warning');
t.equal(
events[2].data[0],
'log4js:logger.log: valid log-level not found as first parameter given:'
);
t.equal(events[2].data[1], undefined);
t.equal(events[3].level.toString(), 'INFO', 'should fall back to INFO');
t.equal(events[3].data[0], '[undefined]');
t.equal(events[3].data[1], 'Event 2');
t.equal(events[3].data[2], '2 Text');
t.equal(events[4].level.toString(), 'INFO', 'LOG is synonym of INFO');
t.equal(events[4].data[0], 'Event 3');
t.equal(events[5].level.toString(), 'INFO', 'LOG is synonym of INFO');
t.equal(events[5].data[0], 'Event 4');
t.equal(events[5].data[1], '4 Text');
t.end();
});
batch.test('creating a new level with an existing level name', (t) => {
log4js.configure({
levels: {
info: { value: 1234, colour: 'blue' },
},
appenders: { recorder: { type: 'recording' } },
categories: { default: { appenders: ['recorder'], level: 'all' } },
});
t.equal(
log4js.levels.INFO.level,
1234,
'should override the existing log level'
);
t.equal(
log4js.levels.INFO.colour,
'blue',
'should override the existing log level'
);
const logger = log4js.getLogger();
logger.info('test message');
const events = recording.replay();
t.equal(
events[0].level.level,
1234,
'should override the existing log level'
);
t.end();
});
batch.end();
});
| const { test } = require('tap');
const log4js = require('../../lib/log4js');
const recording = require('../../lib/appenders/recording');
test('../../lib/logger', (batch) => {
batch.beforeEach((done) => {
recording.reset();
if (typeof done === 'function') {
done();
}
});
batch.test('creating a new log level', (t) => {
log4js.configure({
levels: {
DIAG: { value: 6000, colour: 'green' },
},
appenders: {
stdout: { type: 'stdout' },
},
categories: {
default: { appenders: ['stdout'], level: 'trace' },
},
});
const logger = log4js.getLogger();
t.test('should export new log level in levels module', (assert) => {
assert.ok(log4js.levels.DIAG);
assert.equal(log4js.levels.DIAG.levelStr, 'DIAG');
assert.equal(log4js.levels.DIAG.level, 6000);
assert.equal(log4js.levels.DIAG.colour, 'green');
assert.end();
});
t.type(
logger.diag,
'function',
'should create named function on logger prototype'
);
t.type(
logger.isDiagEnabled,
'function',
'should create isLevelEnabled function on logger prototype'
);
t.type(logger.info, 'function', 'should retain default levels');
t.end();
});
batch.test('creating a new log level with underscores', (t) => {
log4js.configure({
levels: {
NEW_LEVEL_OTHER: { value: 6000, colour: 'blue' },
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
const logger = log4js.getLogger();
t.test('should export new log level to levels module', (assert) => {
assert.ok(log4js.levels.NEW_LEVEL_OTHER);
assert.equal(log4js.levels.NEW_LEVEL_OTHER.levelStr, 'NEW_LEVEL_OTHER');
assert.equal(log4js.levels.NEW_LEVEL_OTHER.level, 6000);
assert.equal(log4js.levels.NEW_LEVEL_OTHER.colour, 'blue');
assert.end();
});
t.type(
logger.newLevelOther,
'function',
'should create named function on logger prototype in camel case'
);
t.type(
logger.isNewLevelOtherEnabled,
'function',
'should create named isLevelEnabled function on logger prototype in camel case'
);
t.end();
});
batch.test('creating log events containing newly created log level', (t) => {
log4js.configure({
levels: {
LVL1: { value: 6000, colour: 'grey' },
LVL2: { value: 5000, colour: 'magenta' },
},
appenders: { recorder: { type: 'recording' } },
categories: {
default: { appenders: ['recorder'], level: 'LVL1' },
},
});
const logger = log4js.getLogger();
logger.log(log4js.levels.getLevel('LVL1', log4js.levels.DEBUG), 'Event 1');
logger.log(log4js.levels.getLevel('LVL1'), 'Event 2');
logger.log('LVL1', 'Event 3');
logger.lvl1('Event 4');
logger.lvl2('Event 5');
const events = recording.replay();
t.test('should show log events with new log level', (assert) => {
assert.equal(events[0].level.toString(), 'LVL1');
assert.equal(events[0].data[0], 'Event 1');
assert.equal(events[1].level.toString(), 'LVL1');
assert.equal(events[1].data[0], 'Event 2');
assert.equal(events[2].level.toString(), 'LVL1');
assert.equal(events[2].data[0], 'Event 3');
assert.equal(events[3].level.toString(), 'LVL1');
assert.equal(events[3].data[0], 'Event 4');
assert.end();
});
t.equal(
events.length,
4,
'should not be present if min log level is greater than newly created level'
);
t.end();
});
batch.test('creating a new log level with incorrect parameters', (t) => {
t.throws(() => {
log4js.configure({
levels: {
cheese: { value: 'biscuits' },
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level "cheese".value must have an integer value');
t.throws(() => {
log4js.configure({
levels: {
cheese: 'biscuits',
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level "cheese" must be an object');
t.throws(() => {
log4js.configure({
levels: {
cheese: { thing: 'biscuits' },
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level "cheese" must have a \'value\' property');
t.throws(() => {
log4js.configure({
levels: {
cheese: { value: 3 },
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level "cheese" must have a \'colour\' property');
t.throws(() => {
log4js.configure({
levels: {
cheese: { value: 3, colour: 'pants' },
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level "cheese".colour must be one of white, grey, black, blue, cyan, green, magenta, red, yellow');
t.throws(() => {
log4js.configure({
levels: {
'#pants': 3,
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level name "#pants" is not a valid identifier (must start with a letter, only contain A-Z,a-z,0-9,_)');
t.throws(() => {
log4js.configure({
levels: {
'thing#pants': 3,
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level name "thing#pants" is not a valid identifier (must start with a letter, only contain A-Z,a-z,0-9,_)');
t.throws(() => {
log4js.configure({
levels: {
'1pants': 3,
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level name "1pants" is not a valid identifier (must start with a letter, only contain A-Z,a-z,0-9,_)');
t.throws(() => {
log4js.configure({
levels: {
2: 3,
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level name "2" is not a valid identifier (must start with a letter, only contain A-Z,a-z,0-9,_)');
t.throws(() => {
log4js.configure({
levels: {
'cheese!': 3,
},
appenders: { stdout: { type: 'stdout' } },
categories: { default: { appenders: ['stdout'], level: 'trace' } },
});
}, 'level name "cheese!" is not a valid identifier (must start with a letter, only contain A-Z,a-z,0-9,_)');
t.end();
});
batch.test('calling log with an undefined log level', (t) => {
log4js.configure({
appenders: { recorder: { type: 'recording' } },
categories: { default: { appenders: ['recorder'], level: 'trace' } },
});
const logger = log4js.getLogger();
// fallback behavior
logger.log('LEVEL_DOES_NOT_EXIST', 'Event 1');
logger.log(
log4js.levels.getLevel('LEVEL_DOES_NOT_EXIST'),
'Event 2',
'2 Text'
);
// synonym behavior
logger.log('Event 3');
logger.log('Event 4', '4 Text');
const events = recording.replay();
t.equal(events[0].level.toString(), 'WARN', 'should log warning');
t.equal(
events[0].data[0],
'log4js:logger.log: valid log-level not found as first parameter given:'
);
t.equal(events[0].data[1], 'LEVEL_DOES_NOT_EXIST');
t.equal(events[1].level.toString(), 'INFO', 'should fall back to INFO');
t.equal(events[1].data[0], '[LEVEL_DOES_NOT_EXIST]');
t.equal(events[1].data[1], 'Event 1');
t.equal(events[2].level.toString(), 'WARN', 'should log warning');
t.equal(
events[2].data[0],
'log4js:logger.log: valid log-level not found as first parameter given:'
);
t.equal(events[2].data[1], undefined);
t.equal(events[3].level.toString(), 'INFO', 'should fall back to INFO');
t.equal(events[3].data[0], '[undefined]');
t.equal(events[3].data[1], 'Event 2');
t.equal(events[3].data[2], '2 Text');
t.equal(events[4].level.toString(), 'INFO', 'LOG is synonym of INFO');
t.equal(events[4].data[0], 'Event 3');
t.equal(events[5].level.toString(), 'INFO', 'LOG is synonym of INFO');
t.equal(events[5].data[0], 'Event 4');
t.equal(events[5].data[1], '4 Text');
t.end();
});
batch.test('creating a new level with an existing level name', (t) => {
log4js.configure({
levels: {
info: { value: 1234, colour: 'blue' },
},
appenders: { recorder: { type: 'recording' } },
categories: { default: { appenders: ['recorder'], level: 'all' } },
});
t.equal(
log4js.levels.INFO.level,
1234,
'should override the existing log level'
);
t.equal(
log4js.levels.INFO.colour,
'blue',
'should override the existing log level'
);
const logger = log4js.getLogger();
logger.info('test message');
const events = recording.replay();
t.equal(
events[0].level.level,
1234,
'should override the existing log level'
);
t.end();
});
batch.end();
});
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/multiprocess-worker.js | if (process.argv.indexOf('start-multiprocess-worker') >= 0) {
const log4js = require('../lib/log4js');
const port = parseInt(process.argv[process.argv.length - 1], 10);
log4js.configure({
appenders: {
multi: { type: 'multiprocess', mode: 'worker', loggerPort: port },
},
categories: { default: { appenders: ['multi'], level: 'debug' } },
});
log4js.getLogger('worker').info('Logging from worker');
log4js.shutdown(() => {
process.send('worker is done');
});
}
| if (process.argv.indexOf('start-multiprocess-worker') >= 0) {
const log4js = require('../lib/log4js');
const port = parseInt(process.argv[process.argv.length - 1], 10);
log4js.configure({
appenders: {
multi: { type: 'multiprocess', mode: 'worker', loggerPort: port },
},
categories: { default: { appenders: ['multi'], level: 'debug' } },
});
log4js.getLogger('worker').info('Logging from worker');
log4js.shutdown(() => {
process.send('worker is done');
});
}
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./examples/smtp-appender.js | // Note that smtp appender needs nodemailer to work.
// If you haven't got nodemailer installed, you'll get cryptic
// "cannot find module" errors when using the smtp appender
const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
out: {
type: 'console',
},
mail: {
type: '@log4js-node/smtp',
recipients: 'logfilerecipient@logging.com',
sendInterval: 5,
transport: 'SMTP',
SMTP: {
host: 'smtp.gmail.com',
secureConnection: true,
port: 465,
auth: {
user: 'someone@gmail',
pass: '********************',
},
debug: true,
},
},
},
categories: {
default: { appenders: ['out'], level: 'info' },
mailer: { appenders: ['mail'], level: 'info' },
},
});
const log = log4js.getLogger('test');
const logmailer = log4js.getLogger('mailer');
function doTheLogging(x) {
log.info('Logging something %d', x);
logmailer.info('Logging something %d', x);
}
for (let i = 0; i < 500; i += 1) {
doTheLogging(i);
}
| // Note that smtp appender needs nodemailer to work.
// If you haven't got nodemailer installed, you'll get cryptic
// "cannot find module" errors when using the smtp appender
const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
out: {
type: 'console',
},
mail: {
type: '@log4js-node/smtp',
recipients: 'logfilerecipient@logging.com',
sendInterval: 5,
transport: 'SMTP',
SMTP: {
host: 'smtp.gmail.com',
secureConnection: true,
port: 465,
auth: {
user: 'someone@gmail',
pass: '********************',
},
debug: true,
},
},
},
categories: {
default: { appenders: ['out'], level: 'info' },
mailer: { appenders: ['mail'], level: 'info' },
},
});
const log = log4js.getLogger('test');
const logmailer = log4js.getLogger('mailer');
function doTheLogging(x) {
log.info('Logging something %d', x);
logmailer.info('Logging something %d', x);
}
for (let i = 0; i < 500; i += 1) {
doTheLogging(i);
}
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./examples/example-socket.js | const log4js = require('../lib/log4js');
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;
let i = 0;
if (cluster.isMaster) {
log4js.configure({
appenders: {
console: { type: 'console' },
master: {
type: 'multiprocess',
mode: 'master',
appender: 'console',
},
},
categories: {
default: { appenders: ['console'], level: 'info' },
},
});
console.info('Master creating %d workers', numCPUs);
for (i = 0; i < numCPUs; i++) {
cluster.fork();
}
cluster.on('death', (worker) => {
console.info('Worker %d died.', worker.pid);
});
} else {
log4js.configure({
appenders: {
worker: { type: 'multiprocess', mode: 'worker' },
},
categories: {
default: { appenders: ['worker'], level: 'info' },
},
});
const logger = log4js.getLogger('example-socket');
console.info('Worker %d started.', process.pid);
for (i = 0; i < 1000; i++) {
logger.info('Worker %d - logging something %d', process.pid, i);
}
log4js.shutdown(() => {
process.exit();
});
}
| const log4js = require('../lib/log4js');
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;
let i = 0;
if (cluster.isMaster) {
log4js.configure({
appenders: {
console: { type: 'console' },
master: {
type: 'multiprocess',
mode: 'master',
appender: 'console',
},
},
categories: {
default: { appenders: ['console'], level: 'info' },
},
});
console.info('Master creating %d workers', numCPUs);
for (i = 0; i < numCPUs; i++) {
cluster.fork();
}
cluster.on('death', (worker) => {
console.info('Worker %d died.', worker.pid);
});
} else {
log4js.configure({
appenders: {
worker: { type: 'multiprocess', mode: 'worker' },
},
categories: {
default: { appenders: ['worker'], level: 'info' },
},
});
const logger = log4js.getLogger('example-socket');
console.info('Worker %d started.', process.pid);
for (i = 0; i < 1000; i++) {
logger.info('Worker %d - logging something %d', process.pid, i);
}
log4js.shutdown(() => {
process.exit();
});
}
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/connect-context-test.js | /* eslint max-classes-per-file: ["error", 2] */
const { test } = require('tap');
const EE = require('events').EventEmitter;
const levels = require('../../lib/levels');
class MockLogger {
constructor() {
this.level = levels.TRACE;
this.context = {};
this.contexts = [];
}
log() {
this.contexts.push(Object.assign({}, this.context)); // eslint-disable-line prefer-object-spread
}
isLevelEnabled(level) {
return level.isGreaterThanOrEqualTo(this.level);
}
addContext(key, value) {
this.context[key] = value;
}
removeContext(key) {
delete this.context[key];
}
}
function MockRequest(remoteAddr, method, originalUrl) {
this.socket = { remoteAddress: remoteAddr };
this.originalUrl = originalUrl;
this.method = method;
this.httpVersionMajor = '5';
this.httpVersionMinor = '0';
this.headers = {};
}
class MockResponse extends EE {
constructor(code) {
super();
this.statusCode = code;
this.cachedHeaders = {};
}
end() {
this.emit('finish');
}
setHeader(key, value) {
this.cachedHeaders[key.toLowerCase()] = value;
}
getHeader(key) {
return this.cachedHeaders[key.toLowerCase()];
}
writeHead(code /* , headers */) {
this.statusCode = code;
}
}
test('log4js connect logger', (batch) => {
const clm = require('../../lib/connect-logger');
batch.test('with context config', (t) => {
const ml = new MockLogger();
const cl = clm(ml, { context: true });
t.beforeEach((done) => {
ml.contexts = [];
if (typeof done === 'function') {
done();
}
});
t.test('response should be included in context', (assert) => {
const { contexts } = ml;
const req = new MockRequest(
'my.remote.addr',
'GET',
'http://url/hoge.png'
); // not gif
const res = new MockResponse(200);
cl(req, res, () => {});
res.end('chunk', 'encoding');
assert.type(contexts, 'Array');
assert.equal(contexts.length, 1);
assert.type(contexts[0].res, MockResponse);
assert.end();
});
t.end();
});
batch.test('without context config', (t) => {
const ml = new MockLogger();
const cl = clm(ml, {});
t.beforeEach((done) => {
ml.contexts = [];
if (typeof done === 'function') {
done();
}
});
t.test('response should not be included in context', (assert) => {
const { contexts } = ml;
const req = new MockRequest(
'my.remote.addr',
'GET',
'http://url/hoge.png'
); // not gif
const res = new MockResponse(200);
cl(req, res, () => {});
res.end('chunk', 'encoding');
assert.type(contexts, 'Array');
assert.equal(contexts.length, 1);
assert.type(contexts[0].res, undefined);
assert.end();
});
t.end();
});
batch.end();
});
| /* eslint max-classes-per-file: ["error", 2] */
const { test } = require('tap');
const EE = require('events').EventEmitter;
const levels = require('../../lib/levels');
class MockLogger {
constructor() {
this.level = levels.TRACE;
this.context = {};
this.contexts = [];
}
log() {
this.contexts.push(Object.assign({}, this.context)); // eslint-disable-line prefer-object-spread
}
isLevelEnabled(level) {
return level.isGreaterThanOrEqualTo(this.level);
}
addContext(key, value) {
this.context[key] = value;
}
removeContext(key) {
delete this.context[key];
}
}
function MockRequest(remoteAddr, method, originalUrl) {
this.socket = { remoteAddress: remoteAddr };
this.originalUrl = originalUrl;
this.method = method;
this.httpVersionMajor = '5';
this.httpVersionMinor = '0';
this.headers = {};
}
class MockResponse extends EE {
constructor(code) {
super();
this.statusCode = code;
this.cachedHeaders = {};
}
end() {
this.emit('finish');
}
setHeader(key, value) {
this.cachedHeaders[key.toLowerCase()] = value;
}
getHeader(key) {
return this.cachedHeaders[key.toLowerCase()];
}
writeHead(code /* , headers */) {
this.statusCode = code;
}
}
test('log4js connect logger', (batch) => {
const clm = require('../../lib/connect-logger');
batch.test('with context config', (t) => {
const ml = new MockLogger();
const cl = clm(ml, { context: true });
t.beforeEach((done) => {
ml.contexts = [];
if (typeof done === 'function') {
done();
}
});
t.test('response should be included in context', (assert) => {
const { contexts } = ml;
const req = new MockRequest(
'my.remote.addr',
'GET',
'http://url/hoge.png'
); // not gif
const res = new MockResponse(200);
cl(req, res, () => {});
res.end('chunk', 'encoding');
assert.type(contexts, 'Array');
assert.equal(contexts.length, 1);
assert.type(contexts[0].res, MockResponse);
assert.end();
});
t.end();
});
batch.test('without context config', (t) => {
const ml = new MockLogger();
const cl = clm(ml, {});
t.beforeEach((done) => {
ml.contexts = [];
if (typeof done === 'function') {
done();
}
});
t.test('response should not be included in context', (assert) => {
const { contexts } = ml;
const req = new MockRequest(
'my.remote.addr',
'GET',
'http://url/hoge.png'
); // not gif
const res = new MockResponse(200);
cl(req, res, () => {});
res.end('chunk', 'encoding');
assert.type(contexts, 'Array');
assert.equal(contexts.length, 1);
assert.type(contexts[0].res, undefined);
assert.end();
});
t.end();
});
batch.end();
});
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/tcp-appender-test.js | const { test } = require('tap');
const net = require('net');
const flatted = require('flatted');
const sandbox = require('@log4js-node/sandboxed-module');
const log4js = require('../../lib/log4js');
const LoggingEvent = require('../../lib/LoggingEvent');
let messages = [];
let server = null;
function makeServer(config) {
server = net.createServer((socket) => {
socket.setEncoding('utf8');
socket.on('data', (data) => {
data
.split(config.endMsg)
.filter((s) => s.length)
.forEach((s) => {
messages.push(config.deserialise(s));
});
});
});
server.unref();
return server;
}
function makeFakeNet() {
return {
data: [],
cbs: {},
createConnectionCalled: 0,
createConnection(port, host) {
const fakeNet = this;
this.port = port;
this.host = host;
this.createConnectionCalled += 1;
return {
on(evt, cb) {
fakeNet.cbs[evt] = cb;
},
write(data, encoding) {
fakeNet.data.push(data);
fakeNet.encoding = encoding;
return false;
},
end() {
fakeNet.closeCalled = true;
},
};
},
createServer(cb) {
const fakeNet = this;
cb({
remoteAddress: '1.2.3.4',
remotePort: '1234',
setEncoding(encoding) {
fakeNet.encoding = encoding;
},
on(event, cb2) {
fakeNet.cbs[event] = cb2;
},
});
return {
listen(port, host) {
fakeNet.port = port;
fakeNet.host = host;
},
};
},
};
}
test('TCP Appender', (batch) => {
batch.test('Default Configuration', (t) => {
messages = [];
const serverConfig = {
endMsg: '__LOG4JS__',
deserialise: (log) => LoggingEvent.deserialise(log),
};
server = makeServer(serverConfig);
server.listen(() => {
const { port } = server.address();
log4js.configure({
appenders: {
default: { type: 'tcp', port },
},
categories: {
default: { appenders: ['default'], level: 'debug' },
},
});
const logger = log4js.getLogger();
logger.info('This should be sent via TCP.');
logger.info('This should also be sent via TCP and not break things.');
log4js.shutdown(() => {
server.close(() => {
t.equal(messages.length, 2);
t.match(messages[0], {
data: ['This should be sent via TCP.'],
categoryName: 'default',
context: {},
level: { levelStr: 'INFO' },
});
t.match(messages[1], {
data: ['This should also be sent via TCP and not break things.'],
categoryName: 'default',
context: {},
level: { levelStr: 'INFO' },
});
t.end();
});
});
});
});
batch.test('Custom EndMessage String', (t) => {
messages = [];
const serverConfig = {
endMsg: '\n',
deserialise: (log) => LoggingEvent.deserialise(log),
};
server = makeServer(serverConfig);
server.listen(() => {
const { port } = server.address();
log4js.configure({
appenders: {
customEndMsg: { type: 'tcp', port, endMsg: '\n' },
},
categories: {
default: { appenders: ['customEndMsg'], level: 'debug' },
},
});
const logger = log4js.getLogger();
logger.info('This should be sent via TCP using a custom EndMsg string.');
logger.info(
'This should also be sent via TCP using a custom EndMsg string and not break things.'
);
log4js.shutdown(() => {
server.close(() => {
t.equal(messages.length, 2);
t.match(messages[0], {
data: ['This should be sent via TCP using a custom EndMsg string.'],
categoryName: 'default',
context: {},
level: { levelStr: 'INFO' },
});
t.match(messages[1], {
data: [
'This should also be sent via TCP using a custom EndMsg string and not break things.',
],
categoryName: 'default',
context: {},
level: { levelStr: 'INFO' },
});
t.end();
});
});
});
});
batch.test('Custom Layout', (t) => {
messages = [];
const serverConfig = {
endMsg: '__LOG4JS__',
deserialise: (log) => JSON.parse(log),
};
server = makeServer(serverConfig);
log4js.addLayout(
'json',
() =>
function(logEvent) {
return JSON.stringify({
time: logEvent.startTime,
message: logEvent.data[0],
level: logEvent.level.toString(),
});
}
);
server.listen(() => {
const { port } = server.address();
log4js.configure({
appenders: {
customLayout: {
type: 'tcp',
port,
layout: { type: 'json' },
},
},
categories: {
default: { appenders: ['customLayout'], level: 'debug' },
},
});
const logger = log4js.getLogger();
logger.info('This should be sent as a customized json.');
logger.info(
'This should also be sent via TCP as a customized json and not break things.'
);
log4js.shutdown(() => {
server.close(() => {
t.equal(messages.length, 2);
t.match(messages[0], {
message: 'This should be sent as a customized json.',
level: 'INFO',
});
t.match(messages[1], {
message:
'This should also be sent via TCP as a customized json and not break things.',
level: 'INFO',
});
t.end();
});
});
});
});
batch.test('when underlying stream errors', (t) => {
const fakeNet = makeFakeNet();
const sandboxedLog4js = sandbox.require('../../lib/log4js', {
requires: {
net: fakeNet,
},
});
sandboxedLog4js.configure({
appenders: {
default: { type: 'tcp' },
},
categories: {
default: { appenders: ['default'], level: 'debug' },
},
});
const logger = sandboxedLog4js.getLogger();
logger.info('before connect');
t.test(
'should buffer messages written before socket is connected',
(assert) => {
assert.equal(fakeNet.data.length, 0);
assert.equal(fakeNet.createConnectionCalled, 1);
assert.end();
}
);
fakeNet.cbs.connect();
t.test('should flush buffered messages', (assert) => {
assert.equal(fakeNet.data.length, 1);
assert.equal(fakeNet.createConnectionCalled, 1);
assert.match(fakeNet.data[0], 'before connect');
assert.end();
});
logger.info('after connect');
t.test(
'should write log messages to socket as flatted strings with a terminator string',
(assert) => {
assert.equal(fakeNet.data.length, 2);
assert.match(fakeNet.data[0], 'before connect');
assert.ok(fakeNet.data[0].endsWith('__LOG4JS__'));
assert.match(fakeNet.data[1], 'after connect');
assert.ok(fakeNet.data[1].endsWith('__LOG4JS__'));
assert.equal(fakeNet.encoding, 'utf8');
assert.end();
}
);
fakeNet.cbs.error();
logger.info('after error, before close');
fakeNet.cbs.close();
logger.info('after close, before connect');
fakeNet.cbs.connect();
logger.info('after error, after connect');
t.test('should attempt to re-open the socket on error', (assert) => {
assert.equal(fakeNet.data.length, 5);
assert.equal(fakeNet.createConnectionCalled, 2);
assert.match(fakeNet.data[2], 'after error, before close');
assert.match(fakeNet.data[3], 'after close, before connect');
assert.match(fakeNet.data[4], 'after error, after connect');
assert.end();
});
t.test('should buffer messages until drain', (assert) => {
const previousLength = fakeNet.data.length;
logger.info('should not be flushed');
assert.equal(fakeNet.data.length, previousLength);
assert.notMatch(
fakeNet.data[fakeNet.data.length - 1],
'should not be flushed'
);
fakeNet.cbs.drain();
assert.equal(fakeNet.data.length, previousLength + 1);
assert.match(
fakeNet.data[fakeNet.data.length - 1],
'should not be flushed'
);
assert.end();
});
t.test('should serialize an Error correctly', (assert) => {
const previousLength = fakeNet.data.length;
logger.error(new Error('Error test'));
fakeNet.cbs.drain();
assert.equal(fakeNet.data.length, previousLength + 1);
const raw = fakeNet.data[fakeNet.data.length - 1];
const offset = raw.indexOf('__LOG4JS__');
assert.ok(
flatted.parse(raw.slice(0, offset !== -1 ? offset : 0)).data[0].stack,
`Expected:\n\n${fakeNet.data[6]}\n\n to have a 'data[0].stack' property`
);
const actual = flatted.parse(raw.slice(0, offset !== -1 ? offset : 0))
.data[0].stack;
assert.match(actual, /^Error: Error test/);
assert.end();
});
t.end();
});
batch.end();
});
| const { test } = require('tap');
const net = require('net');
const flatted = require('flatted');
const sandbox = require('@log4js-node/sandboxed-module');
const log4js = require('../../lib/log4js');
const LoggingEvent = require('../../lib/LoggingEvent');
let messages = [];
let server = null;
function makeServer(config) {
server = net.createServer((socket) => {
socket.setEncoding('utf8');
socket.on('data', (data) => {
data
.split(config.endMsg)
.filter((s) => s.length)
.forEach((s) => {
messages.push(config.deserialise(s));
});
});
});
server.unref();
return server;
}
function makeFakeNet() {
return {
data: [],
cbs: {},
createConnectionCalled: 0,
createConnection(port, host) {
const fakeNet = this;
this.port = port;
this.host = host;
this.createConnectionCalled += 1;
return {
on(evt, cb) {
fakeNet.cbs[evt] = cb;
},
write(data, encoding) {
fakeNet.data.push(data);
fakeNet.encoding = encoding;
return false;
},
end() {
fakeNet.closeCalled = true;
},
};
},
createServer(cb) {
const fakeNet = this;
cb({
remoteAddress: '1.2.3.4',
remotePort: '1234',
setEncoding(encoding) {
fakeNet.encoding = encoding;
},
on(event, cb2) {
fakeNet.cbs[event] = cb2;
},
});
return {
listen(port, host) {
fakeNet.port = port;
fakeNet.host = host;
},
};
},
};
}
test('TCP Appender', (batch) => {
batch.test('Default Configuration', (t) => {
messages = [];
const serverConfig = {
endMsg: '__LOG4JS__',
deserialise: (log) => LoggingEvent.deserialise(log),
};
server = makeServer(serverConfig);
server.listen(() => {
const { port } = server.address();
log4js.configure({
appenders: {
default: { type: 'tcp', port },
},
categories: {
default: { appenders: ['default'], level: 'debug' },
},
});
const logger = log4js.getLogger();
logger.info('This should be sent via TCP.');
logger.info('This should also be sent via TCP and not break things.');
log4js.shutdown(() => {
server.close(() => {
t.equal(messages.length, 2);
t.match(messages[0], {
data: ['This should be sent via TCP.'],
categoryName: 'default',
context: {},
level: { levelStr: 'INFO' },
});
t.match(messages[1], {
data: ['This should also be sent via TCP and not break things.'],
categoryName: 'default',
context: {},
level: { levelStr: 'INFO' },
});
t.end();
});
});
});
});
batch.test('Custom EndMessage String', (t) => {
messages = [];
const serverConfig = {
endMsg: '\n',
deserialise: (log) => LoggingEvent.deserialise(log),
};
server = makeServer(serverConfig);
server.listen(() => {
const { port } = server.address();
log4js.configure({
appenders: {
customEndMsg: { type: 'tcp', port, endMsg: '\n' },
},
categories: {
default: { appenders: ['customEndMsg'], level: 'debug' },
},
});
const logger = log4js.getLogger();
logger.info('This should be sent via TCP using a custom EndMsg string.');
logger.info(
'This should also be sent via TCP using a custom EndMsg string and not break things.'
);
log4js.shutdown(() => {
server.close(() => {
t.equal(messages.length, 2);
t.match(messages[0], {
data: ['This should be sent via TCP using a custom EndMsg string.'],
categoryName: 'default',
context: {},
level: { levelStr: 'INFO' },
});
t.match(messages[1], {
data: [
'This should also be sent via TCP using a custom EndMsg string and not break things.',
],
categoryName: 'default',
context: {},
level: { levelStr: 'INFO' },
});
t.end();
});
});
});
});
batch.test('Custom Layout', (t) => {
messages = [];
const serverConfig = {
endMsg: '__LOG4JS__',
deserialise: (log) => JSON.parse(log),
};
server = makeServer(serverConfig);
log4js.addLayout(
'json',
() =>
function(logEvent) {
return JSON.stringify({
time: logEvent.startTime,
message: logEvent.data[0],
level: logEvent.level.toString(),
});
}
);
server.listen(() => {
const { port } = server.address();
log4js.configure({
appenders: {
customLayout: {
type: 'tcp',
port,
layout: { type: 'json' },
},
},
categories: {
default: { appenders: ['customLayout'], level: 'debug' },
},
});
const logger = log4js.getLogger();
logger.info('This should be sent as a customized json.');
logger.info(
'This should also be sent via TCP as a customized json and not break things.'
);
log4js.shutdown(() => {
server.close(() => {
t.equal(messages.length, 2);
t.match(messages[0], {
message: 'This should be sent as a customized json.',
level: 'INFO',
});
t.match(messages[1], {
message:
'This should also be sent via TCP as a customized json and not break things.',
level: 'INFO',
});
t.end();
});
});
});
});
batch.test('when underlying stream errors', (t) => {
const fakeNet = makeFakeNet();
const sandboxedLog4js = sandbox.require('../../lib/log4js', {
requires: {
net: fakeNet,
},
});
sandboxedLog4js.configure({
appenders: {
default: { type: 'tcp' },
},
categories: {
default: { appenders: ['default'], level: 'debug' },
},
});
const logger = sandboxedLog4js.getLogger();
logger.info('before connect');
t.test(
'should buffer messages written before socket is connected',
(assert) => {
assert.equal(fakeNet.data.length, 0);
assert.equal(fakeNet.createConnectionCalled, 1);
assert.end();
}
);
fakeNet.cbs.connect();
t.test('should flush buffered messages', (assert) => {
assert.equal(fakeNet.data.length, 1);
assert.equal(fakeNet.createConnectionCalled, 1);
assert.match(fakeNet.data[0], 'before connect');
assert.end();
});
logger.info('after connect');
t.test(
'should write log messages to socket as flatted strings with a terminator string',
(assert) => {
assert.equal(fakeNet.data.length, 2);
assert.match(fakeNet.data[0], 'before connect');
assert.ok(fakeNet.data[0].endsWith('__LOG4JS__'));
assert.match(fakeNet.data[1], 'after connect');
assert.ok(fakeNet.data[1].endsWith('__LOG4JS__'));
assert.equal(fakeNet.encoding, 'utf8');
assert.end();
}
);
fakeNet.cbs.error();
logger.info('after error, before close');
fakeNet.cbs.close();
logger.info('after close, before connect');
fakeNet.cbs.connect();
logger.info('after error, after connect');
t.test('should attempt to re-open the socket on error', (assert) => {
assert.equal(fakeNet.data.length, 5);
assert.equal(fakeNet.createConnectionCalled, 2);
assert.match(fakeNet.data[2], 'after error, before close');
assert.match(fakeNet.data[3], 'after close, before connect');
assert.match(fakeNet.data[4], 'after error, after connect');
assert.end();
});
t.test('should buffer messages until drain', (assert) => {
const previousLength = fakeNet.data.length;
logger.info('should not be flushed');
assert.equal(fakeNet.data.length, previousLength);
assert.notMatch(
fakeNet.data[fakeNet.data.length - 1],
'should not be flushed'
);
fakeNet.cbs.drain();
assert.equal(fakeNet.data.length, previousLength + 1);
assert.match(
fakeNet.data[fakeNet.data.length - 1],
'should not be flushed'
);
assert.end();
});
t.test('should serialize an Error correctly', (assert) => {
const previousLength = fakeNet.data.length;
logger.error(new Error('Error test'));
fakeNet.cbs.drain();
assert.equal(fakeNet.data.length, previousLength + 1);
const raw = fakeNet.data[fakeNet.data.length - 1];
const offset = raw.indexOf('__LOG4JS__');
assert.ok(
flatted.parse(raw.slice(0, offset !== -1 ? offset : 0)).data[0].stack,
`Expected:\n\n${fakeNet.data[6]}\n\n to have a 'data[0].stack' property`
);
const actual = flatted.parse(raw.slice(0, offset !== -1 ? offset : 0))
.data[0].stack;
assert.match(actual, /^Error: Error test/);
assert.end();
});
t.end();
});
batch.end();
});
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./examples/slack-appender.js | // Note that slack appender needs slack-node package to work.
const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
slack: {
type: '@log4js-node/slack',
token: 'TOKEN',
channel_id: '#CHANNEL',
username: 'USERNAME',
format: 'text',
icon_url: 'ICON_URL',
},
},
categories: {
default: { appenders: ['slack'], level: 'info' },
},
});
const logger = log4js.getLogger('slack');
logger.warn('Test Warn message');
logger.info('Test Info message');
logger.debug('Test Debug Message');
logger.trace('Test Trace Message');
logger.fatal('Test Fatal Message');
logger.error('Test Error Message');
| // Note that slack appender needs slack-node package to work.
const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
slack: {
type: '@log4js-node/slack',
token: 'TOKEN',
channel_id: '#CHANNEL',
username: 'USERNAME',
format: 'text',
icon_url: 'ICON_URL',
},
},
categories: {
default: { appenders: ['slack'], level: 'info' },
},
});
const logger = log4js.getLogger('slack');
logger.warn('Test Warn message');
logger.info('Test Info message');
logger.debug('Test Debug Message');
logger.trace('Test Trace Message');
logger.fatal('Test Fatal Message');
logger.error('Test Error Message');
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./lib/appenders/multiFile.js | const debug = require('debug')('log4js:multiFile');
const path = require('path');
const fileAppender = require('./file');
const findFileKey = (property, event) =>
event[property] || event.context[property];
module.exports.configure = (config, layouts) => {
debug('Creating a multi-file appender');
const files = new Map();
const timers = new Map();
function checkForTimeout(fileKey) {
const timer = timers.get(fileKey);
const app = files.get(fileKey);
/* istanbul ignore else: failsafe */
if (timer && app) {
if (Date.now() - timer.lastUsed > timer.timeout) {
debug('%s not used for > %d ms => close', fileKey, timer.timeout);
clearInterval(timer.interval);
timers.delete(fileKey);
files.delete(fileKey);
app.shutdown((err) => {
if (err) {
debug('ignore error on file shutdown: %s', err.message);
}
});
}
} else {
// will never get here as files and timers are coupled to be added and deleted at same place
debug('timer or app does not exist');
}
}
const appender = (logEvent) => {
const fileKey = findFileKey(config.property, logEvent);
debug('fileKey for property ', config.property, ' is ', fileKey);
if (fileKey) {
let file = files.get(fileKey);
debug('existing file appender is ', file);
if (!file) {
debug('creating new file appender');
config.filename = path.join(config.base, fileKey + config.extension);
file = fileAppender.configure(config, layouts);
files.set(fileKey, file);
if (config.timeout) {
debug('creating new timer');
timers.set(fileKey, {
timeout: config.timeout,
lastUsed: Date.now(),
interval: setInterval(
checkForTimeout.bind(null, fileKey),
config.timeout
),
});
}
} else if (config.timeout) {
debug('%s extending activity', fileKey);
timers.get(fileKey).lastUsed = Date.now();
}
file(logEvent);
} else {
debug('No fileKey for logEvent, quietly ignoring this log event');
}
};
appender.shutdown = (cb) => {
let shutdownFunctions = files.size;
if (shutdownFunctions <= 0) {
cb();
}
let error;
timers.forEach((timer, fileKey) => {
debug('clearing timer for ', fileKey);
clearInterval(timer.interval);
});
files.forEach((app, fileKey) => {
debug('calling shutdown for ', fileKey);
app.shutdown((err) => {
error = error || err;
shutdownFunctions -= 1;
if (shutdownFunctions <= 0) {
cb(error);
}
});
});
};
return appender;
};
| const debug = require('debug')('log4js:multiFile');
const path = require('path');
const fileAppender = require('./file');
const findFileKey = (property, event) =>
event[property] || event.context[property];
module.exports.configure = (config, layouts) => {
debug('Creating a multi-file appender');
const files = new Map();
const timers = new Map();
function checkForTimeout(fileKey) {
const timer = timers.get(fileKey);
const app = files.get(fileKey);
/* istanbul ignore else: failsafe */
if (timer && app) {
if (Date.now() - timer.lastUsed > timer.timeout) {
debug('%s not used for > %d ms => close', fileKey, timer.timeout);
clearInterval(timer.interval);
timers.delete(fileKey);
files.delete(fileKey);
app.shutdown((err) => {
if (err) {
debug('ignore error on file shutdown: %s', err.message);
}
});
}
} else {
// will never get here as files and timers are coupled to be added and deleted at same place
debug('timer or app does not exist');
}
}
const appender = (logEvent) => {
const fileKey = findFileKey(config.property, logEvent);
debug('fileKey for property ', config.property, ' is ', fileKey);
if (fileKey) {
let file = files.get(fileKey);
debug('existing file appender is ', file);
if (!file) {
debug('creating new file appender');
config.filename = path.join(config.base, fileKey + config.extension);
file = fileAppender.configure(config, layouts);
files.set(fileKey, file);
if (config.timeout) {
debug('creating new timer');
timers.set(fileKey, {
timeout: config.timeout,
lastUsed: Date.now(),
interval: setInterval(
checkForTimeout.bind(null, fileKey),
config.timeout
),
});
}
} else if (config.timeout) {
debug('%s extending activity', fileKey);
timers.get(fileKey).lastUsed = Date.now();
}
file(logEvent);
} else {
debug('No fileKey for logEvent, quietly ignoring this log event');
}
};
appender.shutdown = (cb) => {
let shutdownFunctions = files.size;
if (shutdownFunctions <= 0) {
cb();
}
let error;
timers.forEach((timer, fileKey) => {
debug('clearing timer for ', fileKey);
clearInterval(timer.interval);
});
files.forEach((app, fileKey) => {
debug('calling shutdown for ', fileKey);
app.shutdown((err) => {
error = error || err;
shutdownFunctions -= 1;
if (shutdownFunctions <= 0) {
cb(error);
}
});
});
};
return appender;
};
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./examples/fromreadme.js | // remember to change the require to just 'log4js' if you've npm install'ed it
const log4js = require('../lib/log4js');
log4js.configure({
appenders: { cheese: { type: 'file', filename: 'cheese.log' } },
categories: { default: { appenders: ['cheese'], level: 'error' } },
});
const logger = log4js.getLogger('cheese');
logger.level = 'ERROR';
logger.trace('Entering cheese testing');
logger.debug('Got cheese.');
logger.info('Cheese is Gouda.');
logger.warn('Cheese is quite smelly.');
logger.error('Cheese is too ripe!');
logger.fatal('Cheese was breeding ground for listeria.');
| // remember to change the require to just 'log4js' if you've npm install'ed it
const log4js = require('../lib/log4js');
log4js.configure({
appenders: { cheese: { type: 'file', filename: 'cheese.log' } },
categories: { default: { appenders: ['cheese'], level: 'error' } },
});
const logger = log4js.getLogger('cheese');
logger.level = 'ERROR';
logger.trace('Entering cheese testing');
logger.debug('Got cheese.');
logger.info('Cheese is Gouda.');
logger.warn('Cheese is quite smelly.');
logger.error('Cheese is too ripe!');
logger.fatal('Cheese was breeding ground for listeria.');
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/configuration-test.js | const { test } = require('tap');
const sandbox = require('@log4js-node/sandboxed-module');
const realFS = require('fs');
const modulePath = 'some/path/to/mylog4js.json';
const pathsChecked = [];
let fakeFS = {};
let dependencies;
let fileRead;
test('log4js configure', (batch) => {
batch.beforeEach((done) => {
fileRead = 0;
fakeFS = {
realpath: realFS.realpath, // fs-extra looks for this
ReadStream: realFS.ReadStream, // need to define these, because graceful-fs uses them
WriteStream: realFS.WriteStream,
read: realFS.read,
closeSync: () => {},
config: {
appenders: {
console: {
type: 'console',
layout: { type: 'messagePassThrough' },
},
},
categories: {
default: {
appenders: ['console'],
level: 'INFO',
},
},
},
readdirSync: (dir) => require('fs').readdirSync(dir),
readFileSync: (file, encoding) => {
fileRead += 1;
batch.type(file, 'string');
batch.equal(file, modulePath);
batch.equal(encoding, 'utf8');
return JSON.stringify(fakeFS.config);
},
statSync: (path) => {
pathsChecked.push(path);
if (path === modulePath) {
return { mtime: new Date() };
}
throw new Error('no such file');
},
};
dependencies = {
requires: {
fs: fakeFS,
},
};
if (typeof done === 'function') {
done();
}
});
batch.test(
'when configuration file loaded via LOG4JS_CONFIG env variable',
(t) => {
process.env.LOG4JS_CONFIG = 'some/path/to/mylog4js.json';
const log4js = sandbox.require('../../lib/log4js', dependencies);
log4js.getLogger('test-logger');
t.equal(fileRead, 1, 'should load the specified local config file');
delete process.env.LOG4JS_CONFIG;
t.end();
}
);
batch.test(
'when configuration is set via configure() method call, return the log4js object',
(t) => {
const log4js = sandbox
.require('../../lib/log4js', dependencies)
.configure(fakeFS.config);
t.type(
log4js,
'object',
'Configure method call should return the log4js object!'
);
const log = log4js.getLogger('daemon');
t.type(
log,
'object',
'log4js object, returned by configure(...) method should be able to create log object.'
);
t.type(log.info, 'function');
t.end();
}
);
batch.end();
});
| const { test } = require('tap');
const sandbox = require('@log4js-node/sandboxed-module');
const realFS = require('fs');
const modulePath = 'some/path/to/mylog4js.json';
const pathsChecked = [];
let fakeFS = {};
let dependencies;
let fileRead;
test('log4js configure', (batch) => {
batch.beforeEach((done) => {
fileRead = 0;
fakeFS = {
realpath: realFS.realpath, // fs-extra looks for this
ReadStream: realFS.ReadStream, // need to define these, because graceful-fs uses them
WriteStream: realFS.WriteStream,
read: realFS.read,
closeSync: () => {},
config: {
appenders: {
console: {
type: 'console',
layout: { type: 'messagePassThrough' },
},
},
categories: {
default: {
appenders: ['console'],
level: 'INFO',
},
},
},
readdirSync: (dir) => require('fs').readdirSync(dir),
readFileSync: (file, encoding) => {
fileRead += 1;
batch.type(file, 'string');
batch.equal(file, modulePath);
batch.equal(encoding, 'utf8');
return JSON.stringify(fakeFS.config);
},
statSync: (path) => {
pathsChecked.push(path);
if (path === modulePath) {
return { mtime: new Date() };
}
throw new Error('no such file');
},
};
dependencies = {
requires: {
fs: fakeFS,
},
};
if (typeof done === 'function') {
done();
}
});
batch.test(
'when configuration file loaded via LOG4JS_CONFIG env variable',
(t) => {
process.env.LOG4JS_CONFIG = 'some/path/to/mylog4js.json';
const log4js = sandbox.require('../../lib/log4js', dependencies);
log4js.getLogger('test-logger');
t.equal(fileRead, 1, 'should load the specified local config file');
delete process.env.LOG4JS_CONFIG;
t.end();
}
);
batch.test(
'when configuration is set via configure() method call, return the log4js object',
(t) => {
const log4js = sandbox
.require('../../lib/log4js', dependencies)
.configure(fakeFS.config);
t.type(
log4js,
'object',
'Configure method call should return the log4js object!'
);
const log = log4js.getLogger('daemon');
t.type(
log,
'object',
'log4js object, returned by configure(...) method should be able to create log object.'
);
t.type(log.info, 'function');
t.end();
}
);
batch.end();
});
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./lib/appenders/adapters.js | function maxFileSizeUnitTransform(maxLogSize) {
if (typeof maxLogSize === 'number' && Number.isInteger(maxLogSize)) {
return maxLogSize;
}
const units = {
K: 1024,
M: 1024 * 1024,
G: 1024 * 1024 * 1024,
};
const validUnit = Object.keys(units);
const unit = maxLogSize.slice(-1).toLocaleUpperCase();
const value = maxLogSize.slice(0, -1).trim();
if (validUnit.indexOf(unit) < 0 || !Number.isInteger(Number(value))) {
throw Error(`maxLogSize: "${maxLogSize}" is invalid`);
} else {
return value * units[unit];
}
}
function adapter(configAdapter, config) {
const newConfig = Object.assign({}, config); // eslint-disable-line prefer-object-spread
Object.keys(configAdapter).forEach((key) => {
if (newConfig[key]) {
newConfig[key] = configAdapter[key](config[key]);
}
});
return newConfig;
}
function fileAppenderAdapter(config) {
const configAdapter = {
maxLogSize: maxFileSizeUnitTransform,
};
return adapter(configAdapter, config);
}
const adapters = {
dateFile: fileAppenderAdapter,
file: fileAppenderAdapter,
fileSync: fileAppenderAdapter,
};
module.exports.modifyConfig = (config) =>
adapters[config.type] ? adapters[config.type](config) : config;
| function maxFileSizeUnitTransform(maxLogSize) {
if (typeof maxLogSize === 'number' && Number.isInteger(maxLogSize)) {
return maxLogSize;
}
const units = {
K: 1024,
M: 1024 * 1024,
G: 1024 * 1024 * 1024,
};
const validUnit = Object.keys(units);
const unit = maxLogSize.slice(-1).toLocaleUpperCase();
const value = maxLogSize.slice(0, -1).trim();
if (validUnit.indexOf(unit) < 0 || !Number.isInteger(Number(value))) {
throw Error(`maxLogSize: "${maxLogSize}" is invalid`);
} else {
return value * units[unit];
}
}
function adapter(configAdapter, config) {
const newConfig = Object.assign({}, config); // eslint-disable-line prefer-object-spread
Object.keys(configAdapter).forEach((key) => {
if (newConfig[key]) {
newConfig[key] = configAdapter[key](config[key]);
}
});
return newConfig;
}
function fileAppenderAdapter(config) {
const configAdapter = {
maxLogSize: maxFileSizeUnitTransform,
};
return adapter(configAdapter, config);
}
const adapters = {
dateFile: fileAppenderAdapter,
file: fileAppenderAdapter,
fileSync: fileAppenderAdapter,
};
module.exports.modifyConfig = (config) =>
adapters[config.type] ? adapters[config.type](config) : config;
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/pause-test.js | const tap = require('tap');
const fs = require('fs');
const log4js = require('../../lib/log4js');
const removeFiles = async (filenames) => {
if (!Array.isArray(filenames)) filenames = [filenames];
const promises = filenames.map((filename) => fs.promises.unlink(filename));
await Promise.allSettled(promises);
};
tap.test('Drain event test', (batch) => {
batch.test(
'Should emit pause event and resume when logging in a file with high frequency',
(t) => {
t.teardown(async () => {
process.off(
'log4js:pause',
process.listeners('log4js:pause')[
process.listeners('log4js:pause').length - 1
]
);
await removeFiles('logs/drain.log');
});
// Generate logger with 5k of highWaterMark config
log4js.configure({
appenders: {
file: {
type: 'file',
filename: 'logs/drain.log',
highWaterMark: 5 * 1024,
},
},
categories: {
default: { appenders: ['file'], level: 'debug' },
},
});
let paused = false;
let resumed = false;
process.on('log4js:pause', (value) => {
if (value) {
paused = true;
t.ok(value, 'log4js:pause, true');
} else {
resumed = true;
t.ok(!value, 'log4js:pause, false');
t.end();
}
});
const logger = log4js.getLogger();
while (!paused && !resumed) {
if (!paused) {
logger.info('This is a test for emitting drain event');
}
}
}
);
batch.test(
'Should emit pause event and resume when logging in a date file with high frequency',
(t) => {
t.teardown(async () => {
process.off(
'log4js:pause',
process.listeners('log4js:pause')[
process.listeners('log4js:pause').length - 1
]
);
await removeFiles('logs/date-file-drain.log');
});
// Generate date file logger with 5kb of highWaterMark config
log4js.configure({
appenders: {
file: {
type: 'dateFile',
filename: 'logs/date-file-drain.log',
highWaterMark: 5 * 1024,
},
},
categories: {
default: { appenders: ['file'], level: 'debug' },
},
});
let paused = false;
let resumed = false;
process.on('log4js:pause', (value) => {
if (value) {
paused = true;
t.ok(value, 'log4js:pause, true');
} else {
resumed = true;
t.ok(!value, 'log4js:pause, false');
t.end();
}
});
const logger = log4js.getLogger();
while (!paused && !resumed) {
if (!paused)
logger.info(
'This is a test for emitting drain event in date file logger'
);
}
}
);
batch.teardown(async () => {
try {
const files = fs.readdirSync('logs');
await removeFiles(files.map((filename) => `logs/${filename}`));
fs.rmdirSync('logs');
} catch (e) {
// doesn't matter
}
});
batch.end();
});
| const tap = require('tap');
const fs = require('fs');
const log4js = require('../../lib/log4js');
const removeFiles = async (filenames) => {
if (!Array.isArray(filenames)) filenames = [filenames];
const promises = filenames.map((filename) => fs.promises.unlink(filename));
await Promise.allSettled(promises);
};
tap.test('Drain event test', (batch) => {
batch.test(
'Should emit pause event and resume when logging in a file with high frequency',
(t) => {
t.teardown(async () => {
process.off(
'log4js:pause',
process.listeners('log4js:pause')[
process.listeners('log4js:pause').length - 1
]
);
await removeFiles('logs/drain.log');
});
// Generate logger with 5k of highWaterMark config
log4js.configure({
appenders: {
file: {
type: 'file',
filename: 'logs/drain.log',
highWaterMark: 5 * 1024,
},
},
categories: {
default: { appenders: ['file'], level: 'debug' },
},
});
let paused = false;
let resumed = false;
process.on('log4js:pause', (value) => {
if (value) {
paused = true;
t.ok(value, 'log4js:pause, true');
} else {
resumed = true;
t.ok(!value, 'log4js:pause, false');
t.end();
}
});
const logger = log4js.getLogger();
while (!paused && !resumed) {
if (!paused) {
logger.info('This is a test for emitting drain event');
}
}
}
);
batch.test(
'Should emit pause event and resume when logging in a date file with high frequency',
(t) => {
t.teardown(async () => {
process.off(
'log4js:pause',
process.listeners('log4js:pause')[
process.listeners('log4js:pause').length - 1
]
);
await removeFiles('logs/date-file-drain.log');
});
// Generate date file logger with 5kb of highWaterMark config
log4js.configure({
appenders: {
file: {
type: 'dateFile',
filename: 'logs/date-file-drain.log',
highWaterMark: 5 * 1024,
},
},
categories: {
default: { appenders: ['file'], level: 'debug' },
},
});
let paused = false;
let resumed = false;
process.on('log4js:pause', (value) => {
if (value) {
paused = true;
t.ok(value, 'log4js:pause, true');
} else {
resumed = true;
t.ok(!value, 'log4js:pause, false');
t.end();
}
});
const logger = log4js.getLogger();
while (!paused && !resumed) {
if (!paused)
logger.info(
'This is a test for emitting drain event in date file logger'
);
}
}
);
batch.teardown(async () => {
try {
const files = fs.readdirSync('logs');
await removeFiles(files.map((filename) => `logs/${filename}`));
fs.rmdirSync('logs');
} catch (e) {
// doesn't matter
}
});
batch.end();
});
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./commitlint.config.js | module.exports = { extends: ['@commitlint/config-conventional'] };
| module.exports = { extends: ['@commitlint/config-conventional'] };
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./examples/logstashHTTP.js | const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
console: {
type: 'console',
},
logstash: {
url: 'http://172.17.0.5:9200/_bulk',
type: '@log4js-node/logstash-http',
logType: 'application',
logChannel: 'node',
application: 'logstash-log4js',
layout: {
type: 'pattern',
pattern: '%m',
},
},
},
categories: {
default: { appenders: ['console', 'logstash'], level: 'info' },
},
});
const logger = log4js.getLogger('myLogger');
logger.info('Test log message %s', 'arg1', 'arg2');
| const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
console: {
type: 'console',
},
logstash: {
url: 'http://172.17.0.5:9200/_bulk',
type: '@log4js-node/logstash-http',
logType: 'application',
logChannel: 'node',
application: 'logstash-log4js',
layout: {
type: 'pattern',
pattern: '%m',
},
},
},
categories: {
default: { appenders: ['console', 'logstash'], level: 'info' },
},
});
const logger = log4js.getLogger('myLogger');
logger.info('Test log message %s', 'arg1', 'arg2');
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./examples/flush-on-exit.js | /**
* run this, then "ab -c 10 -n 100 localhost:4444/" to test (in
* another shell)
*/
const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
cheese: { type: 'file', filename: 'cheese.log' },
},
categories: {
default: { appenders: ['cheese'], level: 'debug' },
},
});
const logger = log4js.getLogger('cheese');
const http = require('http');
http
.createServer((request, response) => {
response.writeHead(200, { 'Content-Type': 'text/plain' });
const rd = Math.random() * 50;
logger.info(`hello ${rd}`);
response.write('hello ');
if (Math.floor(rd) === 30) {
log4js.shutdown(() => {
process.exit(1);
});
}
response.end();
})
.listen(4444);
| /**
* run this, then "ab -c 10 -n 100 localhost:4444/" to test (in
* another shell)
*/
const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
cheese: { type: 'file', filename: 'cheese.log' },
},
categories: {
default: { appenders: ['cheese'], level: 'debug' },
},
});
const logger = log4js.getLogger('cheese');
const http = require('http');
http
.createServer((request, response) => {
response.writeHead(200, { 'Content-Type': 'text/plain' });
const rd = Math.random() * 50;
logger.info(`hello ${rd}`);
response.write('hello ');
if (Math.floor(rd) === 30) {
log4js.shutdown(() => {
process.exit(1);
});
}
response.end();
})
.listen(4444);
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./examples/logFaces-appender.js | const log4js = require('../lib/log4js');
/*
logFaces server configured with UDP receiver, using JSON format,
listening on port 55201 will receive the logs from the appender below.
*/
log4js.configure({
appenders: {
logFaces: {
type: '@log4js-node/logfaces-udp', // (mandatory) appender type
application: 'MY-NODEJS', // (optional) name of the application (domain)
remoteHost: 'localhost', // (optional) logFaces server host or IP address
port: 55201, // (optional) logFaces UDP receiver port (must use JSON format)
layout: {
// (optional) the layout to use for messages
type: 'pattern',
pattern: '%m',
},
},
},
categories: { default: { appenders: ['logFaces'], level: 'info' } },
});
const logger = log4js.getLogger('myLogger');
logger.info('Testing message %s', 'arg1');
| const log4js = require('../lib/log4js');
/*
logFaces server configured with UDP receiver, using JSON format,
listening on port 55201 will receive the logs from the appender below.
*/
log4js.configure({
appenders: {
logFaces: {
type: '@log4js-node/logfaces-udp', // (mandatory) appender type
application: 'MY-NODEJS', // (optional) name of the application (domain)
remoteHost: 'localhost', // (optional) logFaces server host or IP address
port: 55201, // (optional) logFaces UDP receiver port (must use JSON format)
layout: {
// (optional) the layout to use for messages
type: 'pattern',
pattern: '%m',
},
},
},
categories: { default: { appenders: ['logFaces'], level: 'info' } },
});
const logger = log4js.getLogger('myLogger');
logger.info('Testing message %s', 'arg1');
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/logger-test.js | const { test } = require('tap');
const debug = require('debug')('log4js:test.logger');
const sandbox = require('@log4js-node/sandboxed-module');
const callsites = require('callsites');
const levels = require('../../lib/levels');
const categories = require('../../lib/categories');
const events = [];
const messages = [];
const Logger = sandbox.require('../../lib/logger', {
requires: {
'./levels': levels,
'./categories': categories,
'./clustering': {
isMaster: () => true,
onlyOnMaster: (fn) => fn(),
send: (evt) => {
debug('fake clustering got event:', evt);
events.push(evt);
},
},
},
globals: {
console: {
...console,
error(msg) {
messages.push(msg);
},
},
},
});
const testConfig = {
level: levels.TRACE,
};
test('../../lib/logger', (batch) => {
batch.beforeEach((done) => {
events.length = 0;
testConfig.level = levels.TRACE;
if (typeof done === 'function') {
done();
}
});
batch.test('constructor with no parameters', (t) => {
t.throws(() => new Logger(), new Error('No category provided.'));
t.end();
});
batch.test('constructor with category', (t) => {
const logger = new Logger('cheese');
t.equal(logger.category, 'cheese', 'should use category');
t.equal(logger.level, levels.OFF, 'should use OFF log level');
t.end();
});
batch.test('set level should delegate', (t) => {
const logger = new Logger('cheese');
logger.level = 'debug';
t.equal(logger.category, 'cheese', 'should use category');
t.equal(logger.level, levels.DEBUG, 'should use level');
t.end();
});
batch.test('isLevelEnabled', (t) => {
const logger = new Logger('cheese');
const functions = [
'isTraceEnabled',
'isDebugEnabled',
'isInfoEnabled',
'isWarnEnabled',
'isErrorEnabled',
'isFatalEnabled',
];
t.test(
'should provide a level enabled function for all levels',
(subtest) => {
subtest.plan(functions.length);
functions.forEach((fn) => {
subtest.type(logger[fn], 'function');
});
}
);
logger.level = 'INFO';
t.notOk(logger.isTraceEnabled());
t.notOk(logger.isDebugEnabled());
t.ok(logger.isInfoEnabled());
t.ok(logger.isWarnEnabled());
t.ok(logger.isErrorEnabled());
t.ok(logger.isFatalEnabled());
t.end();
});
batch.test('should send log events to dispatch function', (t) => {
const logger = new Logger('cheese');
logger.level = 'debug';
logger.debug('Event 1');
logger.debug('Event 2');
logger.debug('Event 3');
t.equal(events.length, 3);
t.equal(events[0].data[0], 'Event 1');
t.equal(events[1].data[0], 'Event 2');
t.equal(events[2].data[0], 'Event 3');
t.end();
});
batch.test('should add context values to every event', (t) => {
const logger = new Logger('fromage');
logger.level = 'debug';
logger.debug('Event 1');
logger.addContext('cheese', 'edam');
logger.debug('Event 2');
logger.debug('Event 3');
logger.addContext('biscuits', 'timtam');
logger.debug('Event 4');
logger.removeContext('cheese');
logger.debug('Event 5');
logger.clearContext();
logger.debug('Event 6');
t.equal(events.length, 6);
t.same(events[0].context, {});
t.same(events[1].context, { cheese: 'edam' });
t.same(events[2].context, { cheese: 'edam' });
t.same(events[3].context, { cheese: 'edam', biscuits: 'timtam' });
t.same(events[4].context, { biscuits: 'timtam' });
t.same(events[5].context, {});
t.end();
});
batch.test('should not break when log data has no toString', (t) => {
const logger = new Logger('thing');
logger.level = 'debug';
logger.info('Just testing ', Object.create(null));
t.equal(events.length, 1);
t.end();
});
batch.test(
'default should disable useCallStack unless manual enable',
(t) => {
const logger = new Logger('stack');
logger.level = 'debug';
t.equal(logger.useCallStack, false);
logger.useCallStack = false;
t.equal(logger.useCallStack, false);
logger.useCallStack = 0;
t.equal(logger.useCallStack, false);
logger.useCallStack = '';
t.equal(logger.useCallStack, false);
logger.useCallStack = null;
t.equal(logger.useCallStack, false);
logger.useCallStack = undefined;
t.equal(logger.useCallStack, false);
logger.useCallStack = 'true';
t.equal(logger.useCallStack, false);
logger.useCallStack = true;
t.equal(logger.useCallStack, true);
t.end();
}
);
batch.test('should correctly switch on/off useCallStack', (t) => {
const logger = new Logger('stack');
logger.level = 'debug';
logger.useCallStack = true;
t.equal(logger.useCallStack, true);
logger.info('hello world');
const callsite = callsites()[0];
t.equal(events.length, 1);
t.equal(events[0].data[0], 'hello world');
t.equal(events[0].fileName, callsite.getFileName());
t.equal(events[0].lineNumber, callsite.getLineNumber() - 1);
t.equal(events[0].columnNumber, 12);
logger.useCallStack = false;
logger.info('disabled');
t.equal(logger.useCallStack, false);
t.equal(events[1].data[0], 'disabled');
t.equal(events[1].fileName, undefined);
t.equal(events[1].lineNumber, undefined);
t.equal(events[1].columnNumber, undefined);
t.end();
});
batch.test(
'Once switch on/off useCallStack will apply all same category loggers',
(t) => {
const logger1 = new Logger('stack');
logger1.level = 'debug';
logger1.useCallStack = true;
const logger2 = new Logger('stack');
logger2.level = 'debug';
logger1.info('hello world');
const callsite = callsites()[0];
t.equal(logger1.useCallStack, true);
t.equal(events.length, 1);
t.equal(events[0].data[0], 'hello world');
t.equal(events[0].fileName, callsite.getFileName());
t.equal(events[0].lineNumber, callsite.getLineNumber() - 1);
t.equal(events[0].columnNumber, 15); // col of the '.' in logger1.info(...)
logger2.info('hello world');
const callsite2 = callsites()[0];
t.equal(logger2.useCallStack, true);
t.equal(events[1].data[0], 'hello world');
t.equal(events[1].fileName, callsite2.getFileName());
t.equal(events[1].lineNumber, callsite2.getLineNumber() - 1);
t.equal(events[1].columnNumber, 15); // col of the '.' in logger1.info(...)
logger1.useCallStack = false;
logger2.info('hello world');
t.equal(logger2.useCallStack, false);
t.equal(events[2].data[0], 'hello world');
t.equal(events[2].fileName, undefined);
t.equal(events[2].lineNumber, undefined);
t.equal(events[2].columnNumber, undefined);
t.end();
}
);
batch.test('parseCallStack function coverage', (t) => {
const logger = new Logger('stack');
logger.useCallStack = true;
let results;
results = logger.parseCallStack(new Error());
t.ok(results);
t.equal(messages.length, 0, 'should not have error');
results = logger.parseCallStack('');
t.notOk(results);
t.equal(messages.length, 1, 'should have error');
t.end();
});
batch.test('should correctly change the parseCallStack function', (t) => {
const logger = new Logger('stack');
const parseFunction = function() {
return {
functionName: 'test function name',
fileName: 'test file name',
lineNumber: 15,
columnNumber: 25,
callStack: 'test callstack',
};
};
logger.level = 'debug';
logger.useCallStack = true;
logger.setParseCallStackFunction(parseFunction);
t.equal(logger.parseCallStack, parseFunction);
logger.info('test parseCallStack');
t.equal(events[0].functionName, 'test function name');
t.equal(events[0].fileName, 'test file name');
t.equal(events[0].lineNumber, 15);
t.equal(events[0].columnNumber, 25);
t.equal(events[0].callStack, 'test callstack');
t.end();
});
batch.test('creating/cloning of category', (t) => {
const defaultLogger = new Logger('default');
defaultLogger.level = 'trace';
defaultLogger.useCallStack = true;
t.test(
'category should be cloned from parent/default if does not exist',
(assert) => {
const originalLength = categories.size;
const logger = new Logger('cheese1');
assert.equal(
categories.size,
originalLength + 1,
'category should be cloned'
);
assert.equal(
logger.level,
levels.TRACE,
'should inherit level=TRACE from default-category'
);
assert.equal(
logger.useCallStack,
true,
'should inherit useCallStack=true from default-category'
);
assert.end();
}
);
t.test(
'changing level should not impact default-category or useCallStack',
(assert) => {
const logger = new Logger('cheese2');
logger.level = 'debug';
assert.equal(
logger.level,
levels.DEBUG,
'should be changed to level=DEBUG'
);
assert.equal(
defaultLogger.level,
levels.TRACE,
'default-category should remain as level=TRACE'
);
assert.equal(
logger.useCallStack,
true,
'should remain as useCallStack=true'
);
assert.equal(
defaultLogger.useCallStack,
true,
'default-category should remain as useCallStack=true'
);
assert.end();
}
);
t.test(
'changing useCallStack should not impact default-category or level',
(assert) => {
const logger = new Logger('cheese3');
logger.useCallStack = false;
assert.equal(
logger.useCallStack,
false,
'should be changed to useCallStack=false'
);
assert.equal(
defaultLogger.useCallStack,
true,
'default-category should remain as useCallStack=true'
);
assert.equal(
logger.level,
levels.TRACE,
'should remain as level=TRACE'
);
assert.equal(
defaultLogger.level,
levels.TRACE,
'default-category should remain as level=TRACE'
);
assert.end();
}
);
t.end();
});
batch.end();
});
| const { test } = require('tap');
const debug = require('debug')('log4js:test.logger');
const sandbox = require('@log4js-node/sandboxed-module');
const callsites = require('callsites');
const levels = require('../../lib/levels');
const categories = require('../../lib/categories');
const events = [];
const messages = [];
const Logger = sandbox.require('../../lib/logger', {
requires: {
'./levels': levels,
'./categories': categories,
'./clustering': {
isMaster: () => true,
onlyOnMaster: (fn) => fn(),
send: (evt) => {
debug('fake clustering got event:', evt);
events.push(evt);
},
},
},
globals: {
console: {
...console,
error(msg) {
messages.push(msg);
},
},
},
});
const testConfig = {
level: levels.TRACE,
};
test('../../lib/logger', (batch) => {
batch.beforeEach((done) => {
events.length = 0;
testConfig.level = levels.TRACE;
if (typeof done === 'function') {
done();
}
});
batch.test('constructor with no parameters', (t) => {
t.throws(() => new Logger(), new Error('No category provided.'));
t.end();
});
batch.test('constructor with category', (t) => {
const logger = new Logger('cheese');
t.equal(logger.category, 'cheese', 'should use category');
t.equal(logger.level, levels.OFF, 'should use OFF log level');
t.end();
});
batch.test('set level should delegate', (t) => {
const logger = new Logger('cheese');
logger.level = 'debug';
t.equal(logger.category, 'cheese', 'should use category');
t.equal(logger.level, levels.DEBUG, 'should use level');
t.end();
});
batch.test('isLevelEnabled', (t) => {
const logger = new Logger('cheese');
const functions = [
'isTraceEnabled',
'isDebugEnabled',
'isInfoEnabled',
'isWarnEnabled',
'isErrorEnabled',
'isFatalEnabled',
];
t.test(
'should provide a level enabled function for all levels',
(subtest) => {
subtest.plan(functions.length);
functions.forEach((fn) => {
subtest.type(logger[fn], 'function');
});
}
);
logger.level = 'INFO';
t.notOk(logger.isTraceEnabled());
t.notOk(logger.isDebugEnabled());
t.ok(logger.isInfoEnabled());
t.ok(logger.isWarnEnabled());
t.ok(logger.isErrorEnabled());
t.ok(logger.isFatalEnabled());
t.end();
});
batch.test('should send log events to dispatch function', (t) => {
const logger = new Logger('cheese');
logger.level = 'debug';
logger.debug('Event 1');
logger.debug('Event 2');
logger.debug('Event 3');
t.equal(events.length, 3);
t.equal(events[0].data[0], 'Event 1');
t.equal(events[1].data[0], 'Event 2');
t.equal(events[2].data[0], 'Event 3');
t.end();
});
batch.test('should add context values to every event', (t) => {
const logger = new Logger('fromage');
logger.level = 'debug';
logger.debug('Event 1');
logger.addContext('cheese', 'edam');
logger.debug('Event 2');
logger.debug('Event 3');
logger.addContext('biscuits', 'timtam');
logger.debug('Event 4');
logger.removeContext('cheese');
logger.debug('Event 5');
logger.clearContext();
logger.debug('Event 6');
t.equal(events.length, 6);
t.same(events[0].context, {});
t.same(events[1].context, { cheese: 'edam' });
t.same(events[2].context, { cheese: 'edam' });
t.same(events[3].context, { cheese: 'edam', biscuits: 'timtam' });
t.same(events[4].context, { biscuits: 'timtam' });
t.same(events[5].context, {});
t.end();
});
batch.test('should not break when log data has no toString', (t) => {
const logger = new Logger('thing');
logger.level = 'debug';
logger.info('Just testing ', Object.create(null));
t.equal(events.length, 1);
t.end();
});
batch.test(
'default should disable useCallStack unless manual enable',
(t) => {
const logger = new Logger('stack');
logger.level = 'debug';
t.equal(logger.useCallStack, false);
logger.useCallStack = false;
t.equal(logger.useCallStack, false);
logger.useCallStack = 0;
t.equal(logger.useCallStack, false);
logger.useCallStack = '';
t.equal(logger.useCallStack, false);
logger.useCallStack = null;
t.equal(logger.useCallStack, false);
logger.useCallStack = undefined;
t.equal(logger.useCallStack, false);
logger.useCallStack = 'true';
t.equal(logger.useCallStack, false);
logger.useCallStack = true;
t.equal(logger.useCallStack, true);
t.end();
}
);
batch.test('should correctly switch on/off useCallStack', (t) => {
const logger = new Logger('stack');
logger.level = 'debug';
logger.useCallStack = true;
t.equal(logger.useCallStack, true);
logger.info('hello world');
const callsite = callsites()[0];
t.equal(events.length, 1);
t.equal(events[0].data[0], 'hello world');
t.equal(events[0].fileName, callsite.getFileName());
t.equal(events[0].lineNumber, callsite.getLineNumber() - 1);
t.equal(events[0].columnNumber, 12);
logger.useCallStack = false;
logger.info('disabled');
t.equal(logger.useCallStack, false);
t.equal(events[1].data[0], 'disabled');
t.equal(events[1].fileName, undefined);
t.equal(events[1].lineNumber, undefined);
t.equal(events[1].columnNumber, undefined);
t.end();
});
batch.test(
'Once switch on/off useCallStack will apply all same category loggers',
(t) => {
const logger1 = new Logger('stack');
logger1.level = 'debug';
logger1.useCallStack = true;
const logger2 = new Logger('stack');
logger2.level = 'debug';
logger1.info('hello world');
const callsite = callsites()[0];
t.equal(logger1.useCallStack, true);
t.equal(events.length, 1);
t.equal(events[0].data[0], 'hello world');
t.equal(events[0].fileName, callsite.getFileName());
t.equal(events[0].lineNumber, callsite.getLineNumber() - 1);
t.equal(events[0].columnNumber, 15); // col of the '.' in logger1.info(...)
logger2.info('hello world');
const callsite2 = callsites()[0];
t.equal(logger2.useCallStack, true);
t.equal(events[1].data[0], 'hello world');
t.equal(events[1].fileName, callsite2.getFileName());
t.equal(events[1].lineNumber, callsite2.getLineNumber() - 1);
t.equal(events[1].columnNumber, 15); // col of the '.' in logger1.info(...)
logger1.useCallStack = false;
logger2.info('hello world');
t.equal(logger2.useCallStack, false);
t.equal(events[2].data[0], 'hello world');
t.equal(events[2].fileName, undefined);
t.equal(events[2].lineNumber, undefined);
t.equal(events[2].columnNumber, undefined);
t.end();
}
);
batch.test('parseCallStack function coverage', (t) => {
const logger = new Logger('stack');
logger.useCallStack = true;
let results;
results = logger.parseCallStack(new Error());
t.ok(results);
t.equal(messages.length, 0, 'should not have error');
results = logger.parseCallStack('');
t.notOk(results);
t.equal(messages.length, 1, 'should have error');
t.end();
});
batch.test('should correctly change the parseCallStack function', (t) => {
const logger = new Logger('stack');
const parseFunction = function() {
return {
functionName: 'test function name',
fileName: 'test file name',
lineNumber: 15,
columnNumber: 25,
callStack: 'test callstack',
};
};
logger.level = 'debug';
logger.useCallStack = true;
logger.setParseCallStackFunction(parseFunction);
t.equal(logger.parseCallStack, parseFunction);
logger.info('test parseCallStack');
t.equal(events[0].functionName, 'test function name');
t.equal(events[0].fileName, 'test file name');
t.equal(events[0].lineNumber, 15);
t.equal(events[0].columnNumber, 25);
t.equal(events[0].callStack, 'test callstack');
t.end();
});
batch.test('creating/cloning of category', (t) => {
const defaultLogger = new Logger('default');
defaultLogger.level = 'trace';
defaultLogger.useCallStack = true;
t.test(
'category should be cloned from parent/default if does not exist',
(assert) => {
const originalLength = categories.size;
const logger = new Logger('cheese1');
assert.equal(
categories.size,
originalLength + 1,
'category should be cloned'
);
assert.equal(
logger.level,
levels.TRACE,
'should inherit level=TRACE from default-category'
);
assert.equal(
logger.useCallStack,
true,
'should inherit useCallStack=true from default-category'
);
assert.end();
}
);
t.test(
'changing level should not impact default-category or useCallStack',
(assert) => {
const logger = new Logger('cheese2');
logger.level = 'debug';
assert.equal(
logger.level,
levels.DEBUG,
'should be changed to level=DEBUG'
);
assert.equal(
defaultLogger.level,
levels.TRACE,
'default-category should remain as level=TRACE'
);
assert.equal(
logger.useCallStack,
true,
'should remain as useCallStack=true'
);
assert.equal(
defaultLogger.useCallStack,
true,
'default-category should remain as useCallStack=true'
);
assert.end();
}
);
t.test(
'changing useCallStack should not impact default-category or level',
(assert) => {
const logger = new Logger('cheese3');
logger.useCallStack = false;
assert.equal(
logger.useCallStack,
false,
'should be changed to useCallStack=false'
);
assert.equal(
defaultLogger.useCallStack,
true,
'default-category should remain as useCallStack=true'
);
assert.equal(
logger.level,
levels.TRACE,
'should remain as level=TRACE'
);
assert.equal(
defaultLogger.level,
levels.TRACE,
'default-category should remain as level=TRACE'
);
assert.end();
}
);
t.end();
});
batch.end();
});
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./examples/loggly-appender.js | // Note that loggly appender needs node-loggly to work.
// If you haven't got node-loggly installed, you'll get cryptic
// "cannot find module" errors when using the loggly appender
const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
console: {
type: 'console',
},
loggly: {
type: 'loggly',
token: '12345678901234567890',
subdomain: 'your-subdomain',
tags: ['test'],
},
},
categories: {
default: { appenders: ['console'], level: 'info' },
loggly: { appenders: ['loggly'], level: 'info' },
},
});
const logger = log4js.getLogger('loggly');
logger.info('Test log message');
// logger.debug("Test log message");
| // Note that loggly appender needs node-loggly to work.
// If you haven't got node-loggly installed, you'll get cryptic
// "cannot find module" errors when using the loggly appender
const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
console: {
type: 'console',
},
loggly: {
type: 'loggly',
token: '12345678901234567890',
subdomain: 'your-subdomain',
tags: ['test'],
},
},
categories: {
default: { appenders: ['console'], level: 'info' },
loggly: { appenders: ['loggly'], level: 'info' },
},
});
const logger = log4js.getLogger('loggly');
logger.info('Test log message');
// logger.debug("Test log message");
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./lib/LoggingEvent.js | const flatted = require('flatted');
const levels = require('./levels');
/**
* @name LoggingEvent
* @namespace Log4js
*/
class LoggingEvent {
/**
* Models a logging event.
* @constructor
* @param {string} categoryName name of category
* @param {Log4js.Level} level level of message
* @param {Array} data objects to log
* @author Seth Chisamore
*/
constructor(categoryName, level, data, context, location) {
this.startTime = new Date();
this.categoryName = categoryName;
this.data = data;
this.level = level;
this.context = Object.assign({}, context); // eslint-disable-line prefer-object-spread
this.pid = process.pid;
if (location) {
this.functionName = location.functionName;
this.fileName = location.fileName;
this.lineNumber = location.lineNumber;
this.columnNumber = location.columnNumber;
this.callStack = location.callStack;
}
}
serialise() {
return flatted.stringify(this, (key, value) => {
// JSON.stringify(new Error('test')) returns {}, which is not really useful for us.
// The following allows us to serialize errors correctly.
// duck-typing for Error object
if (value && value.message && value.stack) {
// eslint-disable-next-line prefer-object-spread
value = Object.assign(
{ message: value.message, stack: value.stack },
value
);
}
// JSON.stringify({a: parseInt('abc'), b: 1/0, c: -1/0}) returns {a: null, b: null, c: null}.
// The following allows us to serialize to NaN, Infinity and -Infinity correctly.
else if (
typeof value === 'number' &&
(Number.isNaN(value) || !Number.isFinite(value))
) {
value = value.toString();
}
// JSON.stringify([undefined]) returns [null].
// The following allows us to serialize to undefined correctly.
else if (typeof value === 'undefined') {
value = typeof value;
}
return value;
});
}
static deserialise(serialised) {
let event;
try {
const rehydratedEvent = flatted.parse(serialised, (key, value) => {
if (value && value.message && value.stack) {
const fakeError = new Error(value);
Object.keys(value).forEach((k) => {
fakeError[k] = value[k];
});
value = fakeError;
}
return value;
});
rehydratedEvent.location = {
functionName: rehydratedEvent.functionName,
fileName: rehydratedEvent.fileName,
lineNumber: rehydratedEvent.lineNumber,
columnNumber: rehydratedEvent.columnNumber,
callStack: rehydratedEvent.callStack,
};
event = new LoggingEvent(
rehydratedEvent.categoryName,
levels.getLevel(rehydratedEvent.level.levelStr),
rehydratedEvent.data,
rehydratedEvent.context,
rehydratedEvent.location
);
event.startTime = new Date(rehydratedEvent.startTime);
event.pid = rehydratedEvent.pid;
event.cluster = rehydratedEvent.cluster;
} catch (e) {
event = new LoggingEvent('log4js', levels.ERROR, [
'Unable to parse log:',
serialised,
'because: ',
e,
]);
}
return event;
}
}
module.exports = LoggingEvent;
| const flatted = require('flatted');
const levels = require('./levels');
/**
* @name LoggingEvent
* @namespace Log4js
*/
class LoggingEvent {
/**
* Models a logging event.
* @constructor
* @param {string} categoryName name of category
* @param {Log4js.Level} level level of message
* @param {Array} data objects to log
* @author Seth Chisamore
*/
constructor(categoryName, level, data, context, location) {
this.startTime = new Date();
this.categoryName = categoryName;
this.data = data;
this.level = level;
this.context = Object.assign({}, context); // eslint-disable-line prefer-object-spread
this.pid = process.pid;
if (location) {
this.functionName = location.functionName;
this.fileName = location.fileName;
this.lineNumber = location.lineNumber;
this.columnNumber = location.columnNumber;
this.callStack = location.callStack;
}
}
serialise() {
return flatted.stringify(this, (key, value) => {
// JSON.stringify(new Error('test')) returns {}, which is not really useful for us.
// The following allows us to serialize errors correctly.
// duck-typing for Error object
if (value && value.message && value.stack) {
// eslint-disable-next-line prefer-object-spread
value = Object.assign(
{ message: value.message, stack: value.stack },
value
);
}
// JSON.stringify({a: parseInt('abc'), b: 1/0, c: -1/0}) returns {a: null, b: null, c: null}.
// The following allows us to serialize to NaN, Infinity and -Infinity correctly.
else if (
typeof value === 'number' &&
(Number.isNaN(value) || !Number.isFinite(value))
) {
value = value.toString();
}
// JSON.stringify([undefined]) returns [null].
// The following allows us to serialize to undefined correctly.
else if (typeof value === 'undefined') {
value = typeof value;
}
return value;
});
}
static deserialise(serialised) {
let event;
try {
const rehydratedEvent = flatted.parse(serialised, (key, value) => {
if (value && value.message && value.stack) {
const fakeError = new Error(value);
Object.keys(value).forEach((k) => {
fakeError[k] = value[k];
});
value = fakeError;
}
return value;
});
rehydratedEvent.location = {
functionName: rehydratedEvent.functionName,
fileName: rehydratedEvent.fileName,
lineNumber: rehydratedEvent.lineNumber,
columnNumber: rehydratedEvent.columnNumber,
callStack: rehydratedEvent.callStack,
};
event = new LoggingEvent(
rehydratedEvent.categoryName,
levels.getLevel(rehydratedEvent.level.levelStr),
rehydratedEvent.data,
rehydratedEvent.context,
rehydratedEvent.location
);
event.startTime = new Date(rehydratedEvent.startTime);
event.pid = rehydratedEvent.pid;
event.cluster = rehydratedEvent.cluster;
} catch (e) {
event = new LoggingEvent('log4js', levels.ERROR, [
'Unable to parse log:',
serialised,
'because: ',
e,
]);
}
return event;
}
}
module.exports = LoggingEvent;
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./examples/patternLayout-tokens.js | const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
out: {
type: 'console',
layout: {
type: 'pattern',
pattern: '%[%r (%x{pid}) %p %c -%] %m%n',
tokens: {
pid: function() {
return process.pid;
},
},
},
},
},
categories: {
default: { appenders: ['out'], level: 'info' },
},
});
const logger = log4js.getLogger('app');
logger.info('Test log message');
| const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
out: {
type: 'console',
layout: {
type: 'pattern',
pattern: '%[%r (%x{pid}) %p %c -%] %m%n',
tokens: {
pid: function() {
return process.pid;
},
},
},
},
},
categories: {
default: { appenders: ['out'], level: 'info' },
},
});
const logger = log4js.getLogger('app');
logger.info('Test log message');
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./examples/log-to-files.js | const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
file: {
type: 'file',
filename: 'important-things.log',
maxLogSize: 10 * 1024 * 1024, // = 10Mb
backups: 5, // keep five backup files
compress: true, // compress the backups
encoding: 'utf-8',
mode: 0o0640,
flags: 'w+',
},
dateFile: {
type: 'dateFile',
filename: 'more-important-things.log',
pattern: 'yyyy-MM-dd-hh',
compress: true,
},
out: {
type: 'stdout',
},
},
categories: {
default: { appenders: ['file', 'dateFile', 'out'], level: 'trace' },
},
});
const logger = log4js.getLogger('things');
logger.debug('This little thing went to market');
logger.info('This little thing stayed at home');
logger.error('This little thing had roast beef');
logger.fatal('This little thing had none');
logger.trace('and this little thing went wee, wee, wee, all the way home.');
| const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
file: {
type: 'file',
filename: 'important-things.log',
maxLogSize: 10 * 1024 * 1024, // = 10Mb
backups: 5, // keep five backup files
compress: true, // compress the backups
encoding: 'utf-8',
mode: 0o0640,
flags: 'w+',
},
dateFile: {
type: 'dateFile',
filename: 'more-important-things.log',
pattern: 'yyyy-MM-dd-hh',
compress: true,
},
out: {
type: 'stdout',
},
},
categories: {
default: { appenders: ['file', 'dateFile', 'out'], level: 'trace' },
},
});
const logger = log4js.getLogger('things');
logger.debug('This little thing went to market');
logger.info('This little thing stayed at home');
logger.error('This little thing had roast beef');
logger.fatal('This little thing had none');
logger.trace('and this little thing went wee, wee, wee, all the way home.');
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./examples/custom-layout.js | const log4js = require('../lib/log4js');
log4js.addLayout(
'json',
(config) =>
function(logEvent) {
return JSON.stringify(logEvent) + config.separator;
}
);
log4js.configure({
appenders: {
out: { type: 'stdout', layout: { type: 'json', separator: ',' } },
},
categories: {
default: { appenders: ['out'], level: 'info' },
},
});
const logger = log4js.getLogger('json-test');
logger.info('this is just a test');
logger.error('of a custom appender');
logger.warn('that outputs json');
log4js.shutdown(() => {});
| const log4js = require('../lib/log4js');
log4js.addLayout(
'json',
(config) =>
function(logEvent) {
return JSON.stringify(logEvent) + config.separator;
}
);
log4js.configure({
appenders: {
out: { type: 'stdout', layout: { type: 'json', separator: ',' } },
},
categories: {
default: { appenders: ['out'], level: 'info' },
},
});
const logger = log4js.getLogger('json-test');
logger.info('this is just a test');
logger.error('of a custom appender');
logger.warn('that outputs json');
log4js.shutdown(() => {});
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/connect-logger-test.js | /* eslint max-classes-per-file: ["error", 2] */
const { test } = require('tap');
const EE = require('events').EventEmitter;
const levels = require('../../lib/levels');
class MockLogger {
constructor() {
this.level = levels.TRACE;
this.messages = [];
this.log = function(level, message) {
this.messages.push({ level, message });
};
this.isLevelEnabled = function(level) {
return level.isGreaterThanOrEqualTo(this.level);
};
}
}
function MockRequest(remoteAddr, method, originalUrl, headers, url, custom) {
this.socket = { remoteAddress: remoteAddr };
this.originalUrl = originalUrl;
this.url = url;
this.method = method;
this.httpVersionMajor = '5';
this.httpVersionMinor = '0';
this.headers = headers || {};
if (custom) {
for (const key of Object.keys(custom)) {
this[key] = custom[key];
}
}
const self = this;
Object.keys(this.headers).forEach((key) => {
self.headers[key.toLowerCase()] = self.headers[key];
});
}
class MockResponse extends EE {
constructor() {
super();
this.cachedHeaders = {};
}
end() {
this.emit('finish');
}
setHeader(key, value) {
this.cachedHeaders[key.toLowerCase()] = value;
}
getHeader(key) {
return this.cachedHeaders[key.toLowerCase()];
}
writeHead(code /* , headers */) {
this.statusCode = code;
}
}
function request(
cl,
method,
originalUrl,
code,
reqHeaders,
resHeaders,
next,
url,
custom = undefined
) {
const req = new MockRequest(
'my.remote.addr',
method,
originalUrl,
reqHeaders,
url,
custom
);
const res = new MockResponse();
if (next) {
next = next.bind(null, req, res, () => {});
} else {
next = () => {};
}
cl(req, res, next);
res.writeHead(code, resHeaders);
res.end('chunk', 'encoding');
}
test('log4js connect logger', (batch) => {
const clm = require('../../lib/connect-logger');
batch.test('getConnectLoggerModule', (t) => {
t.type(clm, 'function', 'should return a connect logger factory');
t.test(
'should take a log4js logger and return a "connect logger"',
(assert) => {
const ml = new MockLogger();
const cl = clm(ml);
assert.type(cl, 'function');
assert.end();
}
);
t.test('log events', (assert) => {
const ml = new MockLogger();
const cl = clm(ml);
request(cl, 'GET', 'http://url', 200);
const { messages } = ml;
assert.type(messages, 'Array');
assert.equal(messages.length, 1);
assert.ok(levels.INFO.isEqualTo(messages[0].level));
assert.match(messages[0].message, 'GET');
assert.match(messages[0].message, 'http://url');
assert.match(messages[0].message, 'my.remote.addr');
assert.match(messages[0].message, '200');
assert.end();
});
t.test('log events with level below logging level', (assert) => {
const ml = new MockLogger();
ml.level = levels.FATAL;
const cl = clm(ml);
request(cl, 'GET', 'http://url', 200);
assert.type(ml.messages, 'Array');
assert.equal(ml.messages.length, 0);
assert.end();
});
t.test('log events with non-default level and custom format', (assert) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, { level: levels.WARN, format: ':method :url' });
request(cl, 'GET', 'http://url', 200);
const { messages } = ml;
assert.type(messages, Array);
assert.equal(messages.length, 1);
assert.ok(levels.WARN.isEqualTo(messages[0].level));
assert.equal(messages[0].message, 'GET http://url');
assert.end();
});
t.test('adding multiple loggers should only log once', (assert) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, { level: levels.WARN, format: ':method :url' });
const nextLogger = clm(ml, { level: levels.INFO, format: ':method' });
request(cl, 'GET', 'http://url', 200, null, null, nextLogger);
const { messages } = ml;
assert.type(messages, Array);
assert.equal(messages.length, 1);
assert.ok(levels.WARN.isEqualTo(messages[0].level));
assert.equal(messages[0].message, 'GET http://url');
assert.end();
});
t.end();
});
batch.test('logger with options as string', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, ':method :url');
request(cl, 'POST', 'http://meh', 200);
const { messages } = ml;
t.equal(messages[0].message, 'POST http://meh');
t.end();
});
batch.test('auto log levels', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, { level: 'auto', format: ':method :url' });
request(cl, 'GET', 'http://meh', 200);
request(cl, 'GET', 'http://meh', 201);
request(cl, 'GET', 'http://meh', 302);
request(cl, 'GET', 'http://meh', 404);
request(cl, 'GET', 'http://meh', 500);
const { messages } = ml;
t.test('should use INFO for 2xx', (assert) => {
assert.ok(levels.INFO.isEqualTo(messages[0].level));
assert.ok(levels.INFO.isEqualTo(messages[1].level));
assert.end();
});
t.test('should use WARN for 3xx', (assert) => {
assert.ok(levels.WARN.isEqualTo(messages[2].level));
assert.end();
});
t.test('should use ERROR for 4xx', (assert) => {
assert.ok(levels.ERROR.isEqualTo(messages[3].level));
assert.end();
});
t.test('should use ERROR for 5xx', (assert) => {
assert.ok(levels.ERROR.isEqualTo(messages[4].level));
assert.end();
});
t.end();
});
batch.test('logger with status code rules applied', (t) => {
const ml = new MockLogger();
ml.level = levels.DEBUG;
const clr = [
{ codes: [201, 304], level: levels.DEBUG.toString() },
{ from: 200, to: 299, level: levels.DEBUG.toString() },
{ from: 300, to: 399, level: levels.INFO.toString() },
];
const cl = clm(ml, {
level: 'auto',
format: ':method :url',
statusRules: clr,
});
request(cl, 'GET', 'http://meh', 200);
request(cl, 'GET', 'http://meh', 201);
request(cl, 'GET', 'http://meh', 302);
request(cl, 'GET', 'http://meh', 304);
request(cl, 'GET', 'http://meh', 404);
request(cl, 'GET', 'http://meh', 500);
const { messages } = ml;
t.test('should use DEBUG for 2xx', (assert) => {
assert.ok(levels.DEBUG.isEqualTo(messages[0].level));
assert.ok(levels.DEBUG.isEqualTo(messages[1].level));
assert.end();
});
t.test('should use WARN for 3xx, DEBUG for 304', (assert) => {
assert.ok(levels.INFO.isEqualTo(messages[2].level));
assert.ok(levels.DEBUG.isEqualTo(messages[3].level));
assert.end();
});
t.test('should use ERROR for 4xx', (assert) => {
assert.ok(levels.ERROR.isEqualTo(messages[4].level));
assert.end();
});
t.test('should use ERROR for 5xx', (assert) => {
assert.ok(levels.ERROR.isEqualTo(messages[5].level));
assert.end();
});
t.end();
});
batch.test('format using a function', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, () => 'I was called');
request(cl, 'GET', 'http://blah', 200);
t.equal(ml.messages[0].message, 'I was called');
t.end();
});
batch.test('format using a function that also uses tokens', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(
ml,
(req, res, tokenReplacer) => `${req.method} ${tokenReplacer(':status')}`
);
request(cl, 'GET', 'http://blah', 200);
t.equal(ml.messages[0].message, 'GET 200');
t.end();
});
batch.test(
'format using a function, but do not log anything if the function returns nothing',
(t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, () => null);
request(cl, 'GET', 'http://blah', 200);
t.equal(ml.messages.length, 0);
t.end();
}
);
batch.test('format that includes request headers', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, ':req[Content-Type]');
request(cl, 'GET', 'http://blah', 200, {
'Content-Type': 'application/json',
});
t.equal(ml.messages[0].message, 'application/json');
t.end();
});
batch.test('format that includes response headers', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, ':res[Content-Type]');
request(cl, 'GET', 'http://blah', 200, null, {
'Content-Type': 'application/cheese',
});
t.equal(ml.messages[0].message, 'application/cheese');
t.end();
});
batch.test('url token should check originalUrl and url', (t) => {
const ml = new MockLogger();
const cl = clm(ml, ':url');
request(cl, 'GET', null, 200, null, null, null, 'http://cheese');
t.equal(ml.messages[0].message, 'http://cheese');
t.end();
});
batch.test('log events with custom token', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, {
level: levels.INFO,
format: ':method :url :custom_string',
tokens: [
{
token: ':custom_string',
replacement: 'fooBAR',
},
],
});
request(cl, 'GET', 'http://url', 200);
t.type(ml.messages, 'Array');
t.equal(ml.messages.length, 1);
t.ok(levels.INFO.isEqualTo(ml.messages[0].level));
t.equal(ml.messages[0].message, 'GET http://url fooBAR');
t.end();
});
batch.test('log events with custom override token', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, {
level: levels.INFO,
format: ':method :url :date',
tokens: [
{
token: ':date',
replacement: '20150310',
},
],
});
request(cl, 'GET', 'http://url', 200);
t.type(ml.messages, 'Array');
t.equal(ml.messages.length, 1);
t.ok(levels.INFO.isEqualTo(ml.messages[0].level));
t.equal(ml.messages[0].message, 'GET http://url 20150310');
t.end();
});
batch.test('log events with custom format', (t) => {
const ml = new MockLogger();
const body = { say: 'hi!' };
ml.level = levels.INFO;
const cl = clm(ml, {
level: levels.INFO,
format: (req, res, format) =>
format(`:method :url ${JSON.stringify(req.body)}`),
});
request(
cl,
'POST',
'http://url',
200,
{ 'Content-Type': 'application/json' },
null,
null,
null,
{ body }
);
t.ok(levels.INFO.isEqualTo(ml.messages[0].level));
t.equal(ml.messages[0].message, `POST http://url ${JSON.stringify(body)}`);
t.end();
});
batch.test(
'handle weird old node versions where socket contains socket',
(t) => {
const ml = new MockLogger();
const cl = clm(ml, ':remote-addr');
const req = new MockRequest(null, 'GET', 'http://blah');
req.socket = { socket: { remoteAddress: 'this is weird' } };
const res = new MockResponse();
cl(req, res, () => {});
res.writeHead(200, {});
res.end('chunk', 'encoding');
t.equal(ml.messages[0].message, 'this is weird');
t.end();
}
);
batch.test(
'handles as soon as any of the events end/finish/error/close triggers (only once)',
(t) => {
const ml = new MockLogger();
const cl = clm(ml, ':remote-addr');
const req = new MockRequest(null, 'GET', 'http://blah');
req.socket = { socket: { remoteAddress: 'this is weird' } };
const res = new MockResponse();
cl(req, res, () => {});
res.writeHead(200, {});
t.equal(ml.messages.length, 0);
res.emit('end');
res.emit('finish');
res.emit('error');
res.emit('close');
t.equal(ml.messages.length, 1);
t.equal(ml.messages[0].message, 'this is weird');
t.end();
}
);
batch.end();
});
| /* eslint max-classes-per-file: ["error", 2] */
const { test } = require('tap');
const EE = require('events').EventEmitter;
const levels = require('../../lib/levels');
class MockLogger {
constructor() {
this.level = levels.TRACE;
this.messages = [];
this.log = function(level, message) {
this.messages.push({ level, message });
};
this.isLevelEnabled = function(level) {
return level.isGreaterThanOrEqualTo(this.level);
};
}
}
function MockRequest(remoteAddr, method, originalUrl, headers, url, custom) {
this.socket = { remoteAddress: remoteAddr };
this.originalUrl = originalUrl;
this.url = url;
this.method = method;
this.httpVersionMajor = '5';
this.httpVersionMinor = '0';
this.headers = headers || {};
if (custom) {
for (const key of Object.keys(custom)) {
this[key] = custom[key];
}
}
const self = this;
Object.keys(this.headers).forEach((key) => {
self.headers[key.toLowerCase()] = self.headers[key];
});
}
class MockResponse extends EE {
constructor() {
super();
this.cachedHeaders = {};
}
end() {
this.emit('finish');
}
setHeader(key, value) {
this.cachedHeaders[key.toLowerCase()] = value;
}
getHeader(key) {
return this.cachedHeaders[key.toLowerCase()];
}
writeHead(code /* , headers */) {
this.statusCode = code;
}
}
function request(
cl,
method,
originalUrl,
code,
reqHeaders,
resHeaders,
next,
url,
custom = undefined
) {
const req = new MockRequest(
'my.remote.addr',
method,
originalUrl,
reqHeaders,
url,
custom
);
const res = new MockResponse();
if (next) {
next = next.bind(null, req, res, () => {});
} else {
next = () => {};
}
cl(req, res, next);
res.writeHead(code, resHeaders);
res.end('chunk', 'encoding');
}
test('log4js connect logger', (batch) => {
const clm = require('../../lib/connect-logger');
batch.test('getConnectLoggerModule', (t) => {
t.type(clm, 'function', 'should return a connect logger factory');
t.test(
'should take a log4js logger and return a "connect logger"',
(assert) => {
const ml = new MockLogger();
const cl = clm(ml);
assert.type(cl, 'function');
assert.end();
}
);
t.test('log events', (assert) => {
const ml = new MockLogger();
const cl = clm(ml);
request(cl, 'GET', 'http://url', 200);
const { messages } = ml;
assert.type(messages, 'Array');
assert.equal(messages.length, 1);
assert.ok(levels.INFO.isEqualTo(messages[0].level));
assert.match(messages[0].message, 'GET');
assert.match(messages[0].message, 'http://url');
assert.match(messages[0].message, 'my.remote.addr');
assert.match(messages[0].message, '200');
assert.end();
});
t.test('log events with level below logging level', (assert) => {
const ml = new MockLogger();
ml.level = levels.FATAL;
const cl = clm(ml);
request(cl, 'GET', 'http://url', 200);
assert.type(ml.messages, 'Array');
assert.equal(ml.messages.length, 0);
assert.end();
});
t.test('log events with non-default level and custom format', (assert) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, { level: levels.WARN, format: ':method :url' });
request(cl, 'GET', 'http://url', 200);
const { messages } = ml;
assert.type(messages, Array);
assert.equal(messages.length, 1);
assert.ok(levels.WARN.isEqualTo(messages[0].level));
assert.equal(messages[0].message, 'GET http://url');
assert.end();
});
t.test('adding multiple loggers should only log once', (assert) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, { level: levels.WARN, format: ':method :url' });
const nextLogger = clm(ml, { level: levels.INFO, format: ':method' });
request(cl, 'GET', 'http://url', 200, null, null, nextLogger);
const { messages } = ml;
assert.type(messages, Array);
assert.equal(messages.length, 1);
assert.ok(levels.WARN.isEqualTo(messages[0].level));
assert.equal(messages[0].message, 'GET http://url');
assert.end();
});
t.end();
});
batch.test('logger with options as string', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, ':method :url');
request(cl, 'POST', 'http://meh', 200);
const { messages } = ml;
t.equal(messages[0].message, 'POST http://meh');
t.end();
});
batch.test('auto log levels', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, { level: 'auto', format: ':method :url' });
request(cl, 'GET', 'http://meh', 200);
request(cl, 'GET', 'http://meh', 201);
request(cl, 'GET', 'http://meh', 302);
request(cl, 'GET', 'http://meh', 404);
request(cl, 'GET', 'http://meh', 500);
const { messages } = ml;
t.test('should use INFO for 2xx', (assert) => {
assert.ok(levels.INFO.isEqualTo(messages[0].level));
assert.ok(levels.INFO.isEqualTo(messages[1].level));
assert.end();
});
t.test('should use WARN for 3xx', (assert) => {
assert.ok(levels.WARN.isEqualTo(messages[2].level));
assert.end();
});
t.test('should use ERROR for 4xx', (assert) => {
assert.ok(levels.ERROR.isEqualTo(messages[3].level));
assert.end();
});
t.test('should use ERROR for 5xx', (assert) => {
assert.ok(levels.ERROR.isEqualTo(messages[4].level));
assert.end();
});
t.end();
});
batch.test('logger with status code rules applied', (t) => {
const ml = new MockLogger();
ml.level = levels.DEBUG;
const clr = [
{ codes: [201, 304], level: levels.DEBUG.toString() },
{ from: 200, to: 299, level: levels.DEBUG.toString() },
{ from: 300, to: 399, level: levels.INFO.toString() },
];
const cl = clm(ml, {
level: 'auto',
format: ':method :url',
statusRules: clr,
});
request(cl, 'GET', 'http://meh', 200);
request(cl, 'GET', 'http://meh', 201);
request(cl, 'GET', 'http://meh', 302);
request(cl, 'GET', 'http://meh', 304);
request(cl, 'GET', 'http://meh', 404);
request(cl, 'GET', 'http://meh', 500);
const { messages } = ml;
t.test('should use DEBUG for 2xx', (assert) => {
assert.ok(levels.DEBUG.isEqualTo(messages[0].level));
assert.ok(levels.DEBUG.isEqualTo(messages[1].level));
assert.end();
});
t.test('should use WARN for 3xx, DEBUG for 304', (assert) => {
assert.ok(levels.INFO.isEqualTo(messages[2].level));
assert.ok(levels.DEBUG.isEqualTo(messages[3].level));
assert.end();
});
t.test('should use ERROR for 4xx', (assert) => {
assert.ok(levels.ERROR.isEqualTo(messages[4].level));
assert.end();
});
t.test('should use ERROR for 5xx', (assert) => {
assert.ok(levels.ERROR.isEqualTo(messages[5].level));
assert.end();
});
t.end();
});
batch.test('format using a function', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, () => 'I was called');
request(cl, 'GET', 'http://blah', 200);
t.equal(ml.messages[0].message, 'I was called');
t.end();
});
batch.test('format using a function that also uses tokens', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(
ml,
(req, res, tokenReplacer) => `${req.method} ${tokenReplacer(':status')}`
);
request(cl, 'GET', 'http://blah', 200);
t.equal(ml.messages[0].message, 'GET 200');
t.end();
});
batch.test(
'format using a function, but do not log anything if the function returns nothing',
(t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, () => null);
request(cl, 'GET', 'http://blah', 200);
t.equal(ml.messages.length, 0);
t.end();
}
);
batch.test('format that includes request headers', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, ':req[Content-Type]');
request(cl, 'GET', 'http://blah', 200, {
'Content-Type': 'application/json',
});
t.equal(ml.messages[0].message, 'application/json');
t.end();
});
batch.test('format that includes response headers', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, ':res[Content-Type]');
request(cl, 'GET', 'http://blah', 200, null, {
'Content-Type': 'application/cheese',
});
t.equal(ml.messages[0].message, 'application/cheese');
t.end();
});
batch.test('url token should check originalUrl and url', (t) => {
const ml = new MockLogger();
const cl = clm(ml, ':url');
request(cl, 'GET', null, 200, null, null, null, 'http://cheese');
t.equal(ml.messages[0].message, 'http://cheese');
t.end();
});
batch.test('log events with custom token', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, {
level: levels.INFO,
format: ':method :url :custom_string',
tokens: [
{
token: ':custom_string',
replacement: 'fooBAR',
},
],
});
request(cl, 'GET', 'http://url', 200);
t.type(ml.messages, 'Array');
t.equal(ml.messages.length, 1);
t.ok(levels.INFO.isEqualTo(ml.messages[0].level));
t.equal(ml.messages[0].message, 'GET http://url fooBAR');
t.end();
});
batch.test('log events with custom override token', (t) => {
const ml = new MockLogger();
ml.level = levels.INFO;
const cl = clm(ml, {
level: levels.INFO,
format: ':method :url :date',
tokens: [
{
token: ':date',
replacement: '20150310',
},
],
});
request(cl, 'GET', 'http://url', 200);
t.type(ml.messages, 'Array');
t.equal(ml.messages.length, 1);
t.ok(levels.INFO.isEqualTo(ml.messages[0].level));
t.equal(ml.messages[0].message, 'GET http://url 20150310');
t.end();
});
batch.test('log events with custom format', (t) => {
const ml = new MockLogger();
const body = { say: 'hi!' };
ml.level = levels.INFO;
const cl = clm(ml, {
level: levels.INFO,
format: (req, res, format) =>
format(`:method :url ${JSON.stringify(req.body)}`),
});
request(
cl,
'POST',
'http://url',
200,
{ 'Content-Type': 'application/json' },
null,
null,
null,
{ body }
);
t.ok(levels.INFO.isEqualTo(ml.messages[0].level));
t.equal(ml.messages[0].message, `POST http://url ${JSON.stringify(body)}`);
t.end();
});
batch.test(
'handle weird old node versions where socket contains socket',
(t) => {
const ml = new MockLogger();
const cl = clm(ml, ':remote-addr');
const req = new MockRequest(null, 'GET', 'http://blah');
req.socket = { socket: { remoteAddress: 'this is weird' } };
const res = new MockResponse();
cl(req, res, () => {});
res.writeHead(200, {});
res.end('chunk', 'encoding');
t.equal(ml.messages[0].message, 'this is weird');
t.end();
}
);
batch.test(
'handles as soon as any of the events end/finish/error/close triggers (only once)',
(t) => {
const ml = new MockLogger();
const cl = clm(ml, ':remote-addr');
const req = new MockRequest(null, 'GET', 'http://blah');
req.socket = { socket: { remoteAddress: 'this is weird' } };
const res = new MockResponse();
cl(req, res, () => {});
res.writeHead(200, {});
t.equal(ml.messages.length, 0);
res.emit('end');
res.emit('finish');
res.emit('error');
res.emit('close');
t.equal(ml.messages.length, 1);
t.equal(ml.messages[0].message, 'this is weird');
t.end();
}
);
batch.end();
});
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/passenger-test.js | const { test } = require('tap');
const sandbox = require('@log4js-node/sandboxed-module');
// passenger provides a non-functional cluster module,
// but it does not implement the event emitter functions
const passengerCluster = {
disconnect() {
return false;
},
fork() {
return false;
},
setupMaster() {
return false;
},
isWorker: true,
isMaster: false,
schedulingPolicy: false,
settings: false,
worker: false,
workers: false,
};
const vcr = require('../../lib/appenders/recording');
const log4js = sandbox.require('../../lib/log4js', {
requires: {
cluster: passengerCluster,
'./appenders/recording': vcr,
},
});
test('When running in Passenger', (batch) => {
batch.test('it should still log', (t) => {
log4js.configure({
appenders: {
vcr: { type: 'recording' },
},
categories: {
default: { appenders: ['vcr'], level: 'info' },
},
disableClustering: true,
});
log4js.getLogger().info('This should still work');
const events = vcr.replay();
t.equal(events.length, 1);
t.equal(events[0].data[0], 'This should still work');
t.end();
});
batch.end();
});
| const { test } = require('tap');
const sandbox = require('@log4js-node/sandboxed-module');
// passenger provides a non-functional cluster module,
// but it does not implement the event emitter functions
const passengerCluster = {
disconnect() {
return false;
},
fork() {
return false;
},
setupMaster() {
return false;
},
isWorker: true,
isMaster: false,
schedulingPolicy: false,
settings: false,
worker: false,
workers: false,
};
const vcr = require('../../lib/appenders/recording');
const log4js = sandbox.require('../../lib/log4js', {
requires: {
cluster: passengerCluster,
'./appenders/recording': vcr,
},
});
test('When running in Passenger', (batch) => {
batch.test('it should still log', (t) => {
log4js.configure({
appenders: {
vcr: { type: 'recording' },
},
categories: {
default: { appenders: ['vcr'], level: 'info' },
},
disableClustering: true,
});
log4js.getLogger().info('This should still work');
const events = vcr.replay();
t.equal(events.length, 1);
t.equal(events[0].data[0], 'This should still work');
t.end();
});
batch.end();
});
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./lib/appenders/stderr.js | function stderrAppender(layout, timezoneOffset) {
return (loggingEvent) => {
process.stderr.write(`${layout(loggingEvent, timezoneOffset)}\n`);
};
}
function configure(config, layouts) {
let layout = layouts.colouredLayout;
if (config.layout) {
layout = layouts.layout(config.layout.type, config.layout);
}
return stderrAppender(layout, config.timezoneOffset);
}
module.exports.configure = configure;
| function stderrAppender(layout, timezoneOffset) {
return (loggingEvent) => {
process.stderr.write(`${layout(loggingEvent, timezoneOffset)}\n`);
};
}
function configure(config, layouts) {
let layout = layouts.colouredLayout;
if (config.layout) {
layout = layouts.layout(config.layout.type, config.layout);
}
return stderrAppender(layout, config.timezoneOffset);
}
module.exports.configure = configure;
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/setLevel-asymmetry-test.js | // This test shows an asymmetry between setLevel and isLevelEnabled
// (in log4js-node@0.4.3 and earlier):
// 1) setLevel("foo") works, but setLevel(log4js.levels.foo) silently
// does not (sets the level to TRACE).
// 2) isLevelEnabled("foo") works as does isLevelEnabled(log4js.levels.foo).
//
const { test } = require('tap');
const log4js = require('../../lib/log4js');
const logger = log4js.getLogger('test-setLevel-asymmetry');
// Define the array of levels as string to iterate over.
const strLevels = ['Trace', 'Debug', 'Info', 'Warn', 'Error', 'Fatal'];
const log4jsLevels = strLevels.map(log4js.levels.getLevel);
test('log4js setLevel', (batch) => {
strLevels.forEach((strLevel) => {
batch.test(`is called with a ${strLevel} as string`, (t) => {
const log4jsLevel = log4js.levels.getLevel(strLevel);
t.test('should convert string to level correctly', (assert) => {
logger.level = strLevel;
log4jsLevels.forEach((level) => {
assert.equal(
logger.isLevelEnabled(level),
log4jsLevel.isLessThanOrEqualTo(level)
);
});
assert.end();
});
t.test('should also accept a Level', (assert) => {
logger.level = log4jsLevel;
log4jsLevels.forEach((level) => {
assert.equal(
logger.isLevelEnabled(level),
log4jsLevel.isLessThanOrEqualTo(level)
);
});
assert.end();
});
t.end();
});
});
batch.end();
});
| // This test shows an asymmetry between setLevel and isLevelEnabled
// (in log4js-node@0.4.3 and earlier):
// 1) setLevel("foo") works, but setLevel(log4js.levels.foo) silently
// does not (sets the level to TRACE).
// 2) isLevelEnabled("foo") works as does isLevelEnabled(log4js.levels.foo).
//
const { test } = require('tap');
const log4js = require('../../lib/log4js');
const logger = log4js.getLogger('test-setLevel-asymmetry');
// Define the array of levels as string to iterate over.
const strLevels = ['Trace', 'Debug', 'Info', 'Warn', 'Error', 'Fatal'];
const log4jsLevels = strLevels.map(log4js.levels.getLevel);
test('log4js setLevel', (batch) => {
strLevels.forEach((strLevel) => {
batch.test(`is called with a ${strLevel} as string`, (t) => {
const log4jsLevel = log4js.levels.getLevel(strLevel);
t.test('should convert string to level correctly', (assert) => {
logger.level = strLevel;
log4jsLevels.forEach((level) => {
assert.equal(
logger.isLevelEnabled(level),
log4jsLevel.isLessThanOrEqualTo(level)
);
});
assert.end();
});
t.test('should also accept a Level', (assert) => {
logger.level = log4jsLevel;
log4jsLevels.forEach((level) => {
assert.equal(
logger.isLevelEnabled(level),
log4jsLevel.isLessThanOrEqualTo(level)
);
});
assert.end();
});
t.end();
});
});
batch.end();
});
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./lib/appenders/dateFile.js | const streams = require('streamroller');
const os = require('os');
const eol = os.EOL;
function openTheStream(filename, pattern, options) {
const stream = new streams.DateRollingFileStream(filename, pattern, options);
stream.on('error', (err) => {
// eslint-disable-next-line no-console
console.error(
'log4js.dateFileAppender - Writing to file %s, error happened ',
filename,
err
);
});
stream.on('drain', () => {
process.emit('log4js:pause', false);
});
return stream;
}
/**
* File appender that rolls files according to a date pattern.
* @param filename base filename.
* @param pattern the format that will be added to the end of filename when rolling,
* also used to check when to roll files - defaults to '.yyyy-MM-dd'
* @param layout layout function for log messages - defaults to basicLayout
* @param options - options to be passed to the underlying stream
* @param timezoneOffset - optional timezone offset in minutes (default system local)
*/
function appender(filename, pattern, layout, options, timezoneOffset) {
// the options for file appender use maxLogSize, but the docs say any file appender
// options should work for dateFile as well.
options.maxSize = options.maxLogSize;
const writer = openTheStream(filename, pattern, options);
const app = function(logEvent) {
if (!writer.writable) {
return;
}
if (!writer.write(layout(logEvent, timezoneOffset) + eol, 'utf8')) {
process.emit('log4js:pause', true);
}
};
app.shutdown = function(complete) {
writer.end('', 'utf-8', complete);
};
return app;
}
function configure(config, layouts) {
let layout = layouts.basicLayout;
if (config.layout) {
layout = layouts.layout(config.layout.type, config.layout);
}
if (!config.alwaysIncludePattern) {
config.alwaysIncludePattern = false;
}
// security default (instead of relying on streamroller default)
config.mode = config.mode || 0o600;
return appender(
config.filename,
config.pattern,
layout,
config,
config.timezoneOffset
);
}
module.exports.configure = configure;
| const streams = require('streamroller');
const os = require('os');
const eol = os.EOL;
function openTheStream(filename, pattern, options) {
const stream = new streams.DateRollingFileStream(filename, pattern, options);
stream.on('error', (err) => {
// eslint-disable-next-line no-console
console.error(
'log4js.dateFileAppender - Writing to file %s, error happened ',
filename,
err
);
});
stream.on('drain', () => {
process.emit('log4js:pause', false);
});
return stream;
}
/**
* File appender that rolls files according to a date pattern.
* @param filename base filename.
* @param pattern the format that will be added to the end of filename when rolling,
* also used to check when to roll files - defaults to '.yyyy-MM-dd'
* @param layout layout function for log messages - defaults to basicLayout
* @param options - options to be passed to the underlying stream
* @param timezoneOffset - optional timezone offset in minutes (default system local)
*/
function appender(filename, pattern, layout, options, timezoneOffset) {
// the options for file appender use maxLogSize, but the docs say any file appender
// options should work for dateFile as well.
options.maxSize = options.maxLogSize;
const writer = openTheStream(filename, pattern, options);
const app = function(logEvent) {
if (!writer.writable) {
return;
}
if (!writer.write(layout(logEvent, timezoneOffset) + eol, 'utf8')) {
process.emit('log4js:pause', true);
}
};
app.shutdown = function(complete) {
writer.end('', 'utf-8', complete);
};
return app;
}
function configure(config, layouts) {
let layout = layouts.basicLayout;
if (config.layout) {
layout = layouts.layout(config.layout.type, config.layout);
}
if (!config.alwaysIncludePattern) {
config.alwaysIncludePattern = false;
}
// security default (instead of relying on streamroller default)
config.mode = config.mode || 0o600;
return appender(
config.filename,
config.pattern,
layout,
config,
config.timezoneOffset
);
}
module.exports.configure = configure;
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./lib/layouts.js | const dateFormat = require('date-format');
const os = require('os');
const util = require('util');
const path = require('path');
const url = require('url');
const debug = require('debug')('log4js:layouts');
const styles = {
// styles
bold: [1, 22],
italic: [3, 23],
underline: [4, 24],
inverse: [7, 27],
// grayscale
white: [37, 39],
grey: [90, 39],
black: [90, 39],
// colors
blue: [34, 39],
cyan: [36, 39],
green: [32, 39],
magenta: [35, 39],
red: [91, 39],
yellow: [33, 39],
};
function colorizeStart(style) {
return style ? `\x1B[${styles[style][0]}m` : '';
}
function colorizeEnd(style) {
return style ? `\x1B[${styles[style][1]}m` : '';
}
/**
* Taken from masylum's fork (https://github.com/masylum/log4js-node)
*/
function colorize(str, style) {
return colorizeStart(style) + str + colorizeEnd(style);
}
function timestampLevelAndCategory(loggingEvent, colour) {
return colorize(
util.format(
'[%s] [%s] %s - ',
dateFormat.asString(loggingEvent.startTime),
loggingEvent.level.toString(),
loggingEvent.categoryName
),
colour
);
}
/**
* BasicLayout is a simple layout for storing the logs. The logs are stored
* in following format:
* <pre>
* [startTime] [logLevel] categoryName - message\n
* </pre>
*
* @author Stephan Strittmatter
*/
function basicLayout(loggingEvent) {
return (
timestampLevelAndCategory(loggingEvent) + util.format(...loggingEvent.data)
);
}
/**
* colouredLayout - taken from masylum's fork.
* same as basicLayout, but with colours.
*/
function colouredLayout(loggingEvent) {
return (
timestampLevelAndCategory(loggingEvent, loggingEvent.level.colour) +
util.format(...loggingEvent.data)
);
}
function messagePassThroughLayout(loggingEvent) {
return util.format(...loggingEvent.data);
}
function dummyLayout(loggingEvent) {
return loggingEvent.data[0];
}
/**
* PatternLayout
* Format for specifiers is %[padding].[truncation][field]{[format]}
* e.g. %5.10p - left pad the log level by 5 characters, up to a max of 10
* both padding and truncation can be negative.
* Negative truncation = trunc from end of string
* Positive truncation = trunc from start of string
* Negative padding = pad right
* Positive padding = pad left
*
* Fields can be any of:
* - %r time in toLocaleTimeString format
* - %p log level
* - %c log category
* - %h hostname
* - %m log data
* - %d date in constious formats
* - %% %
* - %n newline
* - %z pid
* - %f filename
* - %l line number
* - %o column postion
* - %s call stack
* - %x{<tokenname>} add dynamic tokens to your log. Tokens are specified in the tokens parameter
* - %X{<tokenname>} add dynamic tokens to your log. Tokens are specified in logger context
* You can use %[ and %] to define a colored block.
*
* Tokens are specified as simple key:value objects.
* The key represents the token name whereas the value can be a string or function
* which is called to extract the value to put in the log message. If token is not
* found, it doesn't replace the field.
*
* A sample token would be: { 'pid' : function() { return process.pid; } }
*
* Takes a pattern string, array of tokens and returns a layout function.
* @return {Function}
* @param pattern
* @param tokens
* @param timezoneOffset
*
* @authors ['Stephan Strittmatter', 'Jan Schmidle']
*/
function patternLayout(pattern, tokens) {
const TTCC_CONVERSION_PATTERN = '%r %p %c - %m%n';
const regex = /%(-?[0-9]+)?(\.?-?[0-9]+)?([[\]cdhmnprzxXyflos%])(\{([^}]+)\})?|([^%]+)/;
pattern = pattern || TTCC_CONVERSION_PATTERN;
function categoryName(loggingEvent, specifier) {
let loggerName = loggingEvent.categoryName;
if (specifier) {
const precision = parseInt(specifier, 10);
const loggerNameBits = loggerName.split('.');
if (precision < loggerNameBits.length) {
loggerName = loggerNameBits
.slice(loggerNameBits.length - precision)
.join('.');
}
}
return loggerName;
}
function formatAsDate(loggingEvent, specifier) {
let format = dateFormat.ISO8601_FORMAT;
if (specifier) {
format = specifier;
// Pick up special cases
switch (format) {
case 'ISO8601':
case 'ISO8601_FORMAT':
format = dateFormat.ISO8601_FORMAT;
break;
case 'ISO8601_WITH_TZ_OFFSET':
case 'ISO8601_WITH_TZ_OFFSET_FORMAT':
format = dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT;
break;
case 'ABSOLUTE':
process.emitWarning(
'Pattern %d{ABSOLUTE} is deprecated in favor of %d{ABSOLUTETIME}. ' +
'Please use %d{ABSOLUTETIME} instead.',
'DeprecationWarning',
'log4js-node-DEP0003'
);
debug(
'[log4js-node-DEP0003]',
'DEPRECATION: Pattern %d{ABSOLUTE} is deprecated and replaced by %d{ABSOLUTETIME}.'
);
// falls through
case 'ABSOLUTETIME':
case 'ABSOLUTETIME_FORMAT':
format = dateFormat.ABSOLUTETIME_FORMAT;
break;
case 'DATE':
process.emitWarning(
'Pattern %d{DATE} is deprecated due to the confusion it causes when used. ' +
'Please use %d{DATETIME} instead.',
'DeprecationWarning',
'log4js-node-DEP0004'
);
debug(
'[log4js-node-DEP0004]',
'DEPRECATION: Pattern %d{DATE} is deprecated and replaced by %d{DATETIME}.'
);
// falls through
case 'DATETIME':
case 'DATETIME_FORMAT':
format = dateFormat.DATETIME_FORMAT;
break;
// no default
}
}
// Format the date
return dateFormat.asString(format, loggingEvent.startTime);
}
function hostname() {
return os.hostname().toString();
}
function formatMessage(loggingEvent) {
return util.format(...loggingEvent.data);
}
function endOfLine() {
return os.EOL;
}
function logLevel(loggingEvent) {
return loggingEvent.level.toString();
}
function startTime(loggingEvent) {
return dateFormat.asString('hh:mm:ss', loggingEvent.startTime);
}
function startColour(loggingEvent) {
return colorizeStart(loggingEvent.level.colour);
}
function endColour(loggingEvent) {
return colorizeEnd(loggingEvent.level.colour);
}
function percent() {
return '%';
}
function pid(loggingEvent) {
return loggingEvent && loggingEvent.pid
? loggingEvent.pid.toString()
: process.pid.toString();
}
function clusterInfo() {
// this used to try to return the master and worker pids,
// but it would never have worked because master pid is not available to workers
// leaving this here to maintain compatibility for patterns
return pid();
}
function userDefined(loggingEvent, specifier) {
if (typeof tokens[specifier] !== 'undefined') {
return typeof tokens[specifier] === 'function'
? tokens[specifier](loggingEvent)
: tokens[specifier];
}
return null;
}
function contextDefined(loggingEvent, specifier) {
const resolver = loggingEvent.context[specifier];
if (typeof resolver !== 'undefined') {
return typeof resolver === 'function' ? resolver(loggingEvent) : resolver;
}
return null;
}
function fileName(loggingEvent, specifier) {
let filename = loggingEvent.fileName || '';
// support for ESM as it uses url instead of path for file
/* istanbul ignore next: unsure how to simulate ESM for test coverage */
const convertFileURLToPath = function(filepath) {
const urlPrefix = 'file://';
if (filepath.startsWith(urlPrefix)) {
// https://nodejs.org/api/url.html#urlfileurltopathurl
if (typeof url.fileURLToPath === 'function') {
filepath = url.fileURLToPath(filepath);
}
// backward-compatible for nodejs pre-10.12.0 (without url.fileURLToPath method)
else {
// posix: file:///hello/world/foo.txt -> /hello/world/foo.txt -> /hello/world/foo.txt
// win32: file:///C:/path/foo.txt -> /C:/path/foo.txt -> \C:\path\foo.txt -> C:\path\foo.txt
// win32: file://nas/foo.txt -> //nas/foo.txt -> nas\foo.txt -> \\nas\foo.txt
filepath = path.normalize(
filepath.replace(new RegExp(`^${urlPrefix}`), '')
);
if (process.platform === 'win32') {
if (filepath.startsWith('\\')) {
filepath = filepath.slice(1);
} else {
filepath = path.sep + path.sep + filepath;
}
}
}
}
return filepath;
};
filename = convertFileURLToPath(filename);
if (specifier) {
const fileDepth = parseInt(specifier, 10);
const fileList = filename.split(path.sep);
if (fileList.length > fileDepth) {
filename = fileList.slice(-fileDepth).join(path.sep);
}
}
return filename;
}
function lineNumber(loggingEvent) {
return loggingEvent.lineNumber ? `${loggingEvent.lineNumber}` : '';
}
function columnNumber(loggingEvent) {
return loggingEvent.columnNumber ? `${loggingEvent.columnNumber}` : '';
}
function callStack(loggingEvent) {
return loggingEvent.callStack || '';
}
const replacers = {
c: categoryName,
d: formatAsDate,
h: hostname,
m: formatMessage,
n: endOfLine,
p: logLevel,
r: startTime,
'[': startColour,
']': endColour,
y: clusterInfo,
z: pid,
'%': percent,
x: userDefined,
X: contextDefined,
f: fileName,
l: lineNumber,
o: columnNumber,
s: callStack,
};
function replaceToken(conversionCharacter, loggingEvent, specifier) {
return replacers[conversionCharacter](loggingEvent, specifier);
}
function truncate(truncation, toTruncate) {
let len;
if (truncation) {
len = parseInt(truncation.slice(1), 10);
// negative truncate length means truncate from end of string
return len > 0 ? toTruncate.slice(0, len) : toTruncate.slice(len);
}
return toTruncate;
}
function pad(padding, toPad) {
let len;
if (padding) {
if (padding.charAt(0) === '-') {
len = parseInt(padding.slice(1), 10);
// Right pad with spaces
while (toPad.length < len) {
toPad += ' ';
}
} else {
len = parseInt(padding, 10);
// Left pad with spaces
while (toPad.length < len) {
toPad = ` ${toPad}`;
}
}
}
return toPad;
}
function truncateAndPad(toTruncAndPad, truncation, padding) {
let replacement = toTruncAndPad;
replacement = truncate(truncation, replacement);
replacement = pad(padding, replacement);
return replacement;
}
return function(loggingEvent) {
let formattedString = '';
let result;
let searchString = pattern;
while ((result = regex.exec(searchString)) !== null) {
// const matchedString = result[0];
const padding = result[1];
const truncation = result[2];
const conversionCharacter = result[3];
const specifier = result[5];
const text = result[6];
// Check if the pattern matched was just normal text
if (text) {
formattedString += text.toString();
} else {
// Create a raw replacement string based on the conversion
// character and specifier
const replacement = replaceToken(
conversionCharacter,
loggingEvent,
specifier
);
formattedString += truncateAndPad(replacement, truncation, padding);
}
searchString = searchString.slice(result.index + result[0].length);
}
return formattedString;
};
}
const layoutMakers = {
messagePassThrough() {
return messagePassThroughLayout;
},
basic() {
return basicLayout;
},
colored() {
return colouredLayout;
},
coloured() {
return colouredLayout;
},
pattern(config) {
return patternLayout(config && config.pattern, config && config.tokens);
},
dummy() {
return dummyLayout;
},
};
module.exports = {
basicLayout,
messagePassThroughLayout,
patternLayout,
colouredLayout,
coloredLayout: colouredLayout,
dummyLayout,
addLayout(name, serializerGenerator) {
layoutMakers[name] = serializerGenerator;
},
layout(name, config) {
return layoutMakers[name] && layoutMakers[name](config);
},
};
| const dateFormat = require('date-format');
const os = require('os');
const util = require('util');
const path = require('path');
const url = require('url');
const debug = require('debug')('log4js:layouts');
const styles = {
// styles
bold: [1, 22],
italic: [3, 23],
underline: [4, 24],
inverse: [7, 27],
// grayscale
white: [37, 39],
grey: [90, 39],
black: [90, 39],
// colors
blue: [34, 39],
cyan: [36, 39],
green: [32, 39],
magenta: [35, 39],
red: [91, 39],
yellow: [33, 39],
};
function colorizeStart(style) {
return style ? `\x1B[${styles[style][0]}m` : '';
}
function colorizeEnd(style) {
return style ? `\x1B[${styles[style][1]}m` : '';
}
/**
* Taken from masylum's fork (https://github.com/masylum/log4js-node)
*/
function colorize(str, style) {
return colorizeStart(style) + str + colorizeEnd(style);
}
function timestampLevelAndCategory(loggingEvent, colour) {
return colorize(
util.format(
'[%s] [%s] %s - ',
dateFormat.asString(loggingEvent.startTime),
loggingEvent.level.toString(),
loggingEvent.categoryName
),
colour
);
}
/**
* BasicLayout is a simple layout for storing the logs. The logs are stored
* in following format:
* <pre>
* [startTime] [logLevel] categoryName - message\n
* </pre>
*
* @author Stephan Strittmatter
*/
function basicLayout(loggingEvent) {
return (
timestampLevelAndCategory(loggingEvent) + util.format(...loggingEvent.data)
);
}
/**
* colouredLayout - taken from masylum's fork.
* same as basicLayout, but with colours.
*/
function colouredLayout(loggingEvent) {
return (
timestampLevelAndCategory(loggingEvent, loggingEvent.level.colour) +
util.format(...loggingEvent.data)
);
}
function messagePassThroughLayout(loggingEvent) {
return util.format(...loggingEvent.data);
}
function dummyLayout(loggingEvent) {
return loggingEvent.data[0];
}
/**
* PatternLayout
* Format for specifiers is %[padding].[truncation][field]{[format]}
* e.g. %5.10p - left pad the log level by 5 characters, up to a max of 10
* both padding and truncation can be negative.
* Negative truncation = trunc from end of string
* Positive truncation = trunc from start of string
* Negative padding = pad right
* Positive padding = pad left
*
* Fields can be any of:
* - %r time in toLocaleTimeString format
* - %p log level
* - %c log category
* - %h hostname
* - %m log data
* - %d date in constious formats
* - %% %
* - %n newline
* - %z pid
* - %f filename
* - %l line number
* - %o column postion
* - %s call stack
* - %x{<tokenname>} add dynamic tokens to your log. Tokens are specified in the tokens parameter
* - %X{<tokenname>} add dynamic tokens to your log. Tokens are specified in logger context
* You can use %[ and %] to define a colored block.
*
* Tokens are specified as simple key:value objects.
* The key represents the token name whereas the value can be a string or function
* which is called to extract the value to put in the log message. If token is not
* found, it doesn't replace the field.
*
* A sample token would be: { 'pid' : function() { return process.pid; } }
*
* Takes a pattern string, array of tokens and returns a layout function.
* @return {Function}
* @param pattern
* @param tokens
* @param timezoneOffset
*
* @authors ['Stephan Strittmatter', 'Jan Schmidle']
*/
function patternLayout(pattern, tokens) {
const TTCC_CONVERSION_PATTERN = '%r %p %c - %m%n';
const regex = /%(-?[0-9]+)?(\.?-?[0-9]+)?([[\]cdhmnprzxXyflos%])(\{([^}]+)\})?|([^%]+)/;
pattern = pattern || TTCC_CONVERSION_PATTERN;
function categoryName(loggingEvent, specifier) {
let loggerName = loggingEvent.categoryName;
if (specifier) {
const precision = parseInt(specifier, 10);
const loggerNameBits = loggerName.split('.');
if (precision < loggerNameBits.length) {
loggerName = loggerNameBits
.slice(loggerNameBits.length - precision)
.join('.');
}
}
return loggerName;
}
function formatAsDate(loggingEvent, specifier) {
let format = dateFormat.ISO8601_FORMAT;
if (specifier) {
format = specifier;
// Pick up special cases
switch (format) {
case 'ISO8601':
case 'ISO8601_FORMAT':
format = dateFormat.ISO8601_FORMAT;
break;
case 'ISO8601_WITH_TZ_OFFSET':
case 'ISO8601_WITH_TZ_OFFSET_FORMAT':
format = dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT;
break;
case 'ABSOLUTE':
process.emitWarning(
'Pattern %d{ABSOLUTE} is deprecated in favor of %d{ABSOLUTETIME}. ' +
'Please use %d{ABSOLUTETIME} instead.',
'DeprecationWarning',
'log4js-node-DEP0003'
);
debug(
'[log4js-node-DEP0003]',
'DEPRECATION: Pattern %d{ABSOLUTE} is deprecated and replaced by %d{ABSOLUTETIME}.'
);
// falls through
case 'ABSOLUTETIME':
case 'ABSOLUTETIME_FORMAT':
format = dateFormat.ABSOLUTETIME_FORMAT;
break;
case 'DATE':
process.emitWarning(
'Pattern %d{DATE} is deprecated due to the confusion it causes when used. ' +
'Please use %d{DATETIME} instead.',
'DeprecationWarning',
'log4js-node-DEP0004'
);
debug(
'[log4js-node-DEP0004]',
'DEPRECATION: Pattern %d{DATE} is deprecated and replaced by %d{DATETIME}.'
);
// falls through
case 'DATETIME':
case 'DATETIME_FORMAT':
format = dateFormat.DATETIME_FORMAT;
break;
// no default
}
}
// Format the date
return dateFormat.asString(format, loggingEvent.startTime);
}
function hostname() {
return os.hostname().toString();
}
function formatMessage(loggingEvent) {
return util.format(...loggingEvent.data);
}
function endOfLine() {
return os.EOL;
}
function logLevel(loggingEvent) {
return loggingEvent.level.toString();
}
function startTime(loggingEvent) {
return dateFormat.asString('hh:mm:ss', loggingEvent.startTime);
}
function startColour(loggingEvent) {
return colorizeStart(loggingEvent.level.colour);
}
function endColour(loggingEvent) {
return colorizeEnd(loggingEvent.level.colour);
}
function percent() {
return '%';
}
function pid(loggingEvent) {
return loggingEvent && loggingEvent.pid
? loggingEvent.pid.toString()
: process.pid.toString();
}
function clusterInfo() {
// this used to try to return the master and worker pids,
// but it would never have worked because master pid is not available to workers
// leaving this here to maintain compatibility for patterns
return pid();
}
function userDefined(loggingEvent, specifier) {
if (typeof tokens[specifier] !== 'undefined') {
return typeof tokens[specifier] === 'function'
? tokens[specifier](loggingEvent)
: tokens[specifier];
}
return null;
}
function contextDefined(loggingEvent, specifier) {
const resolver = loggingEvent.context[specifier];
if (typeof resolver !== 'undefined') {
return typeof resolver === 'function' ? resolver(loggingEvent) : resolver;
}
return null;
}
function fileName(loggingEvent, specifier) {
let filename = loggingEvent.fileName || '';
// support for ESM as it uses url instead of path for file
/* istanbul ignore next: unsure how to simulate ESM for test coverage */
const convertFileURLToPath = function(filepath) {
const urlPrefix = 'file://';
if (filepath.startsWith(urlPrefix)) {
// https://nodejs.org/api/url.html#urlfileurltopathurl
if (typeof url.fileURLToPath === 'function') {
filepath = url.fileURLToPath(filepath);
}
// backward-compatible for nodejs pre-10.12.0 (without url.fileURLToPath method)
else {
// posix: file:///hello/world/foo.txt -> /hello/world/foo.txt -> /hello/world/foo.txt
// win32: file:///C:/path/foo.txt -> /C:/path/foo.txt -> \C:\path\foo.txt -> C:\path\foo.txt
// win32: file://nas/foo.txt -> //nas/foo.txt -> nas\foo.txt -> \\nas\foo.txt
filepath = path.normalize(
filepath.replace(new RegExp(`^${urlPrefix}`), '')
);
if (process.platform === 'win32') {
if (filepath.startsWith('\\')) {
filepath = filepath.slice(1);
} else {
filepath = path.sep + path.sep + filepath;
}
}
}
}
return filepath;
};
filename = convertFileURLToPath(filename);
if (specifier) {
const fileDepth = parseInt(specifier, 10);
const fileList = filename.split(path.sep);
if (fileList.length > fileDepth) {
filename = fileList.slice(-fileDepth).join(path.sep);
}
}
return filename;
}
function lineNumber(loggingEvent) {
return loggingEvent.lineNumber ? `${loggingEvent.lineNumber}` : '';
}
function columnNumber(loggingEvent) {
return loggingEvent.columnNumber ? `${loggingEvent.columnNumber}` : '';
}
function callStack(loggingEvent) {
return loggingEvent.callStack || '';
}
const replacers = {
c: categoryName,
d: formatAsDate,
h: hostname,
m: formatMessage,
n: endOfLine,
p: logLevel,
r: startTime,
'[': startColour,
']': endColour,
y: clusterInfo,
z: pid,
'%': percent,
x: userDefined,
X: contextDefined,
f: fileName,
l: lineNumber,
o: columnNumber,
s: callStack,
};
function replaceToken(conversionCharacter, loggingEvent, specifier) {
return replacers[conversionCharacter](loggingEvent, specifier);
}
function truncate(truncation, toTruncate) {
let len;
if (truncation) {
len = parseInt(truncation.slice(1), 10);
// negative truncate length means truncate from end of string
return len > 0 ? toTruncate.slice(0, len) : toTruncate.slice(len);
}
return toTruncate;
}
function pad(padding, toPad) {
let len;
if (padding) {
if (padding.charAt(0) === '-') {
len = parseInt(padding.slice(1), 10);
// Right pad with spaces
while (toPad.length < len) {
toPad += ' ';
}
} else {
len = parseInt(padding, 10);
// Left pad with spaces
while (toPad.length < len) {
toPad = ` ${toPad}`;
}
}
}
return toPad;
}
function truncateAndPad(toTruncAndPad, truncation, padding) {
let replacement = toTruncAndPad;
replacement = truncate(truncation, replacement);
replacement = pad(padding, replacement);
return replacement;
}
return function(loggingEvent) {
let formattedString = '';
let result;
let searchString = pattern;
while ((result = regex.exec(searchString)) !== null) {
// const matchedString = result[0];
const padding = result[1];
const truncation = result[2];
const conversionCharacter = result[3];
const specifier = result[5];
const text = result[6];
// Check if the pattern matched was just normal text
if (text) {
formattedString += text.toString();
} else {
// Create a raw replacement string based on the conversion
// character and specifier
const replacement = replaceToken(
conversionCharacter,
loggingEvent,
specifier
);
formattedString += truncateAndPad(replacement, truncation, padding);
}
searchString = searchString.slice(result.index + result[0].length);
}
return formattedString;
};
}
const layoutMakers = {
messagePassThrough() {
return messagePassThroughLayout;
},
basic() {
return basicLayout;
},
colored() {
return colouredLayout;
},
coloured() {
return colouredLayout;
},
pattern(config) {
return patternLayout(config && config.pattern, config && config.tokens);
},
dummy() {
return dummyLayout;
},
};
module.exports = {
basicLayout,
messagePassThroughLayout,
patternLayout,
colouredLayout,
coloredLayout: colouredLayout,
dummyLayout,
addLayout(name, serializerGenerator) {
layoutMakers[name] = serializerGenerator;
},
layout(name, config) {
return layoutMakers[name] && layoutMakers[name](config);
},
};
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./lib/appenders/tcp-server.js | const debug = require('debug')('log4js:tcp-server');
const net = require('net');
const clustering = require('../clustering');
const LoggingEvent = require('../LoggingEvent');
const DELIMITER = '__LOG4JS__';
exports.configure = (config) => {
debug('configure called with ', config);
const server = net.createServer((socket) => {
let dataSoFar = '';
const send = (data) => {
if (data) {
dataSoFar += data;
if (dataSoFar.indexOf(DELIMITER)) {
const events = dataSoFar.split(DELIMITER);
if (!dataSoFar.endsWith(DELIMITER)) {
dataSoFar = events.pop();
} else {
dataSoFar = '';
}
events
.filter((e) => e.length)
.forEach((e) => {
clustering.send(LoggingEvent.deserialise(e));
});
} else {
dataSoFar = '';
}
}
};
socket.setEncoding('utf8');
socket.on('data', send);
socket.on('end', send);
});
server.listen(config.port || 5000, config.host || 'localhost', () => {
debug(`listening on ${config.host || 'localhost'}:${config.port || 5000}`);
server.unref();
});
return {
shutdown: (cb) => {
debug('shutdown called.');
server.close(cb);
},
};
};
| const debug = require('debug')('log4js:tcp-server');
const net = require('net');
const clustering = require('../clustering');
const LoggingEvent = require('../LoggingEvent');
const DELIMITER = '__LOG4JS__';
exports.configure = (config) => {
debug('configure called with ', config);
const server = net.createServer((socket) => {
let dataSoFar = '';
const send = (data) => {
if (data) {
dataSoFar += data;
if (dataSoFar.indexOf(DELIMITER)) {
const events = dataSoFar.split(DELIMITER);
if (!dataSoFar.endsWith(DELIMITER)) {
dataSoFar = events.pop();
} else {
dataSoFar = '';
}
events
.filter((e) => e.length)
.forEach((e) => {
clustering.send(LoggingEvent.deserialise(e));
});
} else {
dataSoFar = '';
}
}
};
socket.setEncoding('utf8');
socket.on('data', send);
socket.on('end', send);
});
server.listen(config.port || 5000, config.host || 'localhost', () => {
debug(`listening on ${config.host || 'localhost'}:${config.port || 5000}`);
server.unref();
});
return {
shutdown: (cb) => {
debug('shutdown called.');
server.close(cb);
},
};
};
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./examples/rabbitmq-appender.js | // Note that rabbitmq appender needs install amqplib to work.
const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
out: {
type: 'console',
},
file: {
type: 'dateFile',
filename: 'logs/log.txt',
pattern: 'yyyyMMdd',
alwaysIncludePattern: false,
},
mq: {
type: '@log4js-node/rabbitmq',
host: '127.0.0.1',
port: 5672,
username: 'guest',
password: 'guest',
routing_key: 'logstash',
exchange: 'exchange_logs',
mq_type: 'direct',
durable: true,
layout: {
type: 'pattern',
pattern: '%d{yyyy-MM-dd hh:mm:ss:SSS}#%p#%m',
},
},
},
categories: {
default: { appenders: ['out'], level: 'info' },
dateFile: { appenders: ['file'], level: 'info' },
rabbitmq: { appenders: ['mq'], level: 'info' },
},
});
const log = log4js.getLogger('console');
const logRabbitmq = log4js.getLogger('rabbitmq');
function doTheLogging(x) {
log.info('Logging something %d', x);
logRabbitmq.info('Logging something %d', x);
}
for (let i = 0; i < 500; i += 1) {
doTheLogging(i);
}
| // Note that rabbitmq appender needs install amqplib to work.
const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
out: {
type: 'console',
},
file: {
type: 'dateFile',
filename: 'logs/log.txt',
pattern: 'yyyyMMdd',
alwaysIncludePattern: false,
},
mq: {
type: '@log4js-node/rabbitmq',
host: '127.0.0.1',
port: 5672,
username: 'guest',
password: 'guest',
routing_key: 'logstash',
exchange: 'exchange_logs',
mq_type: 'direct',
durable: true,
layout: {
type: 'pattern',
pattern: '%d{yyyy-MM-dd hh:mm:ss:SSS}#%p#%m',
},
},
},
categories: {
default: { appenders: ['out'], level: 'info' },
dateFile: { appenders: ['file'], level: 'info' },
rabbitmq: { appenders: ['mq'], level: 'info' },
},
});
const log = log4js.getLogger('console');
const logRabbitmq = log4js.getLogger('rabbitmq');
function doTheLogging(x) {
log.info('Logging something %d', x);
logRabbitmq.info('Logging something %d', x);
}
for (let i = 0; i < 500; i += 1) {
doTheLogging(i);
}
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/LoggingEvent-test.js | const flatted = require('flatted');
const { test } = require('tap');
const LoggingEvent = require('../../lib/LoggingEvent');
const levels = require('../../lib/levels');
test('LoggingEvent', (batch) => {
batch.test('should serialise to flatted', (t) => {
const event = new LoggingEvent(
'cheese',
levels.DEBUG,
['log message', parseInt('abc', 10), 1 / 0, -1 / 0, undefined],
{
user: 'bob',
}
);
// set the event date to a known value
event.startTime = new Date(Date.UTC(2018, 1, 4, 18, 30, 23, 10));
const rehydratedEvent = flatted.parse(event.serialise());
t.equal(rehydratedEvent.startTime, '2018-02-04T18:30:23.010Z');
t.equal(rehydratedEvent.categoryName, 'cheese');
t.equal(rehydratedEvent.level.levelStr, 'DEBUG');
t.equal(rehydratedEvent.data.length, 5);
t.equal(rehydratedEvent.data[0], 'log message');
t.equal(rehydratedEvent.data[1], 'NaN');
t.equal(rehydratedEvent.data[2], 'Infinity');
t.equal(rehydratedEvent.data[3], '-Infinity');
t.equal(rehydratedEvent.data[4], 'undefined');
t.equal(rehydratedEvent.context.user, 'bob');
t.end();
});
batch.test('should deserialise from flatted', (t) => {
const dehydratedEvent = flatted.stringify({
startTime: '2018-02-04T10:25:23.010Z',
categoryName: 'biscuits',
level: {
levelStr: 'INFO',
},
data: ['some log message', { x: 1 }],
context: { thing: 'otherThing' },
pid: '1234',
functionName: 'bound',
fileName: 'domain.js',
lineNumber: 421,
columnNumber: 15,
callStack: 'at bound (domain.js:421:15)\n',
});
const event = LoggingEvent.deserialise(dehydratedEvent);
t.type(event, LoggingEvent);
t.same(event.startTime, new Date(Date.UTC(2018, 1, 4, 10, 25, 23, 10)));
t.equal(event.categoryName, 'biscuits');
t.same(event.level, levels.INFO);
t.equal(event.data[0], 'some log message');
t.equal(event.data[1].x, 1);
t.equal(event.context.thing, 'otherThing');
t.equal(event.pid, '1234');
t.equal(event.functionName, 'bound');
t.equal(event.fileName, 'domain.js');
t.equal(event.lineNumber, 421);
t.equal(event.columnNumber, 15);
t.equal(event.callStack, 'at bound (domain.js:421:15)\n');
t.end();
});
batch.test('Should correct construct with/without location info', (t) => {
// console.log([Error('123').stack.split('\n').slice(1).join('\n')])
const callStack =
' at repl:1:14\n at ContextifyScript.Script.runInThisContext (vm.js:50:33)\n at REPLServer.defaultEval (repl.js:240:29)\n at bound (domain.js:301:14)\n at REPLServer.runBound [as eval] (domain.js:314:12)\n at REPLServer.onLine (repl.js:468:10)\n at emitOne (events.js:121:20)\n at REPLServer.emit (events.js:211:7)\n at REPLServer.Interface._onLine (readline.js:280:10)\n at REPLServer.Interface._line (readline.js:629:8)'; // eslint-disable-line max-len
const fileName = '/log4js-node/test/tap/layouts-test.js';
const lineNumber = 1;
const columnNumber = 14;
const location = {
fileName,
lineNumber,
columnNumber,
callStack,
};
const event = new LoggingEvent(
'cheese',
levels.DEBUG,
['log message'],
{ user: 'bob' },
location
);
t.equal(event.fileName, fileName);
t.equal(event.lineNumber, lineNumber);
t.equal(event.columnNumber, columnNumber);
t.equal(event.callStack, callStack);
const event2 = new LoggingEvent('cheese', levels.DEBUG, ['log message'], {
user: 'bob',
});
t.equal(event2.fileName, undefined);
t.equal(event2.lineNumber, undefined);
t.equal(event2.columnNumber, undefined);
t.equal(event2.callStack, undefined);
t.end();
});
batch.end();
});
| const flatted = require('flatted');
const { test } = require('tap');
const LoggingEvent = require('../../lib/LoggingEvent');
const levels = require('../../lib/levels');
test('LoggingEvent', (batch) => {
batch.test('should serialise to flatted', (t) => {
const event = new LoggingEvent(
'cheese',
levels.DEBUG,
['log message', parseInt('abc', 10), 1 / 0, -1 / 0, undefined],
{
user: 'bob',
}
);
// set the event date to a known value
event.startTime = new Date(Date.UTC(2018, 1, 4, 18, 30, 23, 10));
const rehydratedEvent = flatted.parse(event.serialise());
t.equal(rehydratedEvent.startTime, '2018-02-04T18:30:23.010Z');
t.equal(rehydratedEvent.categoryName, 'cheese');
t.equal(rehydratedEvent.level.levelStr, 'DEBUG');
t.equal(rehydratedEvent.data.length, 5);
t.equal(rehydratedEvent.data[0], 'log message');
t.equal(rehydratedEvent.data[1], 'NaN');
t.equal(rehydratedEvent.data[2], 'Infinity');
t.equal(rehydratedEvent.data[3], '-Infinity');
t.equal(rehydratedEvent.data[4], 'undefined');
t.equal(rehydratedEvent.context.user, 'bob');
t.end();
});
batch.test('should deserialise from flatted', (t) => {
const dehydratedEvent = flatted.stringify({
startTime: '2018-02-04T10:25:23.010Z',
categoryName: 'biscuits',
level: {
levelStr: 'INFO',
},
data: ['some log message', { x: 1 }],
context: { thing: 'otherThing' },
pid: '1234',
functionName: 'bound',
fileName: 'domain.js',
lineNumber: 421,
columnNumber: 15,
callStack: 'at bound (domain.js:421:15)\n',
});
const event = LoggingEvent.deserialise(dehydratedEvent);
t.type(event, LoggingEvent);
t.same(event.startTime, new Date(Date.UTC(2018, 1, 4, 10, 25, 23, 10)));
t.equal(event.categoryName, 'biscuits');
t.same(event.level, levels.INFO);
t.equal(event.data[0], 'some log message');
t.equal(event.data[1].x, 1);
t.equal(event.context.thing, 'otherThing');
t.equal(event.pid, '1234');
t.equal(event.functionName, 'bound');
t.equal(event.fileName, 'domain.js');
t.equal(event.lineNumber, 421);
t.equal(event.columnNumber, 15);
t.equal(event.callStack, 'at bound (domain.js:421:15)\n');
t.end();
});
batch.test('Should correct construct with/without location info', (t) => {
// console.log([Error('123').stack.split('\n').slice(1).join('\n')])
const callStack =
' at repl:1:14\n at ContextifyScript.Script.runInThisContext (vm.js:50:33)\n at REPLServer.defaultEval (repl.js:240:29)\n at bound (domain.js:301:14)\n at REPLServer.runBound [as eval] (domain.js:314:12)\n at REPLServer.onLine (repl.js:468:10)\n at emitOne (events.js:121:20)\n at REPLServer.emit (events.js:211:7)\n at REPLServer.Interface._onLine (readline.js:280:10)\n at REPLServer.Interface._line (readline.js:629:8)'; // eslint-disable-line max-len
const fileName = '/log4js-node/test/tap/layouts-test.js';
const lineNumber = 1;
const columnNumber = 14;
const location = {
fileName,
lineNumber,
columnNumber,
callStack,
};
const event = new LoggingEvent(
'cheese',
levels.DEBUG,
['log message'],
{ user: 'bob' },
location
);
t.equal(event.fileName, fileName);
t.equal(event.lineNumber, lineNumber);
t.equal(event.columnNumber, columnNumber);
t.equal(event.callStack, callStack);
const event2 = new LoggingEvent('cheese', levels.DEBUG, ['log message'], {
user: 'bob',
});
t.equal(event2.fileName, undefined);
t.equal(event2.lineNumber, undefined);
t.equal(event2.columnNumber, undefined);
t.equal(event2.callStack, undefined);
t.end();
});
batch.end();
});
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./examples/log-rolling-bug.js | const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
handler: {
type: 'file',
filename: 'logs/handler.log',
maxLogSize: 100000,
backups: 5,
keepFileExt: true,
compress: true,
},
},
categories: {
default: { appenders: ['handler'], level: 'debug' },
handler: { appenders: ['handler'], level: 'debug' },
},
});
const logsToTest = ['handler'];
const logStartDate = new Date();
const loggers = logsToTest.map((log) => log4js.getLogger(log));
// write out a lot
setInterval(() => {
loggers.forEach((logger) =>
logger.info(`TESTING LOGGER!!!!!!${logStartDate}`)
);
}, 10);
| const log4js = require('../lib/log4js');
log4js.configure({
appenders: {
handler: {
type: 'file',
filename: 'logs/handler.log',
maxLogSize: 100000,
backups: 5,
keepFileExt: true,
compress: true,
},
},
categories: {
default: { appenders: ['handler'], level: 'debug' },
handler: { appenders: ['handler'], level: 'debug' },
},
});
const logsToTest = ['handler'];
const logStartDate = new Date();
const loggers = logsToTest.map((log) => log4js.getLogger(log));
// write out a lot
setInterval(() => {
loggers.forEach((logger) =>
logger.info(`TESTING LOGGER!!!!!!${logStartDate}`)
);
}, 10);
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./.npmignore | # Created by .ignore support plugin
**/.*
node_modules
bower_components
test
tests
support
benchmarks
examples
sample
lib-cov
coverage.html
Makefile
coverage
Gemfile
Gemfile.lock
docker-compose.yml
Dockerfile
.bob
| # Created by .ignore support plugin
**/.*
node_modules
bower_components
test
tests
support
benchmarks
examples
sample
lib-cov
coverage.html
Makefile
coverage
Gemfile
Gemfile.lock
docker-compose.yml
Dockerfile
.bob
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./docs/faq.md | # Frequently Asked Questions
## I want errors to go to a special file, but still want everything written to another file - how do I do that?
You'll need to use the [logLevelFilter](logLevelFilter.md). Here's an example configuration:
```javascript
log4js.configure({
appenders: {
everything: { type: "file", filename: "all-the-logs.log" },
emergencies: { type: "file", filename: "oh-no-not-again.log" },
"just-errors": {
type: "logLevelFilter",
appender: "emergencies",
level: "error",
},
},
categories: {
default: { appenders: ["just-errors", "everything"], level: "debug" },
},
});
const logger = log4js.getLogger();
logger.debug("This goes to all-the-logs.log");
logger.info("As does this.");
logger.error("This goes to all-the-logs.log and oh-no-not-again.log");
```
## I want to reload the configuration when I change my config file - how do I do that?
Previous versions of log4js used to watch for changes in the configuration file and reload when it changed. It didn't always work well, sometimes leaving file handles or sockets open. This feature was removed in version 2.x. As a replacement, I'd suggest using a library like [watchr](https://www.npmjs.com/package/watchr) to notify you of file changes. Then you can call `log4js.shutdown` followed by `log4js.configure` again.
## What happened to `replaceConsole` - it doesn't work any more?
I removed `replaceConsole` - it caused a few weird errors, and I wasn't entirely comfortable with messing around with a core part of node. If you still want to do this, then code like this should do the trick:
```javascript
log4js.configure(...); // set up your categories and appenders
const logger = log4js.getLogger('console');
console.log = logger.info.bind(logger); // do the same for others - console.debug, etc.
```
## I'm using pm2/passenger/some other third thing and I'm not getting any logs!
Take a look at the [clustering](clustering.md) docs, they should help you out.
## NPM complains about nodemailer being deprecated, what should I do?
Nodemailer version 4.0.1 (the not-deprecated version) requires a node version >= 6, but log4js supports node versions >= 4. So until I stop supporting node versions less than 6 I can't update the dependency. It's only an optional dependency anyway, so you're free to install nodemailer@4.0.1 if you want - as far as I know it should work, the API looks the same to me. If you know that the smtp appender definitely doesn't work with nodemailer v4, then please create an issue with some details about the problem.
## I want line numbers in my logs!
You need to enable call stack for the category, and use pattern layout to output the values. e.g.
```javascript
const log4js = require("log4js");
log4js.configure({
appenders: {
out: {
type: "stdout",
layout: {
type: "pattern",
pattern: "%d %p %c %f:%l %m%n",
},
},
},
categories: {
default: { appenders: ["out"], level: "info", enableCallStack: true },
},
});
const logger = log4js.getLogger("thing");
logger.info("this should give me a line number now");
```
Would output something like this:
```bash
2019-05-22T08:41:07.312 INFO thing index.js:16 this should give me a line number now
```
| # Frequently Asked Questions
## I want errors to go to a special file, but still want everything written to another file - how do I do that?
You'll need to use the [logLevelFilter](logLevelFilter.md). Here's an example configuration:
```javascript
log4js.configure({
appenders: {
everything: { type: "file", filename: "all-the-logs.log" },
emergencies: { type: "file", filename: "oh-no-not-again.log" },
"just-errors": {
type: "logLevelFilter",
appender: "emergencies",
level: "error",
},
},
categories: {
default: { appenders: ["just-errors", "everything"], level: "debug" },
},
});
const logger = log4js.getLogger();
logger.debug("This goes to all-the-logs.log");
logger.info("As does this.");
logger.error("This goes to all-the-logs.log and oh-no-not-again.log");
```
## I want to reload the configuration when I change my config file - how do I do that?
Previous versions of log4js used to watch for changes in the configuration file and reload when it changed. It didn't always work well, sometimes leaving file handles or sockets open. This feature was removed in version 2.x. As a replacement, I'd suggest using a library like [watchr](https://www.npmjs.com/package/watchr) to notify you of file changes. Then you can call `log4js.shutdown` followed by `log4js.configure` again.
## What happened to `replaceConsole` - it doesn't work any more?
I removed `replaceConsole` - it caused a few weird errors, and I wasn't entirely comfortable with messing around with a core part of node. If you still want to do this, then code like this should do the trick:
```javascript
log4js.configure(...); // set up your categories and appenders
const logger = log4js.getLogger('console');
console.log = logger.info.bind(logger); // do the same for others - console.debug, etc.
```
## I'm using pm2/passenger/some other third thing and I'm not getting any logs!
Take a look at the [clustering](clustering.md) docs, they should help you out.
## NPM complains about nodemailer being deprecated, what should I do?
Nodemailer version 4.0.1 (the not-deprecated version) requires a node version >= 6, but log4js supports node versions >= 4. So until I stop supporting node versions less than 6 I can't update the dependency. It's only an optional dependency anyway, so you're free to install nodemailer@4.0.1 if you want - as far as I know it should work, the API looks the same to me. If you know that the smtp appender definitely doesn't work with nodemailer v4, then please create an issue with some details about the problem.
## I want line numbers in my logs!
You need to enable call stack for the category, and use pattern layout to output the values. e.g.
```javascript
const log4js = require("log4js");
log4js.configure({
appenders: {
out: {
type: "stdout",
layout: {
type: "pattern",
pattern: "%d %p %c %f:%l %m%n",
},
},
},
categories: {
default: { appenders: ["out"], level: "info", enableCallStack: true },
},
});
const logger = log4js.getLogger("thing");
logger.info("this should give me a line number now");
```
Would output something like this:
```bash
2019-05-22T08:41:07.312 INFO thing index.js:16 this should give me a line number now
```
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/.eslintrc | {
"extends": "../.eslintrc",
"rules": {
"no-plusplus": 0,
"global-require": 0,
"no-mixed-operators": 0,
"no-underscore-dangle": 0,
"guard-for-in": 0,
"no-restricted-syntax": ["error", "WithStatement"]
}
}
| {
"extends": "../.eslintrc",
"rules": {
"no-plusplus": 0,
"global-require": 0,
"no-mixed-operators": 0,
"no-underscore-dangle": 0,
"guard-for-in": 0,
"no-restricted-syntax": ["error", "WithStatement"]
}
}
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./docs/dateFile.md | # Date Rolling File Appender
This is a file appender that rolls log files based on a configurable time, rather than the file size. When using the date file appender, you should also call `log4js.shutdown` when your application terminates, to ensure that any remaining asynchronous writes have finished. Although the date file appender uses the [streamroller](https://github.com/nomiddlename/streamroller) library, this is included as a dependency of log4js so you do not need to include it yourself.
## Configuration
- `type` - `"dateFile"`
- `filename` - `string` - the path of the file where you want your logs written.
- `pattern` - `string` (optional, defaults to `yyyy-MM-dd`) - the pattern to use to determine when to roll the logs.
- `layout` - (optional, defaults to basic layout) - see [layouts](layouts.md)
Any other configuration parameters will be passed to the underlying [streamroller](https://github.com/nomiddlename/streamroller) implementation (see also node.js core file streams):
- `encoding` - `string` (default "utf-8")
- `mode` - `integer` (default 0o600 - [node.js file modes](https://nodejs.org/dist/latest-v12.x/docs/api/fs.html#fs_file_modes))
- `flags` - `string` (default 'a' - [node.js file flags](https://nodejs.org/dist/latest-v12.x/docs/api/fs.html#fs_file_system_flags))
- `compress` - `boolean` (default false) - compress the backup files using gzip (backup files will have `.gz` extension)
- `keepFileExt` - `boolean` (default false) - preserve the file extension when rotating log files (`file.log` becomes `file.2017-05-30.log` instead of `file.log.2017-05-30`).
- `fileNameSep` - `string` (default '.') - the filename separator when rolling. e.g.: abc.log`.`2013-08-30 or abc`.`2013-08-30.log (keepFileExt)
- `alwaysIncludePattern` - `boolean` (default false) - include the pattern in the name of the current log file.
- `numBackups` - `integer` (default 1) - the number of old files that matches the pattern to keep (excluding the hot file).
The `pattern` is used to determine when the current log file should be renamed and a new log file created. For example, with a filename of 'cheese.log', and the default pattern of `.yyyy-MM-dd` - on startup this will result in a file called `cheese.log` being created and written to until the next write after midnight. When this happens, `cheese.log` will be renamed to `cheese.log.2017-04-30` and a new `cheese.log` file created. The appender uses the [date-format](https://github.com/nomiddlename/date-format) library to parse the `pattern`, and any of the valid formats can be used. Also note that there is no timer controlling the log rolling - changes in the pattern are determined on every log write. If no writes occur, then no log rolling will happen. If your application logs infrequently this could result in no log file being written for a particular time period.
Note that, from version 4.x of log4js onwards, the file appender can take any of the options for the [file appender](file.md) as well. So you could roll files by both date and size.
## Example (default daily log rolling)
```javascript
log4js.configure({
appenders: {
everything: { type: "dateFile", filename: "all-the-logs.log" },
},
categories: {
default: { appenders: ["everything"], level: "debug" },
},
});
```
This example will result in files being rolled every day. The initial file will be `all-the-logs.log`, with the daily backups being `all-the-logs.log.2017-04-30`, etc.
## Example with hourly log rolling (and compressed backups)
```javascript
log4js.configure({
appenders: {
everything: {
type: "dateFile",
filename: "all-the-logs.log",
pattern: "yyyy-MM-dd-hh",
compress: true,
},
},
categories: {
default: { appenders: ["everything"], level: "debug" },
},
});
```
This will result in one current log file (`all-the-logs.log`). Every hour this file will be compressed and renamed to `all-the-logs.log.2017-04-30-08.gz` (for example) and a new `all-the-logs.log` created.
## Memory usage
If your application logs a large volume of messages, and find memory usage increasing due to buffering log messages before being written to a file, then you can listen for "log4js:pause" events emitted by the file appenders. Your application should stop logging when it receives one of these events with a value of `true` and resume when it receives an event with a value of `false`.
```javascript
log4js.configure({
appenders: {
output: { type: "dateFile", filename: "out.log" },
},
categories: { default: { appenders: ["output"], level: "debug" } },
});
let paused = false;
process.on("log4js:pause", (value) => (paused = value));
const logger = log4js.getLogger();
while (!paused) {
logger.info("I'm logging, but I will stop once we start buffering");
}
```
| # Date Rolling File Appender
This is a file appender that rolls log files based on a configurable time, rather than the file size. When using the date file appender, you should also call `log4js.shutdown` when your application terminates, to ensure that any remaining asynchronous writes have finished. Although the date file appender uses the [streamroller](https://github.com/nomiddlename/streamroller) library, this is included as a dependency of log4js so you do not need to include it yourself.
## Configuration
- `type` - `"dateFile"`
- `filename` - `string` - the path of the file where you want your logs written.
- `pattern` - `string` (optional, defaults to `yyyy-MM-dd`) - the pattern to use to determine when to roll the logs.
- `layout` - (optional, defaults to basic layout) - see [layouts](layouts.md)
Any other configuration parameters will be passed to the underlying [streamroller](https://github.com/nomiddlename/streamroller) implementation (see also node.js core file streams):
- `encoding` - `string` (default "utf-8")
- `mode` - `integer` (default 0o600 - [node.js file modes](https://nodejs.org/dist/latest-v12.x/docs/api/fs.html#fs_file_modes))
- `flags` - `string` (default 'a' - [node.js file flags](https://nodejs.org/dist/latest-v12.x/docs/api/fs.html#fs_file_system_flags))
- `compress` - `boolean` (default false) - compress the backup files using gzip (backup files will have `.gz` extension)
- `keepFileExt` - `boolean` (default false) - preserve the file extension when rotating log files (`file.log` becomes `file.2017-05-30.log` instead of `file.log.2017-05-30`).
- `fileNameSep` - `string` (default '.') - the filename separator when rolling. e.g.: abc.log`.`2013-08-30 or abc`.`2013-08-30.log (keepFileExt)
- `alwaysIncludePattern` - `boolean` (default false) - include the pattern in the name of the current log file.
- `numBackups` - `integer` (default 1) - the number of old files that matches the pattern to keep (excluding the hot file).
The `pattern` is used to determine when the current log file should be renamed and a new log file created. For example, with a filename of 'cheese.log', and the default pattern of `.yyyy-MM-dd` - on startup this will result in a file called `cheese.log` being created and written to until the next write after midnight. When this happens, `cheese.log` will be renamed to `cheese.log.2017-04-30` and a new `cheese.log` file created. The appender uses the [date-format](https://github.com/nomiddlename/date-format) library to parse the `pattern`, and any of the valid formats can be used. Also note that there is no timer controlling the log rolling - changes in the pattern are determined on every log write. If no writes occur, then no log rolling will happen. If your application logs infrequently this could result in no log file being written for a particular time period.
Note that, from version 4.x of log4js onwards, the file appender can take any of the options for the [file appender](file.md) as well. So you could roll files by both date and size.
## Example (default daily log rolling)
```javascript
log4js.configure({
appenders: {
everything: { type: "dateFile", filename: "all-the-logs.log" },
},
categories: {
default: { appenders: ["everything"], level: "debug" },
},
});
```
This example will result in files being rolled every day. The initial file will be `all-the-logs.log`, with the daily backups being `all-the-logs.log.2017-04-30`, etc.
## Example with hourly log rolling (and compressed backups)
```javascript
log4js.configure({
appenders: {
everything: {
type: "dateFile",
filename: "all-the-logs.log",
pattern: "yyyy-MM-dd-hh",
compress: true,
},
},
categories: {
default: { appenders: ["everything"], level: "debug" },
},
});
```
This will result in one current log file (`all-the-logs.log`). Every hour this file will be compressed and renamed to `all-the-logs.log.2017-04-30-08.gz` (for example) and a new `all-the-logs.log` created.
## Memory usage
If your application logs a large volume of messages, and find memory usage increasing due to buffering log messages before being written to a file, then you can listen for "log4js:pause" events emitted by the file appenders. Your application should stop logging when it receives one of these events with a value of `true` and resume when it receives an event with a value of `false`.
```javascript
log4js.configure({
appenders: {
output: { type: "dateFile", filename: "out.log" },
},
categories: { default: { appenders: ["output"], level: "debug" } },
});
let paused = false;
process.on("log4js:pause", (value) => (paused = value));
const logger = log4js.getLogger();
while (!paused) {
logger.info("I'm logging, but I will stop once we start buffering");
}
```
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./LICENSE | Copyright 2015 Gareth Jones (with contributions from many other people)
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
http://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.
| Copyright 2015 Gareth Jones (with contributions from many other people)
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
http://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.
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./test/tap/cluster-test.js | const { test } = require('tap');
const cluster = require('cluster');
const log4js = require('../../lib/log4js');
const recorder = require('../../lib/appenders/recording');
log4js.configure({
appenders: {
vcr: { type: 'recording' },
},
categories: { default: { appenders: ['vcr'], level: 'debug' } },
});
if (cluster.isMaster) {
cluster.fork();
const masterLogger = log4js.getLogger('master');
const masterPid = process.pid;
masterLogger.info('this is master');
let workerLevel;
cluster.on('message', (worker, message) => {
if (worker.type || worker.topic) {
message = worker;
}
if (message.type && message.type === '::testing') {
workerLevel = message.level;
}
});
cluster.on('exit', (worker) => {
const workerPid = worker.process.pid;
const logEvents = recorder.replay();
test('cluster master', (batch) => {
batch.test('events should be logged', (t) => {
t.equal(logEvents.length, 3);
t.equal(logEvents[0].categoryName, 'master');
t.equal(logEvents[0].pid, masterPid);
t.equal(logEvents[1].categoryName, 'worker');
t.equal(logEvents[1].pid, workerPid);
// serialising errors with stacks intact
t.type(logEvents[1].data[1], 'Error');
t.match(logEvents[1].data[1].stack, 'Error: oh dear');
// serialising circular references in objects
t.type(logEvents[1].data[2], 'object');
t.type(logEvents[1].data[2].me, 'object');
// serialising errors with custom properties
t.type(logEvents[1].data[3], 'Error');
t.match(logEvents[1].data[3].stack, 'Error: wtf');
t.equal(logEvents[1].data[3].alert, 'chartreuse');
// serialising things that are not errors, but look a bit like them
t.type(logEvents[1].data[4], 'object');
t.equal(logEvents[1].data[4].stack, 'this is not a stack trace');
t.equal(logEvents[2].categoryName, 'log4js');
t.equal(logEvents[2].level.toString(), 'ERROR');
t.equal(logEvents[2].data[0], 'Unable to parse log:');
t.end();
});
batch.end();
});
test('cluster worker', (batch) => {
batch.test('logger should get correct config', (t) => {
t.equal(workerLevel, 'DEBUG');
t.end();
});
batch.end();
});
});
} else {
const workerLogger = log4js.getLogger('worker');
// test for serialising circular references
const circle = {};
circle.me = circle;
// test for serialising errors with their own properties
const someError = new Error('wtf');
someError.alert = 'chartreuse';
// test for serialising things that look like errors but aren't.
const notAnError = { stack: 'this is not a stack trace' };
workerLogger.info(
'this is worker',
new Error('oh dear'),
circle,
someError,
notAnError
);
// can't run the test in the worker, things get weird
process.send({
type: '::testing',
level: workerLogger.level.toString(),
});
// test sending a badly-formed log message
process.send({ topic: 'log4js:message', data: { cheese: 'gouda' } });
cluster.worker.disconnect();
}
| const { test } = require('tap');
const cluster = require('cluster');
const log4js = require('../../lib/log4js');
const recorder = require('../../lib/appenders/recording');
log4js.configure({
appenders: {
vcr: { type: 'recording' },
},
categories: { default: { appenders: ['vcr'], level: 'debug' } },
});
if (cluster.isMaster) {
cluster.fork();
const masterLogger = log4js.getLogger('master');
const masterPid = process.pid;
masterLogger.info('this is master');
let workerLevel;
cluster.on('message', (worker, message) => {
if (worker.type || worker.topic) {
message = worker;
}
if (message.type && message.type === '::testing') {
workerLevel = message.level;
}
});
cluster.on('exit', (worker) => {
const workerPid = worker.process.pid;
const logEvents = recorder.replay();
test('cluster master', (batch) => {
batch.test('events should be logged', (t) => {
t.equal(logEvents.length, 3);
t.equal(logEvents[0].categoryName, 'master');
t.equal(logEvents[0].pid, masterPid);
t.equal(logEvents[1].categoryName, 'worker');
t.equal(logEvents[1].pid, workerPid);
// serialising errors with stacks intact
t.type(logEvents[1].data[1], 'Error');
t.match(logEvents[1].data[1].stack, 'Error: oh dear');
// serialising circular references in objects
t.type(logEvents[1].data[2], 'object');
t.type(logEvents[1].data[2].me, 'object');
// serialising errors with custom properties
t.type(logEvents[1].data[3], 'Error');
t.match(logEvents[1].data[3].stack, 'Error: wtf');
t.equal(logEvents[1].data[3].alert, 'chartreuse');
// serialising things that are not errors, but look a bit like them
t.type(logEvents[1].data[4], 'object');
t.equal(logEvents[1].data[4].stack, 'this is not a stack trace');
t.equal(logEvents[2].categoryName, 'log4js');
t.equal(logEvents[2].level.toString(), 'ERROR');
t.equal(logEvents[2].data[0], 'Unable to parse log:');
t.end();
});
batch.end();
});
test('cluster worker', (batch) => {
batch.test('logger should get correct config', (t) => {
t.equal(workerLevel, 'DEBUG');
t.end();
});
batch.end();
});
});
} else {
const workerLogger = log4js.getLogger('worker');
// test for serialising circular references
const circle = {};
circle.me = circle;
// test for serialising errors with their own properties
const someError = new Error('wtf');
someError.alert = 'chartreuse';
// test for serialising things that look like errors but aren't.
const notAnError = { stack: 'this is not a stack trace' };
workerLogger.info(
'this is worker',
new Error('oh dear'),
circle,
someError,
notAnError
);
// can't run the test in the worker, things get weird
process.send({
type: '::testing',
level: workerLogger.level.toString(),
});
// test sending a badly-formed log message
process.send({ topic: 'log4js:message', data: { cheese: 'gouda' } });
cluster.worker.disconnect();
}
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./lib/appenders/noLogFilter.js | const debug = require('debug')('log4js:noLogFilter');
/**
* The function removes empty or null regexp from the array
* @param {string[]} regexp
* @returns {string[]} a filtered string array with not empty or null regexp
*/
function removeNullOrEmptyRegexp(regexp) {
const filtered = regexp.filter((el) => el != null && el !== '');
return filtered;
}
/**
* Returns a function that will exclude the events in case they match
* with the regular expressions provided
* @param {(string|string[])} filters contains the regexp that will be used for the evaluation
* @param {*} appender
* @returns {function}
*/
function noLogFilter(filters, appender) {
return (logEvent) => {
debug(`Checking data: ${logEvent.data} against filters: ${filters}`);
if (typeof filters === 'string') {
filters = [filters];
}
filters = removeNullOrEmptyRegexp(filters);
const regex = new RegExp(filters.join('|'), 'i');
if (
filters.length === 0 ||
logEvent.data.findIndex((value) => regex.test(value)) < 0
) {
debug('Not excluded, sending to appender');
appender(logEvent);
}
};
}
function configure(config, layouts, findAppender) {
const appender = findAppender(config.appender);
return noLogFilter(config.exclude, appender);
}
module.exports.configure = configure;
| const debug = require('debug')('log4js:noLogFilter');
/**
* The function removes empty or null regexp from the array
* @param {string[]} regexp
* @returns {string[]} a filtered string array with not empty or null regexp
*/
function removeNullOrEmptyRegexp(regexp) {
const filtered = regexp.filter((el) => el != null && el !== '');
return filtered;
}
/**
* Returns a function that will exclude the events in case they match
* with the regular expressions provided
* @param {(string|string[])} filters contains the regexp that will be used for the evaluation
* @param {*} appender
* @returns {function}
*/
function noLogFilter(filters, appender) {
return (logEvent) => {
debug(`Checking data: ${logEvent.data} against filters: ${filters}`);
if (typeof filters === 'string') {
filters = [filters];
}
filters = removeNullOrEmptyRegexp(filters);
const regex = new RegExp(filters.join('|'), 'i');
if (
filters.length === 0 ||
logEvent.data.findIndex((value) => regex.test(value)) < 0
) {
debug('Not excluded, sending to appender');
appender(logEvent);
}
};
}
function configure(config, layouts, findAppender) {
const appender = findAppender(config.appender);
return noLogFilter(config.exclude, appender);
}
module.exports.configure = configure;
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./docs/categories.md | # Categories
Categories are groups of log events. The category for log events is defined when you get a _Logger_ from log4js (`log4js.getLogger('somecategory')`). Log events with the same _category_ will go to the same _appenders_.
## Default configuration
When defining your appenders through a configuration, at least one category must be defined.
```javascript
const log4js = require("log4js");
log4js.configure({
appenders: {
out: { type: "stdout" },
app: { type: "file", filename: "application.log" },
},
categories: {
default: { appenders: ["out"], level: "trace" },
app: { appenders: ["app"], level: "trace" },
},
});
const logger = log4js.getLogger();
logger.trace("This will use the default category and go to stdout");
const logToFile = log4js.getLogger("app");
logToFile.trace("This will go to a file");
```
## Categories inheritance
Log4js supports a hierarchy for categories, using dots to separate layers - for example, log events in the category 'myapp.submodule' will use the level for 'myapp' if none is defined for 'myapp.submodule', and also any appenders defined for 'myapp'.
This behaviour can be disabled by setting inherit=false on the sub-category.
```javascript
const log4js = require("log4js");
log4js.configure({
appenders: {
console: { type: "console" },
app: { type: "file", filename: "application.log" },
},
categories: {
default: { appenders: ["console"], level: "trace" },
catA: { appenders: ["console"], level: "error" },
"catA.catB": { appenders: ["app"], level: "trace" },
},
});
const loggerA = log4js.getLogger("catA");
loggerA.error("This will be written to console with log level ERROR");
loggerA.trace("This will not be written");
const loggerAB = log4js.getLogger("catA.catB");
loggerAB.error(
"This will be written with log level ERROR to console and to a file"
);
loggerAB.trace(
"This will be written with log level TRACE to console and to a file"
);
```
Two categories are defined:
- Log events with category 'catA' will go to appender 'console' only.
- Log events with category 'catA.catB' will go to appenders 'console' and 'app'.
Appenders will see and log an event only if the category level is less than or equal to the event's level.
| # Categories
Categories are groups of log events. The category for log events is defined when you get a _Logger_ from log4js (`log4js.getLogger('somecategory')`). Log events with the same _category_ will go to the same _appenders_.
## Default configuration
When defining your appenders through a configuration, at least one category must be defined.
```javascript
const log4js = require("log4js");
log4js.configure({
appenders: {
out: { type: "stdout" },
app: { type: "file", filename: "application.log" },
},
categories: {
default: { appenders: ["out"], level: "trace" },
app: { appenders: ["app"], level: "trace" },
},
});
const logger = log4js.getLogger();
logger.trace("This will use the default category and go to stdout");
const logToFile = log4js.getLogger("app");
logToFile.trace("This will go to a file");
```
## Categories inheritance
Log4js supports a hierarchy for categories, using dots to separate layers - for example, log events in the category 'myapp.submodule' will use the level for 'myapp' if none is defined for 'myapp.submodule', and also any appenders defined for 'myapp'.
This behaviour can be disabled by setting inherit=false on the sub-category.
```javascript
const log4js = require("log4js");
log4js.configure({
appenders: {
console: { type: "console" },
app: { type: "file", filename: "application.log" },
},
categories: {
default: { appenders: ["console"], level: "trace" },
catA: { appenders: ["console"], level: "error" },
"catA.catB": { appenders: ["app"], level: "trace" },
},
});
const loggerA = log4js.getLogger("catA");
loggerA.error("This will be written to console with log level ERROR");
loggerA.trace("This will not be written");
const loggerAB = log4js.getLogger("catA.catB");
loggerAB.error(
"This will be written with log level ERROR to console and to a file"
);
loggerAB.trace(
"This will be written with log level TRACE to console and to a file"
);
```
Two categories are defined:
- Log events with category 'catA' will go to appender 'console' only.
- Log events with category 'catA.catB' will go to appenders 'console' and 'app'.
Appenders will see and log an event only if the category level is less than or equal to the event's level.
| -1 |
|
log4js-node/log4js-node | 1,306 | test: extended timeout interval for OS operations | lamweili | "2022-07-26T09:29:19Z" | "2022-07-26T09:29:31Z" | b6b05d3263ae220a0fc18a25666febe328ab1c4c | ea60ad0fd8ff2cb46b4a9a476de097bccb85df2a | test: extended timeout interval for OS operations. | ./.git/index | DIRC egdegd f 5lQFaތq
.editorconfig egdegd f xyi'xK
{Ћ
.eslintignore egdegd f u&
Yеf\#H .eslintrc egdegd f t0z66JpaU .gitattributes eH,4eH,4 fs
U([nxM8 %.github/workflows/codeql-analysis.yml eH,4eH,4 f .x<m\] .github/workflows/node.js.yml eH,4eH,4 f D,U/zP
!.github/workflows/npm-publish.yml egdegd f APvf\;
vQQ
.gitignore egdegd f VR"p:PH5 .husky/commit_msg egdegd f QըYx +J#t .husky/pre-push egdegd f <H<fKf
.npmignore egdegd f @5YVH妉}ZR .prettierignore eX2*peX2*p f {jzq8?^$ g CHANGELOG.md egdegd f ^}ϥEgU/U0Myf LICENSE e,0_e,0_ f Wpk<`{?S README.md egdegd f NeF&Rȷ{V= SECURITY.md egdegd f CB+D[=
sҠTKD commitlint.config.js egdegd f I7.PDr|{ docs/Gemfile egdegd f A{1z<4y#W+ . docs/_config.yml eBGeBG f
Űj`%u5 docs/_layouts/default.html eL+}|TeL+}|T f A>dXˋZIy+MR} docs/api.md egdegd f R*d*zЋ.ol docs/appenders.md egdegd f l#] 2S|QV docs/assets/css/style.scss egdegd f ޮEicBOEz docs/categories.md egdegd f êP)c_ZrlL docs/categoryFilter.md egdegd f xfkd docs/clustering.md eB'eB' f [Y2Ul= docs/connect-logger.md egdegd f 'Z+uS{O>0 docs/console.md egdegd f <gVۢ[9B docs/contrib-guidelines.md egdegd f ,בeGQק docs/contributors.md egdegd f 5ĶL0ЌVA`z docs/dateFile.md egdegd f fi/:'RF- docs/faq.md egdegd f KW_iJg
j docs/file.md egdegd f
Ph{ lK.m docs/fileSync.md egdegd f
0xv-Uk(mW8
docs/index.md eX2*peX2*p f %c
^e+F docs/layouts.md eX2*peX2*p f G<nH}J <! docs/logLevelFilter.md eH,4eH,4 f J)(sk# 6tݻ5 docs/migration-guide.md egdegd f
Lƚ"+A 1_ docs/multiFile.md egdegd f |*~?Rǝ#id docs/multiprocess.md eH,4eH,4 f Cbx?] :D)ECF docs/noLogFilter.md e3$e3$ f uUL>庝/7^1? docs/recording.md egdegd f ~9ks]kI=Ѐ</+X docs/stderr.md egdegd f ͒ui:<( docs/stdout.md egdegd f (i2}C> docs/tcp-server.md egdegd f .p9M#ʍ[( docs/tcp.md egdegd f
sq`|? ;d
docs/terms.md egdegd f `g67^R!c. docs/v3-changes.md egdegd f m{)hV%LjG docs/webpack.md egdegd f kd;?ӄ}[g docs/writing-appenders.md egdegd f ٤K :&/ս]_ examples/cluster.js eB'eB' f "\cw:cB vו examples/custom-layout.js egdegd f |bە&J&Q$\hN` examples/date-file-rolling.js egdegd f -H4u "examples/example-connect-logger.js egdegd f P؍)~:zrCs examples/example-socket.js egdegd f DōC4k examples/example.js egdegd f <G.X'Vn examples/flush-on-exit.js egdegd f L{Z|\x examples/fromreadme.js eB'eB' f ),.A]r .BC<K examples/hipchat-appender.js egdegd f ?3P\vj/n1}I`J examples/layouts.js egdegd f >bq:3`:tU< |