jshbrmn/braid
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added unit testing, and started implementing unit tests...phew

Browse Source
This commit is contained in:
Josh Burman
2019-03-12 22:28:02 -04:00
parent 74aad4a957
commit e8c2539f1b
3489 changed files with 464813 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

527
node_modules/winston/CHANGELOG.md generated vendored Normal file
View File

@ -0,0 +1,527 @@
# CHANGELOG
## v3.2.1 / 2018-01-29
### UNBOUND PROTOTYPE AD INFINITUM EDITION
- #[1579], (@indexzero) Fallback to the "root" instance **always** created by
`createLogger` for level convenience methods (e.g. `.info()`, `.silly()`).
(Fixes [#1577]).
- [#1539], (@indexzero) Assume message is the empty string when level-helper
methods are invoked with no arguments (Fixed [#1501]).
- [#1583], (@kibertoad) Add typings for defaultMeta (Fixes [#1582])
- [#1586], (@kibertoad) Update dependencies.
## v3.2.0 / 2018-01-26
### SORRY IT TOO SO LONG EDITION
> **NOTE:** this was our first release using Github Projects. See the
> [3.2.0 Release Project](https://github.com/orgs/winstonjs/projects/3).
### New Features!
- [#1471], (@kibertoad) Implement child loggers.
- [#1462], (@drazisil) Add handleRejection support.
- [#1555], (@DABH) Add fixes from [#1355] to unhandled rejection handler.
- [#1418], (@mfrisbey) Precompile ES6 syntax before publishing to npm.
- [#1533], (@kibertoad) Update to Babel 7.
- [#1562], (@indexzero) [fix] Better handling of `new Error(string)`
throughout the pipeline(s). (Fixes [#1338], [#1486]).
### Bug Fixes
- [#1355], (@DABH) Fix issues with ExceptionHandler (Fixes [#1289]).
- [#1463], (@SerayaEryn) Bubble transport `warn` events up to logger in
addition to `error`s.
- [#1480], [#1503], (@SerayaEryn) File tailrolling fix.
- [#1483], (@soldair) Assign log levels to un-bound functions.
- [#1513], (@TilaTheHun0) Set maxListeners for Console transport.
- [#1521], (@jamesbechet) Fix Transform from `readable-stream` using CRA.
- [#1434], (@Kouzukii) Fixes logger.query function (regression from `3.0.0`)
- [#1526], (@pixtron) Log file without .gz for tailable (Fixes [#1525]).
- [#1559], (@eubnara) Fix typo related to `exitOnError`.
- [#1556], (@adoyle-h) Support to create log directory if it doesn't exist
for FileTransport.
#### New `splat` behavior
- [#1552], (@indexzero) Consistent handling of meta with (and without)
interpolation in `winston` and `logform`.
- [#1499], (@DABH) Provide all of `SPLAT` to formats (Fixes [#1485]).
- [#1485], (@mpabst) Fixing off-by-one when using both meta and splat.
Previously `splat` would have added a `meta` property for any additional
`info[SPLAT]` beyond the expected number of tokens.
**As of `logform@2.0.0`,** `format.splat` assumes additional splat paramters
(aka "metas") are objects and merges enumerable properties into the `info`.
e.g. **BE ADVISED** previous "metas" that _were not objects_ will very likely
lead to odd behavior. e.g.
``` js
const { createLogger, format, transports } = require('winston');
const { splat } = format;
const { MESSAGE, LEVEL, SPLAT } = require('triple-beam');
const logger = createLogger({
format: format.combine(
format.splat(),
format.json()
),
transports: [new transports.Console()]
});
// Expects two tokens, but four splat parameters provided.
logger.info(
'Let us %s for %j', // message
'objects', // used for %s
{ label: 'sure' }, // used for %j
'lol', ['ok', 'why'] // Multiple additional meta values
);
// winston < 3.2.0 && logform@1.x behavior:
// Added "meta" property.
//
// { level: 'info',
// message: 'Let us objects for {"label":"sure"}',
// meta: ['lol', ['ok', 'why']],
// [Symbol(level)]: 'info',
// [Symbol(message)]: 'Let us %s for %j',
// [Symbol(splat)]: [ 'objects', { label: 'sure' } ] }
// winston >= 3.2.0 && logform@2.x behavior: Enumerable properties
// assigned into `info`. Since **strings and Arrays only have NUMERIC
// enumerable properties we get this behavior!**
//
// { '0': 'ok',
// '1': 'why',
// '2': 'l',
// level: 'info',
// message: 'Let us objects for {"label":"sure"}',
// [Symbol(level)]: 'info',
// [Symbol(message)]: 'Let us %s for %j',
// [Symbol(splat)]: [ 'objects', { label: 'sure' } ] }
```
## Maintenance & Documentation
- Documentation Updates
- [#1410], (@hakanostrom) Add docs reference to transport for Cloudant.
- [#1467], (@SeryaEryn) Add fast-file-rotate transport to transport.md.
- [#1488], (@adamcohen) Fix multi logger documentation.
- [#1531], (@mapleeit) Add links to transports.
- [#1548], (@ejmartin504) Fix `README.md` for awaiting logs.
- [#1554], (@indexzero) Document the solution to [#1486] as by design.
- Other small improvements: [#1509].
- Improved TypeScript support
- [#1470], (@jd-carroll) Export all transport options (Fixes [#1469]).
- [#1474], (@jd-carroll) Correct import to avoid conflict (Fixed [#1472]).
- [#1546], (@alewiahmed) Add consoleWarnLevels field to the
`ConsoleTransportOptions` interface type definition.
- [#1557], (@negezor) Add missing `child()` method.
- Dependency management
- [#1560], (@kibertoad) Update dependencies.
- [#1512], (@SerayaEryn) Add node@11 and disallow failures on node@10.
- [#1516], (@SerayaEryn) Update `readable-stream` to `v3.0.6`.
- [#1534], (@kibertoad) Update `@types/node`, `nyc`, and `through2`.
## v3.1.0 / 2018-08-22
### RELEASES ON A PLANE EDITION
- Minor TypeScript fixes [#1362], [#1395], [#1440]
- Fix minor typos [#1359], [#1363], [#1372], [#1378], [#1390]
- [#1373], (@revik): Add `consoleWarnLevels` property to console transport options for `console.warn` browser support.
- [#1394], (@bzoz): Fix tests on Windows.
- [#1447], (@dboshardy): Support transport name option to override default names for built-in transports.
- [#1420], (@ledbit): Fix file rotation with `tailing: true` (Fixes [#1450], [#1194]).
- [#1352], (@lutovich): Add `isLevelEnabled(string)` & `isXXXEnabled()` to `Logger` class.
- Dependency management
- Regenerate `package-lock.json`.
- Upgrade to `colors@^1.3.2` (Fixes [#1439]).
- Upgrade to `logform@^1.9.1`.
- Upgrade to `diagnostics@^1.1.1`.
- Upgrade to `@types/node@^10.9.3`.
- Upgrade to `assume@^2.1.0`.
- Upgrade to `hock@^1.3.3`.
- Upgrade to `mocha@^5.2.0`.
- Upgrade to `nyc@^13.0.1`.
- Upgrade to `split2@^3.0.0`.
## v3.0.0 / 2018-06-12
### GET IN THE CHOPPA EDITION
- [#1332], (@DABH): logger.debug is sent to stderr (Fixed [#1024])
- [#1328], (@ChrisAlderson): Logger level doesn't update transports level (Fixes [#1191]).
- [#1356], (@indexzero) Move splat functionality into logform. (Fixes [#1298]).
- [#1340], (@indexzero): Check log.length when evaluating "legacyness" of transports (Fixes [#1280]).
- [#1346], (@indexzero): Implement `_final` from Node.js streams. (Related to winston-transport#24, Fixes [#1250]).
- [#1347], (@indexzero): Wrap calls to `format.transform` with try / catch (Fixes [#1261]).
- [#1357], (@indexzero): Remove paddings as we have no use for it in the current API.
- [TODO]: REMAINS OPEN, NO PR (Fixes [#1289])
- Documentation
- [#1301], (@westonpace) Cleaned up some of the documentation on `colorize`
to address concerns in [#1095].
- First pass at a heavy refactor of `docs/transports.md`.
- Dependency management
- Regenerate `package-lock.json`.
- Upgrade to `logform@^1.9.0`.
## v3.0.0-rc6 / 2018-05-30
### T-MINUS 6-DAY TO WINSTON@3 EDITION
- **Document that we are pushing for a June 5th, 2018 release of `winston@3.0.0`**
- [#1287], (@DABH) Added types for Typescript.
- [#1335] Typescript: silent is boolean.
- [#1323] Add level method to default logger.
- [#1286], (@ChrisAlderson) Migrate codebase to ES6
- [#1324], (@ChrisAlderson) Fix regression introduced by ES6 migration for
exception handling.
- [#1333], (@ChrisAlderson) Fix removing all loggers from a container.
- [#1291], [#1294], [#1318], (@indexzero, @ChrisAlderson, @mempf) Improvements
to `File` transport core functionality. Fixes [#1194].
- [#1311], (@ChrisAlderson) Add `eol` option to `Stream` transport.
- [#1297], (@ChrisAlderson) Move `winston.config` to `triple-beam`. Expose
for backwards compatibility.
- [#1320], (@ChrisAlderson) Enhance tests to run on Windows.
- Internal project maintenance
- Bump to `winston-transport@4.0.0` which may cause incompatibilities if
your custom transport does not explicitly require `winston-transport`
itself.
- [#1292], (@ChrisAlderson) Add node v10 to TravisCI build matrix.
- [#1296], (@indexzero) Improve `UPGRADE-3.0.md`. Add Github Issue Template.
- Remove "npm run report" in favor of reports being automatically generate.
- Update `logform`, `triple-beam`, and `winston-transport` to latest.
> Special thanks to our newest `winston` core team member – @ChrisAlderson for
> helping make `winston@3.0.0` a reality next week!
## v3.0.0-rc5 / 2018-04-20
### UNOFFICIAL NATIONAL HOLIDAY EDITION
- [#1281] Use `Buffer.alloc` and `Buffer.from` instead of `new Buffer`.
- Better browser support
- [#1142] Move common tailFile to a separate file
- [#1279] Use feature detection to be safer for browser usage.
- MOAR Docs!
- **Document that we are pushing for a May 29th, 2018 release of `winston@3.0.0`**
- **Add David Hyde as official contributor.**
- [#1278] Final Draft of Upgrade Guide in `UPGRADE-3.0.md`
- Merge Roadmap from `3.0.0.md` into `CONTRIBUTING.md` and other
improvements to `CONTRIBUTING.md`
- Improve & expand examples
- [#1175] Add more copy about printf formats based on issue feedback.
- [#1134] Add sampleto document timestamps more clearly as an example.
- [#1273] Add example using multiple formats.
- [#1250] Add an example illustrating the "finish" event for AWS Lambda scenarios.
- Use simple format to better show that `humanReadableUnhandledException` is now the default message format.
- Add example to illustrate that example code from winston-transport
`README.md` is correct.
- Update `devDependencies`
- Bump `assume` to `^2.0.1`.
- Bump `winston-compat` to `^0.1.1`.
## v3.0.0-rc4 / 2018-04-06
### IF A TREE FALLS IN THE FORREST DOES IT MAKE A LOG EDITION
- (@indexzero, @dabh) Add support for `{ silent }` option to
``` js
require('winston').Logger;
require('winston-transport').TransportStream;
```
- Better browser support
- [#1145], (@Jasu) Replace `isstream` with `is-stream` to make stream detection work in browser.
- [#1146], (@Jasu) Rename query to different than function name, to support Babel 6.26.
- Better Typescript support in all supporting libraries
- `logform@1.4.1`
- Update documentation
- (@indexzero) Correct link to upgrade guide. Fixes #1255.
- [#1258], (@morenoh149) Document how to colorize levels. Fixes #1135.
- [#1246], (@KlemenPlazar) Update colors argument when adding custom colors
- Update `CONTRIBUTING.md`
- [#1239], (@dabh) Add changelog entries for `v3.0.0-rc3`
- Add example showing that `{ level }` can be deleted from info objects because `Symbol.for('level')` is what `winston` uses internally. Fixes #1184.
## v3.0.0-rc3 / 2018-03-16
### I GOT NOTHING EDITION
- [#1195], (@Nilegfx) Fix type error when creating `new stream.Stream()`
- [#1109], (@vsetka) Fix file transprot bug where `self.filename` was not being updated on `ENOENT`
- [#1153], (@wizardnet972) Make prototype methods return like the original method
- [#1234], (@guiguan, @indexzero) Add tests for properly handling logging of `undefined`, `null` and `Error` values
- [#1235], (@indexzero) Add example demonstrating how `meta` objects BECOME the `info` object
- Minor fixes to docs & examples: [#1232], [#1185]
## v3.0.0-rc2 / 2018-03-09
### MAINTENANCE RESUMES EDITION
- [#1209], (@dabh) Use new version of colors, solving a number of issues.
- [#1197], (@indexzero) Roadmap & guidelines for contributors.
- [#1100] Require the package.json by its full name.
- [#1149] Updates `async` to latest (`2.6.0`)
- [#1228], (@mcollina) Always pass a function to `fs.close`.
- Minor fixes to docs & examples: [#1177], [#1182], [#1208], [#1198], [#1165], [#1110], [#1117], [#1097], [#1155], [#1084], [#1141], [#1210], [#1223].
## v3.0.0-rc1 / 2017-10-19
### OMG THEY FORGOT TO NAME IT EDITION
- Fix file transport improper binding of `_onDrain` and `_onError` [#1104](https://github.com/winstonjs/winston/pull/1104)
## v3.0.0-rc0 / 2017-10-02
### IT'S-DONE.GIF EDITION
**See [UPGRADE-3.0.md](UPGRADE-3.0.md) for a complete & living upgrade guide.**
**See [3.0.0.md](3.0.0.md) for a list of remaining RC tasks.**
- **Rewrite of core logging internals:** `Logger` & `Transport` are now implemented using Node.js `objectMode` streams.
- **Your transports _should_ not break:** Special attention has been given to ensure backwards compatibility with existing transports. You will likely see this:
```
YourTransport is a legacy winston transport. Consider upgrading to winston@3:
- Upgrade docs: https://github.com/winstonjs/winston/tree/master/UPGRADE.md
```
- **`filters`, `rewriters`, and `common.log` are now _formats_:** `winston.format` offers a simple mechanism for user-land formatting & style features. The organic & frankly messy growth of `common.log` is of the past; these feature requests can be implemented entirely outside of `winston` itself.
``` js
const { createLogger, format, transports } = require('winston');
const { combine, timestamp, label, printf } = format;
const myFormat = printf(info => {
return `${info.timestamp} [${info.label}] ${info.level}: ${info.message}`;
});
const logger = createLogger({
combine(
label({ label: 'right meow!' }),
timestamp(),
myFormat
),
transports: [new transports.Console()]
});
```
- **Increased modularity:** several subsystems are now stand-alone packages:
- [logform] exposed as `winston.format`
- [winston-transport] exposed as `winston.Transport`
- [abstract-winston-transport] used for reusable unit test suites for transport authors.
- **`2.x` branch will get little to no maintenance:** no feature requests will be accepted – only a limited number of open PRs will be merged. Hoping the [significant performance benefits][perf-bench] incentivizes folks to upgrade quickly. Don't agree? Say something!
- **No guaranteed support for `node@4` or below:** all code will be migrated to ES6 over time. This release was started when ES5 was still a hard requirement due to the current LTS needs.
## v2.4.0 / 2017-10-01
### ZOMFG WINSTON@3.0.0-RC0 EDITION
- [#1036] Container.add() 'filters' and 'rewriters' option passing to logger.
- [#1066] Fixed working of "humanReadableUnhandledException" parameter when additional data is added in meta.
- [#1040] Added filtering by log level
- [#1042] Fix regressions brought by `2.3.1`.
- Fix regression on array printing.
- Fix regression on falsy value.
- [#977] Always decycle objects before cloning.
- Fixes [#862]
- Fixes [#474]
- Fixes [#914]
- [57af38a] Missing context in `.lazyDrain` of `File` transport.
- [178935f] Suppress excessive Node warning from `fs.unlink`.
- [fcf04e1] Add `label` option to `File` transport docs.
- [7e736b4], [24300e2] Added more info about undocumented `winston.startTimer()` method.
- [#1076], [#1082], [#1029], [#989], [e1e7188] Minor grammatical & style updates to `README.md`.
## v2.3.1 / 2017-01-20
### WELCOME TO THE APOCALYPSE EDITION
- [#868](https://github.com/winstonjs/winston/pull/868), Fix 'Maximum call stack size exceeded' error with custom formatter.
## v2.3.0 / 2016-11-02
### ZOMG WHY WOULD YOU ASK EDITION
- Full `CHANGELOG.md` entry forthcoming. See [the `git` diff for `2.3.0`](https://github.com/winstonjs/winston/compare/2.2.0...2.3.0) for now.
## v2.2.0 / 2016-02-25
### LEAVING CALIFORNIA EDITION
- Full `CHANGELOG.md` entry forthcoming. See [the `git` diff for `2.2.0`](https://github.com/winstonjs/winston/compare/2.1.1...2.2.0) for now.
## v2.1.1 / 2015-11-18
### COLOR ME IMPRESSED EDITION
- [#751](https://github.com/winstonjs/winston/pull/751), Fix colors not appearing in non-tty environments. Fixes [#609](https://github.com/winstonjs/winston/issues/609), [#616](https://github.com/winstonjs/winston/issues/616), [#669](https://github.com/winstonjs/winston/issues/669), [#648](https://github.com/winstonjs/winston/issues/648) (`fiznool`).
- [#752](https://github.com/winstonjs/winston/pull/752) Correct syslog RFC number. 5424 instead of 524. (`jbenoit2011`)
## v2.1.0 / 2015-11-03
### TEST ALL THE ECOSYSTEM EDITION
- [#742](https://github.com/winstonjs/winston/pull/742), [32d52b7](https://github.com/winstonjs/winston/commit/32d52b7) Distribute common test files used by transports in the `winston` ecosystem.
## v2.0.1 / 2015-11-02
### BUGS ALWAYS HAPPEN OK EDITION
- [#739](https://github.com/winstonjs/winston/issues/739), [1f16861](https://github.com/winstonjs/winston/commit/1f16861) Ensure that `logger.log("info", undefined)` does not throw.
## v2.0.0 / 2015-10-29
### OMG IT'S MY SISTER'S BIRTHDAY EDITION
#### Breaking changes
**Most important**
- **[0f82204](https://github.com/winstonjs/winston/commit/0f82204) Move `winston.transports.DailyRotateFile` [into a separate module](https://github.com/winstonjs/winston-daily-rotate-file)**: `require('winston-daily-rotate-file');`
- **[fb9eec0](https://github.com/winstonjs/winston/commit/fb9eec0) Reverse log levels in `npm` and `cli` configs to conform to [RFC524](https://tools.ietf.org/html/rfc5424). Fixes [#424](https://github.com/winstonjs/winston/pull/424) [#406](https://github.com/winstonjs/winston/pull/406) [#290](https://github.com/winstonjs/winston/pull/290)**
- **[8cd8368](https://github.com/winstonjs/winston/commit/8cd8368) Change the method signature to a `filter` function to be consistent with `rewriter` and log functions:**
``` js
function filter (level, msg, meta, inst) {
// Filter logic goes here...
}
```
**Other breaking changes**
- [e0c9dde](https://github.com/winstonjs/winston/commit/e0c9dde) Remove `winston.transports.Webhook`. Use `winston.transports.Http` instead.
- [f71e638](https://github.com/winstonjs/winston/commit/f71e638) Remove `Logger.prototype.addRewriter` and `Logger.prototype.addFilter` since they just push to an Array of functions. Use `logger.filters.push` or `logger.rewriters.push` explicitly instead.
- [a470ab5](https://github.com/winstonjs/winston/commit/a470ab5) No longer respect the `handleExceptions` option to `new winston.Logger`. Instead just pass in the `exceptionHandlers` option itself.
- [8cb7048](https://github.com/winstonjs/winston/commit/8cb7048) Removed `Logger.prototype.extend` functionality
#### New features
- [3aa990c](https://github.com/winstonjs/winston/commit/3aa990c) Added `Logger.prototype.configure` which now contains all logic previously in the `winston.Logger` constructor function. (`indexzero`)
- [#726](https://github.com/winstonjs/winston/pull/726) Update .npmignore (`coreybutler`)
- [#700](https://github.com/winstonjs/winston/pull/700) Add an `eol` option to the `Console` transport. (`aquavitae`)
- [#731](https://github.com/winstonjs/winston/pull/731) Update `lib/transports.js` for better static analysis. (`indexzero`)
#### Fixes, refactoring, and optimizations. OH MY!
- [#632](https://github.com/winstonjs/winston/pull/632) Allow `File` transport to be an `objectMode` writable stream. (`stambata`)
- [#527](https://github.com/winstonjs/winston/issues/527), [163f4f9](https://github.com/winstonjs/winston/commit/163f4f9), [3747ccf](https://github.com/winstonjs/winston/commit/3747ccf) Performance optimizations and string interpolation edge cases (`indexzero`)
- [f0edafd](https://github.com/winstonjs/winston/commit/f0edafd) Code cleanup for reability, ad-hoc styleguide enforcement (`indexzero`)
## v1.1.1 - v1.1.2 / 2015-10
### MINOR FIXES EDITION
#### Notable changes
* [727](https://github.com/winstonjs/winston/pull/727) Fix "raw" mode (`jcrugzz`)
* [703](https://github.com/winstonjs/winston/pull/703) Do not modify Error or Date objects when logging. Fixes #610 (`harriha`).
## v1.1.0 / 2015-10-09
### GREETINGS FROM CARTAGENA EDITION
#### Notable Changes
* [#721](https://github.com/winstonjs/winston/pull/721) Fixed octal literal to work with node 4 strict mode (`wesleyeff`)
* [#630](https://github.com/winstonjs/winston/pull/630) Add stderrLevels option to Console Transport and update docs (`paulhroth`)
* [#626](https://github.com/winstonjs/winston/pull/626) Add the logger (this) in the fourth argument in the rewriters and filters functions (`christophehurpeau `)
* [#623](https://github.com/winstonjs/winston/pull/623) Fix Console Transport's align option tests (`paulhroth`, `kikobeats`)
* [#692](https://github.com/winstonjs/winston/pull/692) Adding winston-aws-cloudwatch to transport docs (`timdp`)
## v1.0.2 2015-09-25
### LET'S TALK ON GITTER EDITION
#### Notable Changes
* [de80160](https://github.com/winstonjs/winston/commit/de80160) Add Gitter badge (`The Gitter Badger`)
* [44564de](https://github.com/winstonjs/winston/commit/44564de) [fix] Correct listeners in `logException`. Fixes [#218](https://github.com/winstonjs/winston/issues/218) [#213](https://github.com/winstonjs/winston/issues/213) [#327](https://github.com/winstonjs/winston/issues/327). (`indexzero`)
* [45b1eeb](https://github.com/winstonjs/winston/commit/45b1eeb) [fix] Get `tailFile` function working on latest/all node versions (`Christopher Jeffrey`)
* [c6d45f9](https://github.com/winstonjs/winston/commit/c6d45f9) Fixed event subscription on close (`Roman Stetsyshin`)
#### Other changes
* TravisCI updates & best practices [87b97cc](https://github.com/winstonjs/winston/commit/87b97cc) [91a5bc4](https://github.com/winstonjs/winston/commit/91a5bc4), [cf24e6a](https://github.com/winstonjs/winston/commit/cf24e6a) (`indexzero`)
* [d5397e7](https://github.com/winstonjs/winston/commit/d5397e7) Bump async version (`Roderick Hsiao`)
* Documentation updates & fixes [86d7527](https://github.com/winstonjs/winston/commit/86d7527), [38254c1](https://github.com/winstonjs/winston/commit/38254c1), [04e2928](https://github.com/winstonjs/winston/commit/04e2928), [61c8a89](https://github.com/winstonjs/winston/commit/61c8a89), [c42a783](https://github.com/winstonjs/winston/commit/c42a783), [0688a22](https://github.com/winstonjs/winston/commit/0688a22), [eabc113](https://github.com/winstonjs/winston/commit/eabc113) [c9506b7](https://github.com/winstonjs/winston/commit/c9506b7), [17534d2](https://github.com/winstonjs/winston/commit/17534d2), [b575e7b](https://github.com/winstonjs/winston/commit/b575e7b) (`Stefan Thies`, `charukiewicz`, `unLucio`, `Adam Cohen`, `Denis Gorbachev`, `Frederik Ring`, `Luigi Pinca`, `jeffreypriebe`)
* Documentation refactor & cleanup [a19607e](https://github.com/winstonjs/winston/commit/a19607e), [d1932b4](https://github.com/winstonjs/winston/commit/d1932b4), [7a13132](https://github.com/winstonjs/winston/commit/7a13132) (`indexzero`)
## v1.0.1 / 2015-06-26
### YAY DOCS EDITION
* [#639](https://github.com/winstonjs/winston/pull/639) Fix for [#213](https://github.com/winstonjs/winston/issues/213): More than 10 containers triggers EventEmitter memory leak warning (`marcus`)
* Documentation and `package.json` updates [cec892c](https://github.com/winstonjs/winston/commit/cec892c), [2f13b4f](https://github.com/winstonjs/winston/commit/2f13b4f), [b246efd](https://github.com/winstonjs/winston/commit/b246efd), [22a5f5a](https://github.com/winstonjs/winston/commit/22a5f5a), [5868b78](https://github.com/winstonjs/winston/commit/5868b78), [99b6b44](https://github.com/winstonjs/winston/commit/99b6b44), [447a813](https://github.com/winstonjs/winston/commit/447a813), [7f75b48](https://github.com/winstonjs/winston/commit/7f75b48) (`peteward44`, `Gilad Peleg`, `Anton Ian Sipos`, `nimrod-becker`, `LarsTi`, `indexzero`)
## v1.0.0 / 2015-04-07
### OMG 1.0.0 FINALLY EDITION
#### Breaking Changes
* [#587](https://github.com/winstonjs/winston/pull/587) Do not extend `String` prototypes as a side effect of using `colors`. (`kenperkins`)
* [#581](https://github.com/winstonjs/winston/pull/581) File transports now emit `error` on error of the underlying streams after `maxRetries` attempts. (`ambbell`).
* [#583](https://github.com/winstonjs/winston/pull/583), [92729a](https://github.com/winstonjs/winston/commit/92729a68d71d07715501c35d94d2ac06ac03ca08) Use `os.EOL` for all file writing by default. (`Mik13`, `indexzero`)
* [#532](https://github.com/winstonjs/winston/pull/532) Delete logger instance from `Container` when `close` event is emitted. (`snater`)
* [#380](https://github.com/winstonjs/winston/pull/380) Rename `duration` to `durationMs`, which is now a number a not a string ending in `ms`. (`neoziro`)
* [#253](https://github.com/winstonjs/winston/pull/253) Do not set a default level. When `level` is falsey on any `Transport` instance, any `Logger` instance uses the configured level (instead of the Transport level) (`jstamerj`).
#### Other changes
* [b83de62](https://github.com/winstonjs/winston/commit/b83de62) Fix rendering of stack traces.
* [c899cc](https://github.com/winstonjs/winston/commit/c899cc1f0719e49b26ec933e0fa263578168ea3b) Update documentation (Fixes [#549](https://github.com/winstonjs/winston/issues/549))
* [#551](https://github.com/winstonjs/winston/pull/551) Filter metadata along with messages
* [#578](https://github.com/winstonjs/winston/pull/578) Fixes minor issue with `maxFiles` in `File` transport (Fixes [#556](https://github.com/winstonjs/winston/issues/556)).
* [#560](https://github.com/winstonjs/winston/pull/560) Added `showLevel` support to `File` transport.
* [#558](https://github.com/winstonjs/winston/pull/558) Added `showLevel` support to `Console` transport.
## v0.9.0 / 2015-02-03
* [#496](https://github.com/flatiron/winston/pull/496) Updated default option handling for CLI (`oojacoboo`).
* [f37634b](https://github.com/flatiron/winston/commit/f37634b) [dist] Only support `node >= 0.8.0`. (`indexzero`)
* [91a1e90](https://github.com/flatiron/winston/commit/91a1e90), [50163a0](https://github.com/flatiron/winston/commit/50163a0) Fix #84 [Enable a better unhandled exception experience](https://github.com/flatiron/winston/issues/84) (`samz`)
* [8b5fbcd](https://github.com/flatiron/winston/commit/8b5fbcd) #448 Added tailable option to file transport which rolls files backwards instead of creating incrementing appends. Implements #268 (`neouser99`)
* [a34f7d2](https://github.com/flatiron/winston/commit/a34f7d2) Custom log formatter functionality were added. (`Melnyk Andii`)
* [4c08191](https://github.com/flatiron/winston/commit/4c08191) Added showLevel flag to common.js, file*, memory and console transports. (`Tony Germaneri`)
* [64ed8e0](https://github.com/flatiron/winston/commit/64ed8e0) Adding custom pretty print function test. (`Alberto Pose`)
* [3872dfb](https://github.com/flatiron/winston/commit/3872dfb) Adding prettyPrint parameter as function example. (`Alberto Pose`)
* [2b96eee](https://github.com/flatiron/winston/commit/2b96eee) implemented filters #526 (`Chris Oloff`)
* [72273b1](https://github.com/flatiron/winston/commit/72273b1) Added the options to colorize only the level, only the message or all. Default behavior is kept. Using true will only colorize the level and false will not colorize anything. (`Michiel De Mey`)
* [178e8a6](https://github.com/flatiron/winston/commit/178e8a6) Prevent message from meta input being overwritten (`Leonard Martin`)
* [270be86](https://github.com/flatiron/winston/commit/270be86) [api] Allow for transports to be removed by their string name [test fix] Add test coverage for multiple transports of the same type added in #187. [doc] Document using multiple transports of the same type (`indexzero`)
* [0a848fa](https://github.com/flatiron/winston/commit/0a848fa) Add depth options for meta pretty print (`Loïc Mahieu`)
* [106b670](https://github.com/flatiron/winston/commit/106b670) Allow debug messages to be sent to stdout (`John Frizelle`)
* [ad2d5e1](https://github.com/flatiron/winston/commit/ad2d5e1) [fix] Handle Error instances in a sane way since their properties are non-enumerable __by default.__ Fixes #280. (`indexzero`)
* [5109dd0](https://github.com/flatiron/winston/commit/5109dd0) [fix] Have a default `until` before a default `from`. Fixes #478. (`indexzero`)
* [d761960](https://github.com/flatiron/winston/commit/d761960) Fix logging regular expression objects (`Chasen Le Hara`)
* [2632eb8](https://github.com/flatiron/winston/commit/2632eb8) Add option for EOL chars on FileTransport (`José F. Romaniello`)
* [bdecce7](https://github.com/flatiron/winston/commit/bdecce7) Remove duplicate logstash option (`José F. Romaniello`)
* [7a01f9a](https://github.com/flatiron/winston/commit/7a01f9a) Update declaration block according to project's style guide (`Ricardo Torres`)
* [ae27a19](https://github.com/flatiron/winston/commit/ae27a19) Fixes #306: Can't set customlevels to my loggers (RangeError: Maximum call stack size exceeded) (`Alberto Pose`)
* [1ba4f51](https://github.com/flatiron/winston/commit/1ba4f51) [fix] Call `res.resume()` in HttpTransport to get around known issues in streams2. (`indexzero`)
* [39e0258](https://github.com/flatiron/winston/commit/39e0258) Updated default option handling for CLI (`Jacob Thomason`)
* [8252801](https://github.com/flatiron/winston/commit/8252801) Added logstash support to console transport (`Ramon Snir`)
* [18aa301](https://github.com/flatiron/winston/commit/18aa301) Module isStream should be isstream (`Michael Neil`)
* [2f5f296](https://github.com/flatiron/winston/commit/2f5f296) options.prettyPrint can now be a function (`Matt Zukowski`)
* [a87a876](https://github.com/flatiron/winston/commit/a87a876) Adding rotationFormat prop to file.js (`orcaman`)
* [ff187f4](https://github.com/flatiron/winston/commit/ff187f4) Allow custom exception level (`jupiter`)
## 0.8.3 / 2014-11-04
* [fix lowercase issue (`jcrugzz`)](https://github.com/flatiron/winston/commit/b3ffaa10b5fe9d2a510af5348cf4fb3870534123)
## 0.8.2 / 2014-11-04
* [Full fix for #296 with proper streams2 detection with `isstream` for file transport (`jcrugzz`)](https://github.com/flatiron/winston/commit/5c4bd4191468570e46805ed399cad63cfb1856cc)
* [Add isstream module (`jcrugzz`)](https://github.com/flatiron/winston/commit/498b216d0199aebaef72ee4d8659a00fb737b9ae)
* [Partially fix #296 with streams2 detection for file transport (`indexzero`)](https://github.com/flatiron/winston/commit/b0227b6c27cf651ffa8b8192ef79ab24296362e3)
* [add stress test for issue #288 (`indexzero`)](https://github.com/flatiron/winston/commit/e08e504b5b3a00f0acaade75c5ba69e6439c84a6)
* [lessen timeouts to check test sanity (`indexzero`)](https://github.com/flatiron/winston/commit/e925f5bc398a88464f3e796545ff88912aff7568)
* [update winston-graylog2 documentation (`unlucio`)](https://github.com/flatiron/winston/commit/49fa86c31baf12c8ac3adced3bdba6deeea2e363)
* [fix test formatting (`indexzero`)](https://github.com/flatiron/winston/commit/8e2225799520a4598044cdf93006d216812a27f9)
* [fix so options are not redefined (`indexzero`)](https://github.com/flatiron/winston/commit/d1d146e8a5bb73dcb01579ad433f6d4f70b668ea)
* [fix self/this issue that broke `http` transport (`indexzero`)](https://github.com/flatiron/winston/commit/d10cbc07755c853b60729ab0cd14aa665da2a63b)
## 0.8.1 / 2014-10-06
* [Add label option for DailyRotateFile transport (`francoisTemasys`)](https://github.com/flatiron/winston/pull/459)
* [fix Logger#transports length check upon Logger#log (`adriano-di-giovanni`, `indexzero`)](https://github.com/flatiron/winston/pull/404)
* [err can be a string. (`gdw2`, `indexzero`)](https://github.com/flatiron/winston/pull/396)
* [Added color for pre-defined cli set. (`danilo1105`, `indexzero`)](https://github.com/flatiron/winston/pull/365)
* [Fix dates on transport test (`revington`)](https://github.com/flatiron/winston/pull/346)
* [Included the label from options to the output in JSON mode. (`arxony`)](https://github.com/flatiron/winston/pull/326)
* [Allow using logstash option with the File transport (`gmajoulet`)](https://github.com/flatiron/winston/pull/299)
* [Be more defensive when working with `query` methods from Transports. Fixes #356. (indexzero)](https://github.com/flatiron/winston/commit/b80638974057f74b521dbe6f43fef2105110afa2)
* [Catch exceptions for file transport unlinkSync (`calvinfo`)](https://github.com/flatiron/winston/pull/266)
* [Adding the 'addRewriter' to winston (`machadogj`)](https://github.com/flatiron/winston/pull/258)
* [Updates to transport documentation (`pose`)](https://github.com/flatiron/winston/pull/262)
* [fix typo in "Extending another object with Logging" section.](https://github.com/flatiron/winston/pull/281)
* [Updated README.md - Replaced properties with those listed in winston-mongodb module](https://github.com/flatiron/winston/pull/264)
## 0.8.0 / 2014-09-15
* [Fixes for HTTP Transport](https://github.com/flatiron/winston/commit/a876a012641f8eba1a976eada15b6687d4a03f82)
* Removing [jsonquest](https://github.com/flatiron/winston/commit/4f088382aeda28012b7a0498829ceb243ed74ac1) and [request](https://github.com/flatiron/winston/commit/a5676313b4e9744802cc3b8e1468e4af48830876) dependencies.
* Configuration is now [shalow cloned](https://github.com/flatiron/winston/commit/08fccc81d18536d33050496102d98bde648853f2).
* [Added logstash support](https://github.com/flatiron/winston/pull/445/files)
* Fix for ["flush" event should always fire after "flush" call bug](https://github.com/flatiron/winston/pull/446/files)
* Added tests for file: [open and stress](https://github.com/flatiron/winston/commit/47d885797a2dd0d3cd879305ca813a0bd951c378).
* [Test fixes](https://github.com/flatiron/winston/commit/9e39150e0018f43d198ca4c160acef2af9860bf4)
* [Fix ")" on string interpolation](https://github.com/flatiron/winston/pull/394/files)
## 0.6.2 / 2012-07-08
* Added prettyPrint option for console logging
* Multi-line values for conditional returns are not allowed
* Added acceptance of `stringify` option
* Fixed padding for log levels

19
node_modules/winston/LICENSE generated vendored Normal file
View File

@ -0,0 +1,19 @@
Copyright (c) 2010 Charlie Robbins
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

1144
node_modules/winston/README.md generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

29
node_modules/winston/appveyor.yml generated vendored Normal file
View File

@ -0,0 +1,29 @@
version: "{build}"
environment:
matrix:
- nodejs_version: 6
- nodejs_version: 8
- nodejs_version: 10
matrix:
fast_finish: true
platform: x64
install:
- ps: Install-Product node $env:nodejs_version $env:platform
- npm install
- npm install typescript
build: off
test_script:
- .\node_modules\.bin\tsc --version
- .\node_modules\.bin\tsc -p test
- npm run test
notifications:
- provider: Email
to:
- travis@nodejitsu.com

172
node_modules/winston/dist/winston.js generated vendored Normal file
View File

@ -0,0 +1,172 @@
/**
* winston.js: Top-level include defining Winston.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
var logform = require('logform');
var _require = require('./winston/common'),
warn = _require.warn;
/**
* Setup to expose.
* @type {Object}
*/
var winston = exports;
/**
* Expose version. Use `require` method for `webpack` support.
* @type {string}
*/
winston.version = require('../package.json').version;
/**
* Include transports defined by default by winston
* @type {Array}
*/
winston.transports = require('./winston/transports');
/**
* Expose utility methods
* @type {Object}
*/
winston.config = require('./winston/config');
/**
* Hoist format-related functionality from logform.
* @type {Object}
*/
winston.addColors = logform.levels;
/**
* Hoist format-related functionality from logform.
* @type {Object}
*/
winston.format = logform.format;
/**
* Expose core Logging-related prototypes.
* @type {function}
*/
winston.createLogger = require('./winston/create-logger');
/**
* Expose core Logging-related prototypes.
* @type {Object}
*/
winston.ExceptionHandler = require('./winston/exception-handler');
/**
* Expose core Logging-related prototypes.
* @type {Object}
*/
winston.RejectionHandler = require('./winston/rejection-handler');
/**
* Expose core Logging-related prototypes.
* @type {Container}
*/
winston.Container = require('./winston/container');
/**
* Expose core Logging-related prototypes.
* @type {Object}
*/
winston.Transport = require('winston-transport');
/**
* We create and expose a default `Container` to `winston.loggers` so that the
* programmer may manage multiple `winston.Logger` instances without any
* additional overhead.
* @example
* // some-file1.js
* const logger = require('winston').loggers.get('something');
*
* // some-file2.js
* const logger = require('winston').loggers.get('something');
*/
winston.loggers = new winston.Container();
/**
* We create and expose a 'defaultLogger' so that the programmer may do the
* following without the need to create an instance of winston.Logger directly:
* @example
* const winston = require('winston');
* winston.log('info', 'some message');
* winston.error('some error');
*/
var defaultLogger = winston.createLogger(); // Pass through the target methods onto `winston.
Object.keys(winston.config.npm.levels).concat(['log', 'query', 'stream', 'add', 'remove', 'clear', 'profile', 'startTimer', 'handleExceptions', 'unhandleExceptions', 'handleRejections', 'unhandleRejections', 'configure']).forEach(function (method) {
return winston[method] = function () {
return defaultLogger[method].apply(defaultLogger, arguments);
};
});
/**
* Define getter / setter for the default logger level which need to be exposed
* by winston.
* @type {string}
*/
Object.defineProperty(winston, 'level', {
get: function get() {
return defaultLogger.level;
},
set: function set(val) {
defaultLogger.level = val;
}
});
/**
* Define getter for `exceptions` which replaces `handleExceptions` and
* `unhandleExceptions`.
* @type {Object}
*/
Object.defineProperty(winston, 'exceptions', {
get: function get() {
return defaultLogger.exceptions;
}
});
/**
* Define getters / setters for appropriate properties of the default logger
* which need to be exposed by winston.
* @type {Logger}
*/
['exitOnError'].forEach(function (prop) {
Object.defineProperty(winston, prop, {
get: function get() {
return defaultLogger[prop];
},
set: function set(val) {
defaultLogger[prop] = val;
}
});
});
/**
* The default transports and exceptionHandlers for the default winston logger.
* @type {Object}
*/
Object.defineProperty(winston, 'default', {
get: function get() {
return {
exceptionHandlers: defaultLogger.exceptionHandlers,
rejectionHandlers: defaultLogger.rejectionHandlers,
transports: defaultLogger.transports
};
}
}); // Have friendlier breakage notices for properties that were exposed by default
// on winston < 3.0.
warn.deprecated(winston, 'setLevels');
warn.forFunctions(winston, 'useFormat', ['cli']);
warn.forProperties(winston, 'useFormat', ['padLevels', 'stripColors']);
warn.forFunctions(winston, 'deprecated', ['addRewriter', 'addFilter', 'clone', 'extend']);
warn.forProperties(winston, 'deprecated', ['emitErrs', 'levelLength']); // Throw a useful error when users attempt to run `new winston.Logger`.
warn.moved(winston, 'createLogger', 'Logger');

56
node_modules/winston/dist/winston/common.js generated vendored Normal file
View File

@ -0,0 +1,56 @@
/**
* common.js: Internal helper and utility functions for winston.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
var _require = require('util'),
format = _require.format;
/**
* Set of simple deprecation notices and a way to expose them for a set of
* properties.
* @type {Object}
* @private
*/
exports.warn = {
deprecated: function deprecated(prop) {
return function () {
throw new Error(format('{ %s } was removed in winston@3.0.0.', prop));
};
},
useFormat: function useFormat(prop) {
return function () {
throw new Error([format('{ %s } was removed in winston@3.0.0.', prop), 'Use a custom winston.format = winston.format(function) instead.'].join('\n'));
};
},
forFunctions: function forFunctions(obj, type, props) {
props.forEach(function (prop) {
obj[prop] = exports.warn[type](prop);
});
},
moved: function moved(obj, movedTo, prop) {
function movedNotice() {
return function () {
throw new Error([format('winston.%s was moved in winston@3.0.0.', prop), format('Use a winston.%s instead.', movedTo)].join('\n'));
};
}
Object.defineProperty(obj, prop, {
get: movedNotice,
set: movedNotice
});
},
forProperties: function forProperties(obj, type, props) {
props.forEach(function (prop) {
var notice = exports.warn[type](prop);
Object.defineProperty(obj, prop, {
get: notice,
set: notice
});
});
}
};

37
node_modules/winston/dist/winston/config/index.js generated vendored Normal file
View File

@ -0,0 +1,37 @@
/**
* index.js: Default settings for all levels that winston knows about.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
var logform = require('logform');
var _require = require('triple-beam'),
configs = _require.configs;
/**
* Export config set for the CLI.
* @type {Object}
*/
exports.cli = logform.levels(configs.cli);
/**
* Export config set for npm.
* @type {Object}
*/
exports.npm = logform.levels(configs.npm);
/**
* Export config set for the syslog.
* @type {Object}
*/
exports.syslog = logform.levels(configs.syslog);
/**
* Hoist addColors from logform where it was refactored into in winston@3.
* @type {Object}
*/
exports.addColors = logform.levels;

149
node_modules/winston/dist/winston/container.js generated vendored Normal file
View File

@ -0,0 +1,149 @@
/**
* container.js: Inversion of control container for winston logger instances.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
var createLogger = require('./create-logger');
/**
* Inversion of control container for winston logger instances.
* @type {Container}
*/
module.exports =
/*#__PURE__*/
function () {
/**
* Constructor function for the Container object responsible for managing a
* set of `winston.Logger` instances based on string ids.
* @param {!Object} [options={}] - Default pass-thru options for Loggers.
*/
function Container() {
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
_classCallCheck(this, Container);
this.loggers = new Map();
this.options = options;
}
/**
* Retreives a `winston.Logger` instance for the specified `id`. If an
* instance does not exist, one is created.
* @param {!string} id - The id of the Logger to get.
* @param {?Object} [options] - Options for the Logger instance.
* @returns {Logger} - A configured Logger instance with a specified id.
*/
_createClass(Container, [{
key: "add",
value: function add(id, options) {
var _this = this;
if (!this.loggers.has(id)) {
// Remark: Simple shallow clone for configuration options in case we pass
// in instantiated protoypal objects
options = Object.assign({}, options || this.options);
var existing = options.transports || this.options.transports; // Remark: Make sure if we have an array of transports we slice it to
// make copies of those references.
options.transports = existing ? existing.slice() : [];
var logger = createLogger(options);
logger.on('close', function () {
return _this._delete(id);
});
this.loggers.set(id, logger);
}
return this.loggers.get(id);
}
/**
* Retreives a `winston.Logger` instance for the specified `id`. If
* an instance does not exist, one is created.
* @param {!string} id - The id of the Logger to get.
* @param {?Object} [options] - Options for the Logger instance.
* @returns {Logger} - A configured Logger instance with a specified id.
*/
}, {
key: "get",
value: function get(id, options) {
return this.add(id, options);
}
/**
* Check if the container has a logger with the id.
* @param {?string} id - The id of the Logger instance to find.
* @returns {boolean} - Boolean value indicating if this instance has a
* logger with the specified `id`.
*/
}, {
key: "has",
value: function has(id) {
return !!this.loggers.has(id);
}
/**
* Closes a `Logger` instance with the specified `id` if it exists.
* If no `id` is supplied then all Loggers are closed.
* @param {?string} id - The id of the Logger instance to close.
* @returns {undefined}
*/
}, {
key: "close",
value: function close(id) {
var _this2 = this;
if (id) {
return this._removeLogger(id);
}
this.loggers.forEach(function (val, key) {
return _this2._removeLogger(key);
});
}
/**
* Remove a logger based on the id.
* @param {!string} id - The id of the logger to remove.
* @returns {undefined}
* @private
*/
}, {
key: "_removeLogger",
value: function _removeLogger(id) {
if (!this.loggers.has(id)) {
return;
}
var logger = this.loggers.get(id);
logger.close();
this._delete(id);
}
/**
* Deletes a `Logger` instance with the specified `id`.
* @param {!string} id - The id of the Logger instance to delete from
* container.
* @returns {undefined}
* @private
*/
}, {
key: "_delete",
value: function _delete(id) {
this.loggers.delete(id);
}
}]);
return Container;
}();

137
node_modules/winston/dist/winston/create-logger.js generated vendored Normal file
View File

@ -0,0 +1,137 @@
/**
* create-logger.js: Logger factory for winston logger instances.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var _require = require('triple-beam'),
LEVEL = _require.LEVEL;
var config = require('./config');
var Logger = require('./logger');
var debug = require('diagnostics')('winston:create-logger');
function isLevelEnabledFunctionName(level) {
return 'is' + level.charAt(0).toUpperCase() + level.slice(1) + 'Enabled';
}
/**
* Create a new instance of a winston Logger. Creates a new
* prototype for each instance.
* @param {!Object} opts - Options for the created logger.
* @returns {Logger} - A newly created logger instance.
*/
module.exports = function () {
var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
//
// Default levels: npm
//
opts.levels = opts.levels || config.npm.levels;
/**
* DerivedLogger to attach the logs level methods.
* @type {DerivedLogger}
* @extends {Logger}
*/
var DerivedLogger =
/*#__PURE__*/
function (_Logger) {
_inherits(DerivedLogger, _Logger);
/**
* Create a new class derived logger for which the levels can be attached to
* the prototype of. This is a V8 optimization that is well know to increase
* performance of prototype functions.
* @param {!Object} options - Options for the created logger.
*/
function DerivedLogger(options) {
_classCallCheck(this, DerivedLogger);
return _possibleConstructorReturn(this, _getPrototypeOf(DerivedLogger).call(this, options));
}
return DerivedLogger;
}(Logger);
var logger = new DerivedLogger(opts); //
// Create the log level methods for the derived logger.
//
Object.keys(opts.levels).forEach(function (level) {
debug('Define prototype method for "%s"', level);
if (level === 'log') {
// eslint-disable-next-line no-console
console.warn('Level "log" not defined: conflicts with the method "log". Use a different level name.');
return;
} //
// Define prototype methods for each log level e.g.:
// logger.log('info', msg) implies these methods are defined:
// - logger.info(msg)
// - logger.isInfoEnabled()
//
// Remark: to support logger.child this **MUST** be a function
// so it'll always be called on the instance instead of a fixed
// place in the prototype chain.
//
DerivedLogger.prototype[level] = function () {
// Prefer any instance scope, but default to "root" logger
var self = this || logger; // Optimize the hot-path which is the single object.
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
if (args.length === 1) {
var msg = args[0];
var info = msg && msg.message && msg || {
message: msg
};
info.level = info[LEVEL] = level;
self._addDefaultMeta(info);
self.write(info);
return this || logger;
} // When provided nothing assume the empty string
if (args.length === 0) {
self.log(level, '');
return self;
} // Otherwise build argument list which could potentially conform to
// either:
// . v3 API: log(obj)
// 2. v1/v2 API: log(level, msg, ... [string interpolate], [{metadata}], [callback])
return self.log.apply(self, [level].concat(args));
};
DerivedLogger.prototype[isLevelEnabledFunctionName(level)] = function () {
return (this || logger).isLevelEnabled(level);
};
});
return logger;
};

290
node_modules/winston/dist/winston/exception-handler.js generated vendored Normal file
View File

@ -0,0 +1,290 @@
/**
* exception-handler.js: Object for handling uncaughtException events.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
var os = require('os');
var asyncForEach = require('async/forEach');
var debug = require('diagnostics')('winston:exception');
var once = require('one-time');
var stackTrace = require('stack-trace');
var ExceptionStream = require('./exception-stream');
/**
* Object for handling uncaughtException events.
* @type {ExceptionHandler}
*/
module.exports =
/*#__PURE__*/
function () {
/**
* TODO: add contructor description
* @param {!Logger} logger - TODO: add param description
*/
function ExceptionHandler(logger) {
_classCallCheck(this, ExceptionHandler);
if (!logger) {
throw new Error('Logger is required to handle exceptions');
}
this.logger = logger;
this.handlers = new Map();
}
/**
* Handles `uncaughtException` events for the current process by adding any
* handlers passed in.
* @returns {undefined}
*/
_createClass(ExceptionHandler, [{
key: "handle",
value: function handle() {
var _this = this;
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
args.forEach(function (arg) {
if (Array.isArray(arg)) {
return arg.forEach(function (handler) {
return _this._addHandler(handler);
});
}
_this._addHandler(arg);
});
if (!this.catcher) {
this.catcher = this._uncaughtException.bind(this);
process.on('uncaughtException', this.catcher);
}
}
/**
* Removes any handlers to `uncaughtException` events for the current
* process. This does not modify the state of the `this.handlers` set.
* @returns {undefined}
*/
}, {
key: "unhandle",
value: function unhandle() {
var _this2 = this;
if (this.catcher) {
process.removeListener('uncaughtException', this.catcher);
this.catcher = false;
Array.from(this.handlers.values()).forEach(function (wrapper) {
return _this2.logger.unpipe(wrapper);
});
}
}
/**
* TODO: add method description
* @param {Error} err - Error to get information about.
* @returns {mixed} - TODO: add return description.
*/
}, {
key: "getAllInfo",
value: function getAllInfo(err) {
var message = err.message;
if (!message && typeof err === 'string') {
message = err;
}
return {
error: err,
// TODO (indexzero): how do we configure this?
level: 'error',
message: ["uncaughtException: ".concat(message || '(no error message)'), err.stack || ' No stack trace'].join('\n'),
stack: err.stack,
exception: true,
date: new Date().toString(),
process: this.getProcessInfo(),
os: this.getOsInfo(),
trace: this.getTrace(err)
};
}
/**
* Gets all relevant process information for the currently running process.
* @returns {mixed} - TODO: add return description.
*/
}, {
key: "getProcessInfo",
value: function getProcessInfo() {
return {
pid: process.pid,
uid: process.getuid ? process.getuid() : null,
gid: process.getgid ? process.getgid() : null,
cwd: process.cwd(),
execPath: process.execPath,
version: process.version,
argv: process.argv,
memoryUsage: process.memoryUsage()
};
}
/**
* Gets all relevant OS information for the currently running process.
* @returns {mixed} - TODO: add return description.
*/
}, {
key: "getOsInfo",
value: function getOsInfo() {
return {
loadavg: os.loadavg(),
uptime: os.uptime()
};
}
/**
* Gets a stack trace for the specified error.
* @param {mixed} err - TODO: add param description.
* @returns {mixed} - TODO: add return description.
*/
}, {
key: "getTrace",
value: function getTrace(err) {
var trace = err ? stackTrace.parse(err) : stackTrace.get();
return trace.map(function (site) {
return {
column: site.getColumnNumber(),
file: site.getFileName(),
function: site.getFunctionName(),
line: site.getLineNumber(),
method: site.getMethodName(),
native: site.isNative()
};
});
}
/**
* Helper method to add a transport as an exception handler.
* @param {Transport} handler - The transport to add as an exception handler.
* @returns {void}
*/
}, {
key: "_addHandler",
value: function _addHandler(handler) {
if (!this.handlers.has(handler)) {
handler.handleExceptions = true;
var wrapper = new ExceptionStream(handler);
this.handlers.set(handler, wrapper);
this.logger.pipe(wrapper);
}
}
/**
* Logs all relevant information around the `err` and exits the current
* process.
* @param {Error} err - Error to handle
* @returns {mixed} - TODO: add return description.
* @private
*/
}, {
key: "_uncaughtException",
value: function _uncaughtException(err) {
var info = this.getAllInfo(err);
var handlers = this._getExceptionHandlers(); // Calculate if we should exit on this error
var doExit = typeof this.logger.exitOnError === 'function' ? this.logger.exitOnError(err) : this.logger.exitOnError;
var timeout;
if (!handlers.length && doExit) {
// eslint-disable-next-line no-console
console.warn('winston: exitOnError cannot be true with no exception handlers.'); // eslint-disable-next-line no-console
console.warn('winston: not exiting process.');
doExit = false;
}
function gracefulExit() {
debug('doExit', doExit);
debug('process._exiting', process._exiting);
if (doExit && !process._exiting) {
// Remark: Currently ignoring any exceptions from transports when
// catching uncaught exceptions.
if (timeout) {
clearTimeout(timeout);
} // eslint-disable-next-line no-process-exit
process.exit(1);
}
}
if (!handlers || handlers.length === 0) {
return process.nextTick(gracefulExit);
} // Log to all transports attempting to listen for when they are completed.
asyncForEach(handlers, function (handler, next) {
var done = once(next);
var transport = handler.transport || handler; // Debug wrapping so that we can inspect what's going on under the covers.
function onDone(event) {
return function () {
debug(event);
done();
};
}
transport._ending = true;
transport.once('finish', onDone('finished'));
transport.once('error', onDone('error'));
}, function () {
return doExit && gracefulExit();
});
this.logger.log(info); // If exitOnError is true, then only allow the logging of exceptions to
// take up to `3000ms`.
if (doExit) {
timeout = setTimeout(gracefulExit, 3000);
}
}
/**
* Returns the list of transports and exceptionHandlers for this instance.
* @returns {Array} - List of transports and exceptionHandlers for this
* instance.
* @private
*/
}, {
key: "_getExceptionHandlers",
value: function _getExceptionHandlers() {
// Remark (indexzero): since `logger.transports` returns all of the pipes
// from the _readableState of the stream we actually get the join of the
// explicit handlers and the implicit transports with
// `handleExceptions: true`
return this.logger.transports.filter(function (wrap) {
var transport = wrap.transport || wrap;
return transport.handleExceptions;
});
}
}]);
return ExceptionHandler;
}();

90
node_modules/winston/dist/winston/exception-stream.js generated vendored Normal file
View File

@ -0,0 +1,90 @@
/**
* exception-stream.js: TODO: add file header handler.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var _require = require('readable-stream'),
Writable = _require.Writable;
/**
* TODO: add class description.
* @type {ExceptionStream}
* @extends {Writable}
*/
module.exports =
/*#__PURE__*/
function (_Writable) {
_inherits(ExceptionStream, _Writable);
/**
* Constructor function for the ExceptionStream responsible for wrapping a
* TransportStream; only allowing writes of `info` objects with
* `info.exception` set to true.
* @param {!TransportStream} transport - Stream to filter to exceptions
*/
function ExceptionStream(transport) {
var _this;
_classCallCheck(this, ExceptionStream);
_this = _possibleConstructorReturn(this, _getPrototypeOf(ExceptionStream).call(this, {
objectMode: true
}));
if (!transport) {
throw new Error('ExceptionStream requires a TransportStream instance.');
} // Remark (indexzero): we set `handleExceptions` here because it's the
// predicate checked in ExceptionHandler.prototype.__getExceptionHandlers
_this.handleExceptions = true;
_this.transport = transport;
return _this;
}
/**
* Writes the info object to our transport instance if (and only if) the
* `exception` property is set on the info.
* @param {mixed} info - TODO: add param description.
* @param {mixed} enc - TODO: add param description.
* @param {mixed} callback - TODO: add param description.
* @returns {mixed} - TODO: add return description.
* @private
*/
_createClass(ExceptionStream, [{
key: "_write",
value: function _write(info, enc, callback) {
if (info.exception) {
return this.transport.log(info, callback);
}
callback();
return true;
}
}]);
return ExceptionStream;
}(Writable);

742
node_modules/winston/dist/winston/logger.js generated vendored Normal file
View File

@ -0,0 +1,742 @@
/**
* logger.js: TODO: add file header description.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var _require = require('readable-stream'),
Stream = _require.Stream,
Transform = _require.Transform;
var asyncForEach = require('async/forEach');
var _require2 = require('triple-beam'),
LEVEL = _require2.LEVEL,
SPLAT = _require2.SPLAT;
var isStream = require('is-stream');
var ExceptionHandler = require('./exception-handler');
var RejectionHandler = require('./rejection-handler');
var LegacyTransportStream = require('winston-transport/legacy');
var Profiler = require('./profiler');
var _require3 = require('./common'),
warn = _require3.warn;
var config = require('./config');
/**
* Captures the number of format (i.e. %s strings) in a given string.
* Based on `util.format`, see Node.js source:
* https://github.com/nodejs/node/blob/b1c8f15c5f169e021f7c46eb7b219de95fe97603/lib/util.js#L201-L230
* @type {RegExp}
*/
var formatRegExp = /%[scdjifoO%]/g;
/**
* TODO: add class description.
* @type {Logger}
* @extends {Transform}
*/
var Logger =
/*#__PURE__*/
function (_Transform) {
_inherits(Logger, _Transform);
/**
* Constructor function for the Logger object responsible for persisting log
* messages and metadata to one or more transports.
* @param {!Object} options - foo
*/
function Logger(options) {
var _this;
_classCallCheck(this, Logger);
_this = _possibleConstructorReturn(this, _getPrototypeOf(Logger).call(this, {
objectMode: true
}));
_this.configure(options);
return _this;
}
_createClass(Logger, [{
key: "child",
value: function child(defaultRequestMetadata) {
var logger = this;
return Object.create(logger, {
write: {
value: function value(info) {
var infoClone = Object.assign({}, defaultRequestMetadata, info); // Object.assign doesn't copy inherited Error
// properties so we have to do that explicitly
//
// Remark (indexzero): we should remove this
// since the errors format will handle this case.
//
if (info instanceof Error) {
infoClone.stack = info.stack;
infoClone.message = info.message;
}
logger.write(infoClone);
}
}
});
}
/**
* This will wholesale reconfigure this instance by:
* 1. Resetting all transports. Older transports will be removed implicitly.
* 2. Set all other options including levels, colors, rewriters, filters,
* exceptionHandlers, etc.
* @param {!Object} options - TODO: add param description.
* @returns {undefined}
*/
}, {
key: "configure",
value: function configure() {
var _this2 = this;
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
silent = _ref.silent,
format = _ref.format,
defaultMeta = _ref.defaultMeta,
levels = _ref.levels,
_ref$level = _ref.level,
level = _ref$level === void 0 ? 'info' : _ref$level,
_ref$exitOnError = _ref.exitOnError,
exitOnError = _ref$exitOnError === void 0 ? true : _ref$exitOnError,
transports = _ref.transports,
colors = _ref.colors,
emitErrs = _ref.emitErrs,
formatters = _ref.formatters,
padLevels = _ref.padLevels,
rewriters = _ref.rewriters,
stripColors = _ref.stripColors,
exceptionHandlers = _ref.exceptionHandlers,
rejectionHandlers = _ref.rejectionHandlers;
// Reset transports if we already have them
if (this.transports.length) {
this.clear();
}
this.silent = silent;
this.format = format || this.format || require('logform/json')();
this.defaultMeta = defaultMeta || null; // Hoist other options onto this instance.
this.levels = levels || this.levels || config.npm.levels;
this.level = level;
this.exceptions = new ExceptionHandler(this);
this.rejections = new RejectionHandler(this);
this.profilers = {};
this.exitOnError = exitOnError; // Add all transports we have been provided.
if (transports) {
transports = Array.isArray(transports) ? transports : [transports];
transports.forEach(function (transport) {
return _this2.add(transport);
});
}
if (colors || emitErrs || formatters || padLevels || rewriters || stripColors) {
throw new Error(['{ colors, emitErrs, formatters, padLevels, rewriters, stripColors } were removed in winston@3.0.0.', 'Use a custom winston.format(function) instead.', 'See: https://github.com/winstonjs/winston/tree/master/UPGRADE-3.0.md'].join('\n'));
}
if (exceptionHandlers) {
this.exceptions.handle(exceptionHandlers);
}
if (rejectionHandlers) {
this.rejections.handle(rejectionHandlers);
}
}
}, {
key: "isLevelEnabled",
value: function isLevelEnabled(level) {
var _this3 = this;
var givenLevelValue = getLevelValue(this.levels, level);
if (givenLevelValue === null) {
return false;
}
var configuredLevelValue = getLevelValue(this.levels, this.level);
if (configuredLevelValue === null) {
return false;
}
if (!this.transports || this.transports.length === 0) {
return configuredLevelValue >= givenLevelValue;
}
var index = this.transports.findIndex(function (transport) {
var transportLevelValue = getLevelValue(_this3.levels, transport.level);
if (transportLevelValue === null) {
transportLevelValue = configuredLevelValue;
}
return transportLevelValue >= givenLevelValue;
});
return index !== -1;
}
/* eslint-disable valid-jsdoc */
/**
* Ensure backwards compatibility with a `log` method
* @param {mixed} level - Level the log message is written at.
* @param {mixed} msg - TODO: add param description.
* @param {mixed} meta - TODO: add param description.
* @returns {Logger} - TODO: add return description.
*
* @example
* // Supports the existing API:
* logger.log('info', 'Hello world', { custom: true });
* logger.log('info', new Error('Yo, it\'s on fire'));
*
* // Requires winston.format.splat()
* logger.log('info', '%s %d%%', 'A string', 50, { thisIsMeta: true });
*
* // And the new API with a single JSON literal:
* logger.log({ level: 'info', message: 'Hello world', custom: true });
* logger.log({ level: 'info', message: new Error('Yo, it\'s on fire') });
*
* // Also requires winston.format.splat()
* logger.log({
* level: 'info',
* message: '%s %d%%',
* [SPLAT]: ['A string', 50],
* meta: { thisIsMeta: true }
* });
*
*/
/* eslint-enable valid-jsdoc */
}, {
key: "log",
value: function log(level, msg) {
var _Object$assign2;
for (var _len = arguments.length, splat = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
splat[_key - 2] = arguments[_key];
}
// eslint-disable-line max-params
// Optimize for the hotpath of logging JSON literals
if (arguments.length === 1) {
// Yo dawg, I heard you like levels ... seriously ...
// In this context the LHS `level` here is actually the `info` so read
// this as: info[LEVEL] = info.level;
level[LEVEL] = level.level;
this._addDefaultMeta(level);
this.write(level);
return this;
} // Slightly less hotpath, but worth optimizing for.
if (arguments.length === 2) {
var _this$write;
if (msg && _typeof(msg) === 'object') {
msg[LEVEL] = msg.level = level;
this._addDefaultMeta(msg);
this.write(msg);
return this;
}
this.write((_this$write = {}, _defineProperty(_this$write, LEVEL, level), _defineProperty(_this$write, "level", level), _defineProperty(_this$write, "message", msg), _this$write));
return this;
}
var meta = splat[0];
if (_typeof(meta) === 'object' && meta !== null) {
// Extract tokens, if none available default to empty array to
// ensure consistancy in expected results
var tokens = msg && msg.match && msg.match(formatRegExp);
if (!tokens) {
var _Object$assign;
var info = Object.assign({}, this.defaultMeta, meta, (_Object$assign = {}, _defineProperty(_Object$assign, LEVEL, level), _defineProperty(_Object$assign, SPLAT, splat), _defineProperty(_Object$assign, "level", level), _defineProperty(_Object$assign, "message", msg), _Object$assign));
if (meta.message) info.message += "".concat(meta.message);
if (meta.stack) info.stack = meta.stack;
this.write(info);
return this;
}
}
this.write(Object.assign({}, this.defaultMeta, (_Object$assign2 = {}, _defineProperty(_Object$assign2, LEVEL, level), _defineProperty(_Object$assign2, SPLAT, splat), _defineProperty(_Object$assign2, "level", level), _defineProperty(_Object$assign2, "message", msg), _Object$assign2)));
return this;
}
/**
* Pushes data so that it can be picked up by all of our pipe targets.
* @param {mixed} info - TODO: add param description.
* @param {mixed} enc - TODO: add param description.
* @param {mixed} callback - Continues stream processing.
* @returns {undefined}
* @private
*/
}, {
key: "_transform",
value: function _transform(info, enc, callback) {
if (this.silent) {
return callback();
} // [LEVEL] is only soft guaranteed to be set here since we are a proper
// stream. It is likely that `info` came in through `.log(info)` or
// `.info(info)`. If it is not defined, however, define it.
// This LEVEL symbol is provided by `triple-beam` and also used in:
// - logform
// - winston-transport
// - abstract-winston-transport
if (!info[LEVEL]) {
info[LEVEL] = info.level;
} // Remark: really not sure what to do here, but this has been reported as
// very confusing by pre winston@2.0.0 users as quite confusing when using
// custom levels.
if (!this.levels[info[LEVEL]] && this.levels[info[LEVEL]] !== 0) {
// eslint-disable-next-line no-console
console.error('[winston] Unknown logger level: %s', info[LEVEL]);
} // Remark: not sure if we should simply error here.
if (!this._readableState.pipes) {
// eslint-disable-next-line no-console
console.error('[winston] Attempt to write logs with no transports %j', info);
} // Here we write to the `format` pipe-chain, which on `readable` above will
// push the formatted `info` Object onto the buffer for this instance. We trap
// (and re-throw) any errors generated by the user-provided format, but also
// guarantee that the streams callback is invoked so that we can continue flowing.
try {
this.push(this.format.transform(info, this.format.options));
} catch (ex) {
throw ex;
} finally {
// eslint-disable-next-line callback-return
callback();
}
}
/**
* Delays the 'finish' event until all transport pipe targets have
* also emitted 'finish' or are already finished.
* @param {mixed} callback - Continues stream processing.
*/
}, {
key: "_final",
value: function _final(callback) {
var transports = this.transports.slice();
asyncForEach(transports, function (transport, next) {
if (!transport || transport.finished) return setImmediate(next);
transport.once('finish', next);
transport.end();
}, callback);
}
/**
* Adds the transport to this logger instance by piping to it.
* @param {mixed} transport - TODO: add param description.
* @returns {Logger} - TODO: add return description.
*/
}, {
key: "add",
value: function add(transport) {
// Support backwards compatibility with all existing `winston < 3.x.x`
// transports which meet one of two criteria:
// 1. They inherit from winston.Transport in < 3.x.x which is NOT a stream.
// 2. They expose a log method which has a length greater than 2 (i.e. more then
// just `log(info, callback)`.
var target = !isStream(transport) || transport.log.length > 2 ? new LegacyTransportStream({
transport: transport
}) : transport;
if (!target._writableState || !target._writableState.objectMode) {
throw new Error('Transports must WritableStreams in objectMode. Set { objectMode: true }.');
} // Listen for the `error` event and the `warn` event on the new Transport.
this._onEvent('error', target);
this._onEvent('warn', target);
this.pipe(target);
if (transport.handleExceptions) {
this.exceptions.handle();
}
if (transport.handleRejections) {
this.rejections.handle();
}
return this;
}
/**
* Removes the transport from this logger instance by unpiping from it.
* @param {mixed} transport - TODO: add param description.
* @returns {Logger} - TODO: add return description.
*/
}, {
key: "remove",
value: function remove(transport) {
var target = transport;
if (!isStream(transport) || transport.log.length > 2) {
target = this.transports.filter(function (match) {
return match.transport === transport;
})[0];
}
if (target) {
this.unpipe(target);
}
return this;
}
/**
* Removes all transports from this logger instance.
* @returns {Logger} - TODO: add return description.
*/
}, {
key: "clear",
value: function clear() {
this.unpipe();
return this;
}
/**
* Cleans up resources (streams, event listeners) for all transports
* associated with this instance (if necessary).
* @returns {Logger} - TODO: add return description.
*/
}, {
key: "close",
value: function close() {
this.clear();
this.emit('close');
return this;
}
/**
* Sets the `target` levels specified on this instance.
* @param {Object} Target levels to use on this instance.
*/
}, {
key: "setLevels",
value: function setLevels() {
warn.deprecated('setLevels');
}
/**
* Queries the all transports for this instance with the specified `options`.
* This will aggregate each transport's results into one object containing
* a property per transport.
* @param {Object} options - Query options for this instance.
* @param {function} callback - Continuation to respond to when complete.
*/
}, {
key: "query",
value: function query(options, callback) {
if (typeof options === 'function') {
callback = options;
options = {};
}
options = options || {};
var results = {};
var queryObject = Object.assign({}, options.query || {}); // Helper function to query a single transport
function queryTransport(transport, next) {
if (options.query && typeof transport.formatQuery === 'function') {
options.query = transport.formatQuery(queryObject);
}
transport.query(options, function (err, res) {
if (err) {
return next(err);
}
if (typeof transport.formatResults === 'function') {
res = transport.formatResults(res, options.format);
}
next(null, res);
});
} // Helper function to accumulate the results from `queryTransport` into
// the `results`.
function addResults(transport, next) {
queryTransport(transport, function (err, result) {
// queryTransport could potentially invoke the callback multiple times
// since Transport code can be unpredictable.
if (next) {
result = err || result;
if (result) {
results[transport.name] = result;
} // eslint-disable-next-line callback-return
next();
}
next = null;
});
} // Iterate over the transports in parallel setting the appropriate key in
// the `results`.
asyncForEach(this.transports.filter(function (transport) {
return !!transport.query;
}), addResults, function () {
return callback(null, results);
});
}
/**
* Returns a log stream for all transports. Options object is optional.
* @param{Object} options={} - Stream options for this instance.
* @returns {Stream} - TODO: add return description.
*/
}, {
key: "stream",
value: function stream() {
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var out = new Stream();
var streams = [];
out._streams = streams;
out.destroy = function () {
var i = streams.length;
while (i--) {
streams[i].destroy();
}
}; // Create a list of all transports for this instance.
this.transports.filter(function (transport) {
return !!transport.stream;
}).forEach(function (transport) {
var str = transport.stream(options);
if (!str) {
return;
}
streams.push(str);
str.on('log', function (log) {
log.transport = log.transport || [];
log.transport.push(transport.name);
out.emit('log', log);
});
str.on('error', function (err) {
err.transport = err.transport || [];
err.transport.push(transport.name);
out.emit('error', err);
});
});
return out;
}
/**
* Returns an object corresponding to a specific timing. When done is called
* the timer will finish and log the duration. e.g.:
* @returns {Profile} - TODO: add return description.
* @example
* const timer = winston.startTimer()
* setTimeout(() => {
* timer.done({
* message: 'Logging message'
* });
* }, 1000);
*/
}, {
key: "startTimer",
value: function startTimer() {
return new Profiler(this);
}
/**
* Tracks the time inbetween subsequent calls to this method with the same
* `id` parameter. The second call to this method will log the difference in
* milliseconds along with the message.
* @param {string} id Unique id of the profiler
* @returns {Logger} - TODO: add return description.
*/
}, {
key: "profile",
value: function profile(id) {
var time = Date.now();
if (this.profilers[id]) {
var timeEnd = this.profilers[id];
delete this.profilers[id]; // Attempt to be kind to users if they are still using older APIs.
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
args[_key2 - 1] = arguments[_key2];
}
if (typeof args[args.length - 2] === 'function') {
// eslint-disable-next-line no-console
console.warn('Callback function no longer supported as of winston@3.0.0');
args.pop();
} // Set the duration property of the metadata
var info = _typeof(args[args.length - 1]) === 'object' ? args.pop() : {};
info.level = info.level || 'info';
info.durationMs = time - timeEnd;
info.message = info.message || id;
return this.write(info);
}
this.profilers[id] = time;
return this;
}
/**
* Backwards compatibility to `exceptions.handle` in winston < 3.0.0.
* @returns {undefined}
* @deprecated
*/
}, {
key: "handleExceptions",
value: function handleExceptions() {
var _this$exceptions;
// eslint-disable-next-line no-console
console.warn('Deprecated: .handleExceptions() will be removed in winston@4. Use .exceptions.handle()');
(_this$exceptions = this.exceptions).handle.apply(_this$exceptions, arguments);
}
/**
* Backwards compatibility to `exceptions.handle` in winston < 3.0.0.
* @returns {undefined}
* @deprecated
*/
}, {
key: "unhandleExceptions",
value: function unhandleExceptions() {
var _this$exceptions2;
// eslint-disable-next-line no-console
console.warn('Deprecated: .unhandleExceptions() will be removed in winston@4. Use .exceptions.unhandle()');
(_this$exceptions2 = this.exceptions).unhandle.apply(_this$exceptions2, arguments);
}
/**
* Throw a more meaningful deprecation notice
* @throws {Error} - TODO: add throws description.
*/
}, {
key: "cli",
value: function cli() {
throw new Error(['Logger.cli() was removed in winston@3.0.0', 'Use a custom winston.formats.cli() instead.', 'See: https://github.com/winstonjs/winston/tree/master/UPGRADE-3.0.md'].join('\n'));
}
/**
* Bubbles the `event` that occured on the specified `transport` up
* from this instance.
* @param {string} event - The event that occured
* @param {Object} transport - Transport on which the event occured
* @private
*/
}, {
key: "_onEvent",
value: function _onEvent(event, transport) {
function transportEvent(err) {
this.emit(event, err, transport);
}
if (!transport['__winston' + event]) {
transport['__winston' + event] = transportEvent.bind(this);
transport.on(event, transport['__winston' + event]);
}
}
}, {
key: "_addDefaultMeta",
value: function _addDefaultMeta(msg) {
if (this.defaultMeta) {
Object.assign(msg, this.defaultMeta);
}
}
}]);
return Logger;
}(Transform);
function getLevelValue(levels, level) {
var value = levels[level];
if (!value && value !== 0) {
return null;
}
return value;
}
/**
* Represents the current readableState pipe targets for this Logger instance.
* @type {Array|Object}
*/
Object.defineProperty(Logger.prototype, 'transports', {
configurable: false,
enumerable: true,
get: function get() {
var pipes = this._readableState.pipes;
return !Array.isArray(pipes) ? [pipes].filter(Boolean) : pipes;
}
});
module.exports = Logger;

71
node_modules/winston/dist/winston/profiler.js generated vendored Normal file
View File

@ -0,0 +1,71 @@
/**
* profiler.js: TODO: add file header description.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
/**
* TODO: add class description.
* @type {Profiler}
* @private
*/
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
module.exports =
/*#__PURE__*/
function () {
/**
* Constructor function for the Profiler instance used by
* `Logger.prototype.startTimer`. When done is called the timer will finish
* and log the duration.
* @param {!Logger} logger - TODO: add param description.
* @private
*/
function Profiler(logger) {
_classCallCheck(this, Profiler);
if (!logger) {
throw new Error('Logger is required for profiling.');
}
this.logger = logger;
this.start = Date.now();
}
/**
* Ends the current timer (i.e. Profiler) instance and logs the `msg` along
* with the duration since creation.
* @returns {mixed} - TODO: add return description.
* @private
*/
_createClass(Profiler, [{
key: "done",
value: function done() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
if (typeof args[args.length - 1] === 'function') {
// eslint-disable-next-line no-console
console.warn('Callback function no longer supported as of winston@3.0.0');
args.pop();
}
var info = _typeof(args[args.length - 1]) === 'object' ? args.pop() : {};
info.level = info.level || 'info';
info.durationMs = Date.now() - this.start;
return this.logger.write(info);
}
}]);
return Profiler;
}();

290
node_modules/winston/dist/winston/rejection-handler.js generated vendored Normal file
View File

@ -0,0 +1,290 @@
/**
* exception-handler.js: Object for handling uncaughtException events.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
var os = require('os');
var asyncForEach = require('async/forEach');
var debug = require('diagnostics')('winston:rejection');
var once = require('one-time');
var stackTrace = require('stack-trace');
var ExceptionStream = require('./exception-stream');
/**
* Object for handling unhandledRejection events.
* @type {RejectionHandler}
*/
module.exports =
/*#__PURE__*/
function () {
/**
* TODO: add contructor description
* @param {!Logger} logger - TODO: add param description
*/
function RejectionHandler(logger) {
_classCallCheck(this, RejectionHandler);
if (!logger) {
throw new Error('Logger is required to handle rejections');
}
this.logger = logger;
this.handlers = new Map();
}
/**
* Handles `unhandledRejection` events for the current process by adding any
* handlers passed in.
* @returns {undefined}
*/
_createClass(RejectionHandler, [{
key: "handle",
value: function handle() {
var _this = this;
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
args.forEach(function (arg) {
if (Array.isArray(arg)) {
return arg.forEach(function (handler) {
return _this._addHandler(handler);
});
}
_this._addHandler(arg);
});
if (!this.catcher) {
this.catcher = this._unhandledRejection.bind(this);
process.on('unhandledRejection', this.catcher);
}
}
/**
* Removes any handlers to `unhandledRejection` events for the current
* process. This does not modify the state of the `this.handlers` set.
* @returns {undefined}
*/
}, {
key: "unhandle",
value: function unhandle() {
var _this2 = this;
if (this.catcher) {
process.removeListener('unhandledRejection', this.catcher);
this.catcher = false;
Array.from(this.handlers.values()).forEach(function (wrapper) {
return _this2.logger.unpipe(wrapper);
});
}
}
/**
* TODO: add method description
* @param {Error} err - Error to get information about.
* @returns {mixed} - TODO: add return description.
*/
}, {
key: "getAllInfo",
value: function getAllInfo(err) {
var message = err.message;
if (!message && typeof err === 'string') {
message = err;
}
return {
error: err,
// TODO (indexzero): how do we configure this?
level: 'error',
message: ["unhandledRejection: ".concat(message || '(no error message)'), err.stack || ' No stack trace'].join('\n'),
stack: err.stack,
exception: true,
date: new Date().toString(),
process: this.getProcessInfo(),
os: this.getOsInfo(),
trace: this.getTrace(err)
};
}
/**
* Gets all relevant process information for the currently running process.
* @returns {mixed} - TODO: add return description.
*/
}, {
key: "getProcessInfo",
value: function getProcessInfo() {
return {
pid: process.pid,
uid: process.getuid ? process.getuid() : null,
gid: process.getgid ? process.getgid() : null,
cwd: process.cwd(),
execPath: process.execPath,
version: process.version,
argv: process.argv,
memoryUsage: process.memoryUsage()
};
}
/**
* Gets all relevant OS information for the currently running process.
* @returns {mixed} - TODO: add return description.
*/
}, {
key: "getOsInfo",
value: function getOsInfo() {
return {
loadavg: os.loadavg(),
uptime: os.uptime()
};
}
/**
* Gets a stack trace for the specified error.
* @param {mixed} err - TODO: add param description.
* @returns {mixed} - TODO: add return description.
*/
}, {
key: "getTrace",
value: function getTrace(err) {
var trace = err ? stackTrace.parse(err) : stackTrace.get();
return trace.map(function (site) {
return {
column: site.getColumnNumber(),
file: site.getFileName(),
function: site.getFunctionName(),
line: site.getLineNumber(),
method: site.getMethodName(),
native: site.isNative()
};
});
}
/**
* Helper method to add a transport as an exception handler.
* @param {Transport} handler - The transport to add as an exception handler.
* @returns {void}
*/
}, {
key: "_addHandler",
value: function _addHandler(handler) {
if (!this.handlers.has(handler)) {
handler.handleExceptions = true;
var wrapper = new ExceptionStream(handler);
this.handlers.set(handler, wrapper);
this.logger.pipe(wrapper);
}
}
/**
* Logs all relevant information around the `err` and exits the current
* process.
* @param {Error} err - Error to handle
* @returns {mixed} - TODO: add return description.
* @private
*/
}, {
key: "_unhandledRejection",
value: function _unhandledRejection(err) {
var info = this.getAllInfo(err);
var handlers = this._getRejectionHandlers(); // Calculate if we should exit on this error
var doExit = typeof this.logger.exitOnError === 'function' ? this.logger.exitOnError(err) : this.logger.exitOnError;
var timeout;
if (!handlers.length && doExit) {
// eslint-disable-next-line no-console
console.warn('winston: exitOnError cannot be true with no rejection handlers.'); // eslint-disable-next-line no-console
console.warn('winston: not exiting process.');
doExit = false;
}
function gracefulExit() {
debug('doExit', doExit);
debug('process._exiting', process._exiting);
if (doExit && !process._exiting) {
// Remark: Currently ignoring any rejections from transports when
// catching unhandled rejections.
if (timeout) {
clearTimeout(timeout);
} // eslint-disable-next-line no-process-exit
process.exit(1);
}
}
if (!handlers || handlers.length === 0) {
return process.nextTick(gracefulExit);
} // Log to all transports attempting to listen for when they are completed.
asyncForEach(handlers, function (handler, next) {
var done = once(next);
var transport = handler.transport || handler; // Debug wrapping so that we can inspect what's going on under the covers.
function onDone(event) {
return function () {
debug(event);
done();
};
}
transport._ending = true;
transport.once('finish', onDone('finished'));
transport.once('error', onDone('error'));
}, function () {
return doExit && gracefulExit();
});
this.logger.log(info); // If exitOnError is true, then only allow the logging of exceptions to
// take up to `3000ms`.
if (doExit) {
timeout = setTimeout(gracefulExit, 3000);
}
}
/**
* Returns the list of transports and exceptionHandlers for this instance.
* @returns {Array} - List of transports and exceptionHandlers for this
* instance.
* @private
*/
}, {
key: "_getRejectionHandlers",
value: function _getRejectionHandlers() {
// Remark (indexzero): since `logger.transports` returns all of the pipes
// from the _readableState of the stream we actually get the join of the
// explicit handlers and the implicit transports with
// `handleRejections: true`
return this.logger.transports.filter(function (wrap) {
var transport = wrap.transport || wrap;
return transport.handleRejections;
});
}
}]);
return RejectionHandler;
}();

135
node_modules/winston/dist/winston/tail-file.js generated vendored Normal file
View File

@ -0,0 +1,135 @@
/**
* tail-file.js: TODO: add file header description.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
var fs = require('fs');
var _require = require('string_decoder'),
StringDecoder = _require.StringDecoder;
var _require2 = require('readable-stream'),
Stream = _require2.Stream;
/**
* Simple no-op function.
* @returns {undefined}
*/
function noop() {}
/**
* TODO: add function description.
* @param {Object} options - Options for tail.
* @param {function} iter - Iterator function to execute on every line.
* `tail -f` a file. Options must include file.
* @returns {mixed} - TODO: add return description.
*/
module.exports = function (options, iter) {
var buffer = Buffer.alloc(64 * 1024);
var decode = new StringDecoder('utf8');
var stream = new Stream();
var buff = '';
var pos = 0;
var row = 0;
if (options.start === -1) {
delete options.start;
}
stream.readable = true;
stream.destroy = function () {
stream.destroyed = true;
stream.emit('end');
stream.emit('close');
};
fs.open(options.file, 'a+', '0644', function (err, fd) {
if (err) {
if (!iter) {
stream.emit('error', err);
} else {
iter(err);
}
stream.destroy();
return;
}
(function read() {
if (stream.destroyed) {
fs.close(fd, noop);
return;
}
return fs.read(fd, buffer, 0, buffer.length, pos, function (err, bytes) {
if (err) {
if (!iter) {
stream.emit('error', err);
} else {
iter(err);
}
stream.destroy();
return;
}
if (!bytes) {
if (buff) {
// eslint-disable-next-line eqeqeq
if (options.start == null || row > options.start) {
if (!iter) {
stream.emit('line', buff);
} else {
iter(null, buff);
}
}
row++;
buff = '';
}
return setTimeout(read, 1000);
}
var data = decode.write(buffer.slice(0, bytes));
if (!iter) {
stream.emit('data', data);
}
data = (buff + data).split(/\n+/);
var l = data.length - 1;
var i = 0;
for (; i < l; i++) {
// eslint-disable-next-line eqeqeq
if (options.start == null || row > options.start) {
if (!iter) {
stream.emit('line', data[i]);
} else {
iter(null, data[i]);
}
}
row++;
}
buff = data[l];
pos += bytes;
return read();
});
})();
});
if (!iter) {
return stream;
}
return stream.destroy;
};

162
node_modules/winston/dist/winston/transports/console.js generated vendored Normal file
View File

@ -0,0 +1,162 @@
/* eslint-disable no-console */
/*
* console.js: Transport for outputting to the console.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var os = require('os');
var _require = require('triple-beam'),
LEVEL = _require.LEVEL,
MESSAGE = _require.MESSAGE;
var TransportStream = require('winston-transport');
/**
* Transport for outputting to the console.
* @type {Console}
* @extends {TransportStream}
*/
module.exports =
/*#__PURE__*/
function (_TransportStream) {
_inherits(Console, _TransportStream);
/**
* Constructor function for the Console transport object responsible for
* persisting log messages and metadata to a terminal or TTY.
* @param {!Object} [options={}] - Options for this instance.
*/
function Console() {
var _this;
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
_classCallCheck(this, Console);
_this = _possibleConstructorReturn(this, _getPrototypeOf(Console).call(this, options)); // Expose the name of this Transport on the prototype
_this.name = options.name || 'console';
_this.stderrLevels = _this._stringArrayToSet(options.stderrLevels);
_this.consoleWarnLevels = _this._stringArrayToSet(options.consoleWarnLevels);
_this.eol = options.eol || os.EOL;
_this.setMaxListeners(30);
return _this;
}
/**
* Core logging method exposed to Winston.
* @param {Object} info - TODO: add param description.
* @param {Function} callback - TODO: add param description.
* @returns {undefined}
*/
_createClass(Console, [{
key: "log",
value: function log(info, callback) {
var _this2 = this;
setImmediate(function () {
return _this2.emit('logged', info);
}); // Remark: what if there is no raw...?
if (this.stderrLevels[info[LEVEL]]) {
if (console._stderr) {
// Node.js maps `process.stderr` to `console._stderr`.
console._stderr.write("".concat(info[MESSAGE]).concat(this.eol));
} else {
// console.error adds a newline
console.error(info[MESSAGE]);
}
if (callback) {
callback(); // eslint-disable-line callback-return
}
return;
} else if (this.consoleWarnLevels[info[LEVEL]]) {
if (console._stderr) {
// Node.js maps `process.stderr` to `console._stderr`.
// in Node.js console.warn is an alias for console.error
console._stderr.write("".concat(info[MESSAGE]).concat(this.eol));
} else {
// console.warn adds a newline
console.warn(info[MESSAGE]);
}
if (callback) {
callback(); // eslint-disable-line callback-return
}
return;
}
if (console._stdout) {
// Node.js maps `process.stdout` to `console._stdout`.
console._stdout.write("".concat(info[MESSAGE]).concat(this.eol));
} else {
// console.log adds a newline.
console.log(info[MESSAGE]);
}
if (callback) {
callback(); // eslint-disable-line callback-return
}
}
/**
* Returns a Set-like object with strArray's elements as keys (each with the
* value true).
* @param {Array} strArray - Array of Set-elements as strings.
* @param {?string} [errMsg] - Custom error message thrown on invalid input.
* @returns {Object} - TODO: add return description.
* @private
*/
}, {
key: "_stringArrayToSet",
value: function _stringArrayToSet(strArray, errMsg) {
if (!strArray) return {};
errMsg = errMsg || 'Cannot make set from type other than Array of string elements';
if (!Array.isArray(strArray)) {
throw new Error(errMsg);
}
return strArray.reduce(function (set, el) {
if (typeof el !== 'string') {
throw new Error(errMsg);
}
set[el] = true;
return set;
}, {});
}
}]);
return Console;
}(TransportStream);

815
node_modules/winston/dist/winston/transports/file.js generated vendored Normal file
View File

@ -0,0 +1,815 @@
/* eslint-disable complexity,max-statements */
/**
* file.js: Transport for outputting to a local log file.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
var fs = require('fs');
var path = require('path');
var asyncSeries = require('async/series');
var zlib = require('zlib');
var _require = require('triple-beam'),
MESSAGE = _require.MESSAGE;
var _require2 = require('readable-stream'),
Stream = _require2.Stream,
PassThrough = _require2.PassThrough;
var TransportStream = require('winston-transport');
var debug = require('diagnostics')('winston:file');
var os = require('os');
var tailFile = require('../tail-file');
/**
* Transport for outputting to a local log file.
* @type {File}
* @extends {TransportStream}
*/
module.exports =
/*#__PURE__*/
function (_TransportStream) {
_inherits(File, _TransportStream);
/**
* Constructor function for the File transport object responsible for
* persisting log messages and metadata to one or more files.
* @param {Object} options - Options for this instance.
*/
function File() {
var _this;
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
_classCallCheck(this, File);
_this = _possibleConstructorReturn(this, _getPrototypeOf(File).call(this, options)); // Expose the name of this Transport on the prototype.
_this.name = options.name || 'file'; // Helper function which throws an `Error` in the event that any of the
// rest of the arguments is present in `options`.
function throwIf(target) {
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
args[_key - 1] = arguments[_key];
}
args.slice(1).forEach(function (name) {
if (options[name]) {
throw new Error("Cannot set ".concat(name, " and ").concat(target, " together"));
}
});
} // Setup the base stream that always gets piped to to handle buffering.
_this._stream = new PassThrough();
_this._stream.setMaxListeners(30); // Bind this context for listener methods.
_this._onError = _this._onError.bind(_assertThisInitialized(_assertThisInitialized(_this)));
if (options.filename || options.dirname) {
throwIf('filename or dirname', 'stream');
_this._basename = _this.filename = options.filename ? path.basename(options.filename) : 'winston.log';
_this.dirname = options.dirname || path.dirname(options.filename);
_this.options = options.options || {
flags: 'a'
};
} else if (options.stream) {
// eslint-disable-next-line no-console
console.warn('options.stream will be removed in winston@4. Use winston.transports.Stream');
throwIf('stream', 'filename', 'maxsize');
_this._dest = _this._stream.pipe(_this._setupStream(options.stream));
_this.dirname = path.dirname(_this._dest.path); // We need to listen for drain events when write() returns false. This
// can make node mad at times.
} else {
throw new Error('Cannot log to file without filename or stream.');
}
_this.maxsize = options.maxsize || null;
_this.rotationFormat = options.rotationFormat || false;
_this.zippedArchive = options.zippedArchive || false;
_this.maxFiles = options.maxFiles || null;
_this.eol = options.eol || os.EOL;
_this.tailable = options.tailable || false; // Internal state variables representing the number of files this instance
// has created and the current size (in bytes) of the current logfile.
_this._size = 0;
_this._pendingSize = 0;
_this._created = 0;
_this._drain = false;
_this._opening = false;
_this._ending = false;
if (_this.dirname) _this._createLogDirIfNotExist(_this.dirname);
_this.open();
return _this;
}
_createClass(File, [{
key: "finishIfEnding",
value: function finishIfEnding() {
var _this2 = this;
if (this._ending) {
if (this._opening) {
this.once('open', function () {
_this2._stream.once('finish', function () {
return _this2.emit('finish');
});
setImmediate(function () {
return _this2._stream.end();
});
});
} else {
this._stream.once('finish', function () {
return _this2.emit('finish');
});
setImmediate(function () {
return _this2._stream.end();
});
}
}
}
/**
* Core logging method exposed to Winston. Metadata is optional.
* @param {Object} info - TODO: add param description.
* @param {Function} callback - TODO: add param description.
* @returns {undefined}
*/
}, {
key: "log",
value: function log(info) {
var _this3 = this;
var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {};
// Remark: (jcrugzz) What is necessary about this callback(null, true) now
// when thinking about 3.x? Should silent be handled in the base
// TransportStream _write method?
if (this.silent) {
callback();
return true;
} // Output stream buffer is full and has asked us to wait for the drain event
if (this._drain) {
this._stream.once('drain', function () {
_this3._drain = false;
_this3.log(info, callback);
});
return;
}
if (this._rotate) {
this._stream.once('rotate', function () {
_this3._rotate = false;
_this3.log(info, callback);
});
return;
} // Grab the raw string and append the expected EOL.
var output = "".concat(info[MESSAGE]).concat(this.eol);
var bytes = Buffer.byteLength(output); // After we have written to the PassThrough check to see if we need
// to rotate to the next file.
//
// Remark: This gets called too early and does not depict when data
// has been actually flushed to disk.
function logged() {
var _this4 = this;
this._size += bytes;
this._pendingSize -= bytes;
debug('logged %s %s', this._size, output);
this.emit('logged', info); // Do not attempt to rotate files while opening
if (this._opening) {
return;
} // Check to see if we need to end the stream and create a new one.
if (!this._needsNewFile()) {
return;
} // End the current stream, ensure it flushes and create a new one.
// This could potentially be optimized to not run a stat call but its
// the safest way since we are supporting `maxFiles`.
this._rotate = true;
this._endStream(function () {
return _this4._rotateFile();
});
} // Keep track of the pending bytes being written while files are opening
// in order to properly rotate the PassThrough this._stream when the file
// eventually does open.
this._pendingSize += bytes;
if (this._opening && !this.rotatedWhileOpening && this._needsNewFile(this._size + this._pendingSize)) {
this.rotatedWhileOpening = true;
}
var written = this._stream.write(output, logged.bind(this));
if (!written) {
this._drain = true;
this._stream.once('drain', function () {
_this3._drain = false;
callback();
});
} else {
callback(); // eslint-disable-line callback-return
}
debug('written', written, this._drain);
this.finishIfEnding();
return written;
}
/**
* Query the transport. Options object is optional.
* @param {Object} options - Loggly-like query options for this instance.
* @param {function} callback - Continuation to respond to when complete.
* TODO: Refactor me.
*/
}, {
key: "query",
value: function query(options, callback) {
if (typeof options === 'function') {
callback = options;
options = {};
}
options = normalizeQuery(options);
var file = path.join(this.dirname, this.filename);
var buff = '';
var results = [];
var row = 0;
var stream = fs.createReadStream(file, {
encoding: 'utf8'
});
stream.on('error', function (err) {
if (stream.readable) {
stream.destroy();
}
if (!callback) {
return;
}
return err.code !== 'ENOENT' ? callback(err) : callback(null, results);
});
stream.on('data', function (data) {
data = (buff + data).split(/\n+/);
var l = data.length - 1;
var i = 0;
for (; i < l; i++) {
if (!options.start || row >= options.start) {
add(data[i]);
}
row++;
}
buff = data[l];
});
stream.on('close', function () {
if (buff) {
add(buff, true);
}
if (options.order === 'desc') {
results = results.reverse();
} // eslint-disable-next-line callback-return
if (callback) callback(null, results);
});
function add(buff, attempt) {
try {
var log = JSON.parse(buff);
if (check(log)) {
push(log);
}
} catch (e) {
if (!attempt) {
stream.emit('error', e);
}
}
}
function push(log) {
if (options.rows && results.length >= options.rows && options.order !== 'desc') {
if (stream.readable) {
stream.destroy();
}
return;
}
if (options.fields) {
log = options.fields.reduce(function (obj, key) {
obj[key] = log[key];
return obj;
}, {});
}
if (options.order === 'desc') {
if (results.length >= options.rows) {
results.shift();
}
}
results.push(log);
}
function check(log) {
if (!log) {
return;
}
if (_typeof(log) !== 'object') {
return;
}
var time = new Date(log.timestamp);
if (options.from && time < options.from || options.until && time > options.until || options.level && options.level !== log.level) {
return;
}
return true;
}
function normalizeQuery(options) {
options = options || {}; // limit
options.rows = options.rows || options.limit || 10; // starting row offset
options.start = options.start || 0; // now
options.until = options.until || new Date();
if (_typeof(options.until) !== 'object') {
options.until = new Date(options.until);
} // now - 24
options.from = options.from || options.until - 24 * 60 * 60 * 1000;
if (_typeof(options.from) !== 'object') {
options.from = new Date(options.from);
} // 'asc' or 'desc'
options.order = options.order || 'desc'; // which fields to select
options.fields = options.fields;
return options;
}
}
/**
* Returns a log stream for this transport. Options object is optional.
* @param {Object} options - Stream options for this instance.
* @returns {Stream} - TODO: add return description.
* TODO: Refactor me.
*/
}, {
key: "stream",
value: function stream() {
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var file = path.join(this.dirname, this.filename);
var stream = new Stream();
var tail = {
file: file,
start: options.start
};
stream.destroy = tailFile(tail, function (err, line) {
if (err) {
return stream.emit('error', err);
}
try {
stream.emit('data', line);
line = JSON.parse(line);
stream.emit('log', line);
} catch (e) {
stream.emit('error', e);
}
});
return stream;
}
/**
* Checks to see the filesize of.
* @returns {undefined}
*/
}, {
key: "open",
value: function open() {
var _this5 = this;
// If we do not have a filename then we were passed a stream and
// don't need to keep track of size.
if (!this.filename) return;
if (this._opening) return;
this._opening = true; // Stat the target file to get the size and create the stream.
this.stat(function (err, size) {
if (err) {
return _this5.emit('error', err);
}
debug('stat done: %s { size: %s }', _this5.filename, size);
_this5._size = size;
_this5._dest = _this5._createStream(_this5._stream);
_this5._opening = false;
_this5.once('open', function () {
if (_this5._stream.eventNames().includes('rotate')) {
_this5._stream.emit('rotate');
} else {
_this5._rotate = false;
}
});
});
}
/**
* Stat the file and assess information in order to create the proper stream.
* @param {function} callback - TODO: add param description.
* @returns {undefined}
*/
}, {
key: "stat",
value: function stat(callback) {
var _this6 = this;
var target = this._getFile();
var fullpath = path.join(this.dirname, target);
fs.stat(fullpath, function (err, stat) {
if (err && err.code === 'ENOENT') {
debug('ENOENT ok', fullpath); // Update internally tracked filename with the new target name.
_this6.filename = target;
return callback(null, 0);
}
if (err) {
debug("err ".concat(err.code, " ").concat(fullpath));
return callback(err);
}
if (!stat || _this6._needsNewFile(stat.size)) {
// If `stats.size` is greater than the `maxsize` for this
// instance then try again.
return _this6._incFile(function () {
return _this6.stat(callback);
});
} // Once we have figured out what the filename is, set it
// and return the size.
_this6.filename = target;
callback(null, stat.size);
});
}
/**
* Closes the stream associated with this instance.
* @param {function} cb - TODO: add param description.
* @returns {undefined}
*/
}, {
key: "close",
value: function close(cb) {
var _this7 = this;
if (!this._stream) {
return;
}
this._stream.end(function () {
if (cb) {
cb(); // eslint-disable-line callback-return
}
_this7.emit('flush');
_this7.emit('closed');
});
}
/**
* TODO: add method description.
* @param {number} size - TODO: add param description.
* @returns {undefined}
*/
}, {
key: "_needsNewFile",
value: function _needsNewFile(size) {
size = size || this._size;
return this.maxsize && size >= this.maxsize;
}
/**
* TODO: add method description.
* @param {Error} err - TODO: add param description.
* @returns {undefined}
*/
}, {
key: "_onError",
value: function _onError(err) {
this.emit('error', err);
}
/**
* TODO: add method description.
* @param {Stream} stream - TODO: add param description.
* @returns {mixed} - TODO: add return description.
*/
}, {
key: "_setupStream",
value: function _setupStream(stream) {
stream.on('error', this._onError);
return stream;
}
/**
* TODO: add method description.
* @param {Stream} stream - TODO: add param description.
* @returns {mixed} - TODO: add return description.
*/
}, {
key: "_cleanupStream",
value: function _cleanupStream(stream) {
stream.removeListener('error', this._onError);
return stream;
}
/**
* TODO: add method description.
*/
}, {
key: "_rotateFile",
value: function _rotateFile() {
var _this8 = this;
this._incFile(function () {
return _this8.open();
});
}
/**
* Unpipe from the stream that has been marked as full and end it so it
* flushes to disk.
*
* @param {function} callback - Callback for when the current file has closed.
* @private
*/
}, {
key: "_endStream",
value: function _endStream() {
var _this9 = this;
var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function () {};
if (this._dest) {
this._stream.unpipe(this._dest);
this._dest.end(function () {
_this9._cleanupStream(_this9._dest);
callback();
});
} else {
callback(); // eslint-disable-line callback-return
}
}
/**
* Returns the WritableStream for the active file on this instance. If we
* should gzip the file then a zlib stream is returned.
*
* @param {ReadableStream} source – PassThrough to pipe to the file when open.
* @returns {WritableStream} Stream that writes to disk for the active file.
*/
}, {
key: "_createStream",
value: function _createStream(source) {
var _this10 = this;
var fullpath = path.join(this.dirname, this.filename);
debug('create stream start', fullpath, this.options);
var dest = fs.createWriteStream(fullpath, this.options) // TODO: What should we do with errors here?
.on('error', function (err) {
return debug(err);
}).on('close', function () {
return debug('close', dest.path, dest.bytesWritten);
}).on('open', function () {
debug('file open ok', fullpath);
_this10.emit('open', fullpath);
source.pipe(dest); // If rotation occured during the open operation then we immediately
// start writing to a new PassThrough, begin opening the next file
// and cleanup the previous source and dest once the source has drained.
if (_this10.rotatedWhileOpening) {
_this10._stream = new PassThrough();
_this10._stream.setMaxListeners(30);
_this10._rotateFile();
_this10.rotatedWhileOpening = false;
_this10._cleanupStream(dest);
source.end();
}
});
debug('create stream ok', fullpath);
if (this.zippedArchive) {
var gzip = zlib.createGzip();
gzip.pipe(dest);
return gzip;
}
return dest;
}
/**
* TODO: add method description.
* @param {function} callback - TODO: add param description.
* @returns {undefined}
*/
}, {
key: "_incFile",
value: function _incFile(callback) {
debug('_incFile', this.filename);
var ext = path.extname(this._basename);
var basename = path.basename(this._basename, ext);
if (!this.tailable) {
this._created += 1;
this._checkMaxFilesIncrementing(ext, basename, callback);
} else {
this._checkMaxFilesTailable(ext, basename, callback);
}
}
/**
* Gets the next filename to use for this instance in the case that log
* filesizes are being capped.
* @returns {string} - TODO: add return description.
* @private
*/
}, {
key: "_getFile",
value: function _getFile() {
var ext = path.extname(this._basename);
var basename = path.basename(this._basename, ext);
var isRotation = this.rotationFormat ? this.rotationFormat() : this._created; // Caveat emptor (indexzero): rotationFormat() was broken by design When
// combined with max files because the set of files to unlink is never
// stored.
var target = !this.tailable && this._created ? "".concat(basename).concat(isRotation).concat(ext) : "".concat(basename).concat(ext);
return this.zippedArchive && !this.tailable ? "".concat(target, ".gz") : target;
}
/**
* Increment the number of files created or checked by this instance.
* @param {mixed} ext - TODO: add param description.
* @param {mixed} basename - TODO: add param description.
* @param {mixed} callback - TODO: add param description.
* @returns {undefined}
* @private
*/
}, {
key: "_checkMaxFilesIncrementing",
value: function _checkMaxFilesIncrementing(ext, basename, callback) {
// Check for maxFiles option and delete file.
if (!this.maxFiles || this._created < this.maxFiles) {
return setImmediate(callback);
}
var oldest = this._created - this.maxFiles;
var isOldest = oldest !== 0 ? oldest : '';
var isZipped = this.zippedArchive ? '.gz' : '';
var filePath = "".concat(basename).concat(isOldest).concat(ext).concat(isZipped);
var target = path.join(this.dirname, filePath);
fs.unlink(target, callback);
}
/**
* Roll files forward based on integer, up to maxFiles. e.g. if base if
* file.log and it becomes oversized, roll to file1.log, and allow file.log
* to be re-used. If file is oversized again, roll file1.log to file2.log,
* roll file.log to file1.log, and so on.
* @param {mixed} ext - TODO: add param description.
* @param {mixed} basename - TODO: add param description.
* @param {mixed} callback - TODO: add param description.
* @returns {undefined}
* @private
*/
}, {
key: "_checkMaxFilesTailable",
value: function _checkMaxFilesTailable(ext, basename, callback) {
var _this12 = this;
var tasks = [];
if (!this.maxFiles) {
return;
} // const isZipped = this.zippedArchive ? '.gz' : '';
var isZipped = this.zippedArchive ? '.gz' : '';
for (var x = this.maxFiles - 1; x > 1; x--) {
tasks.push(function (i, cb) {
var _this11 = this;
var fileName = "".concat(basename).concat(i - 1).concat(ext).concat(isZipped);
var tmppath = path.join(this.dirname, fileName);
fs.exists(tmppath, function (exists) {
if (!exists) {
return cb(null);
}
fileName = "".concat(basename).concat(i).concat(ext).concat(isZipped);
fs.rename(tmppath, path.join(_this11.dirname, fileName), cb);
});
}.bind(this, x));
}
asyncSeries(tasks, function () {
fs.rename(path.join(_this12.dirname, "".concat(basename).concat(ext)), path.join(_this12.dirname, "".concat(basename, "1").concat(ext).concat(isZipped)), callback);
});
}
}, {
key: "_createLogDirIfNotExist",
value: function _createLogDirIfNotExist(dirPath) {
/* eslint-disable no-sync */
if (!fs.existsSync(dirPath)) {
fs.mkdirSync(dirPath, {
recursive: true
});
}
/* eslint-enable no-sync */
}
}]);
return File;
}(TransportStream);

247
node_modules/winston/dist/winston/transports/http.js generated vendored Normal file
View File

@ -0,0 +1,247 @@
/**
* http.js: Transport for outputting to a json-rpcserver.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var http = require('http');
var https = require('https');
var _require = require('readable-stream'),
Stream = _require.Stream;
var TransportStream = require('winston-transport');
/**
* Transport for outputting to a json-rpc server.
* @type {Stream}
* @extends {TransportStream}
*/
module.exports =
/*#__PURE__*/
function (_TransportStream) {
_inherits(Http, _TransportStream);
/**
* Constructor function for the Http transport object responsible for
* persisting log messages and metadata to a terminal or TTY.
* @param {!Object} [options={}] - Options for this instance.
*/
function Http() {
var _this;
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
_classCallCheck(this, Http);
_this = _possibleConstructorReturn(this, _getPrototypeOf(Http).call(this, options));
_this.name = options.name || 'http';
_this.ssl = !!options.ssl;
_this.host = options.host || 'localhost';
_this.port = options.port;
_this.auth = options.auth;
_this.path = options.path || '';
_this.agent = options.agent;
_this.headers = options.headers || {};
_this.headers['content-type'] = 'application/json';
if (!_this.port) {
_this.port = _this.ssl ? 443 : 80;
}
return _this;
}
/**
* Core logging method exposed to Winston.
* @param {Object} info - TODO: add param description.
* @param {function} callback - TODO: add param description.
* @returns {undefined}
*/
_createClass(Http, [{
key: "log",
value: function log(info, callback) {
var _this2 = this;
this._request(info, function (err, res) {
if (res && res.statusCode !== 200) {
err = new Error("Invalid HTTP Status Code: ".concat(res.statusCode));
}
if (err) {
_this2.emit('warn', err);
} else {
_this2.emit('logged', info);
}
}); // Remark: (jcrugzz) Fire and forget here so requests dont cause buffering
// and block more requests from happening?
if (callback) {
setImmediate(callback);
}
}
/**
* Query the transport. Options object is optional.
* @param {Object} options - Loggly-like query options for this instance.
* @param {function} callback - Continuation to respond to when complete.
* @returns {undefined}
*/
}, {
key: "query",
value: function query(options, callback) {
if (typeof options === 'function') {
callback = options;
options = {};
}
options = {
method: 'query',
params: this.normalizeQuery(options)
};
if (options.params.path) {
options.path = options.params.path;
delete options.params.path;
}
if (options.params.auth) {
options.auth = options.params.auth;
delete options.params.auth;
}
this._request(options, function (err, res, body) {
if (res && res.statusCode !== 200) {
err = new Error("Invalid HTTP Status Code: ".concat(res.statusCode));
}
if (err) {
return callback(err);
}
if (typeof body === 'string') {
try {
body = JSON.parse(body);
} catch (e) {
return callback(e);
}
}
callback(null, body);
});
}
/**
* Returns a log stream for this transport. Options object is optional.
* @param {Object} options - Stream options for this instance.
* @returns {Stream} - TODO: add return description
*/
}, {
key: "stream",
value: function stream() {
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var stream = new Stream();
options = {
method: 'stream',
params: options
};
if (options.params.path) {
options.path = options.params.path;
delete options.params.path;
}
if (options.params.auth) {
options.auth = options.params.auth;
delete options.params.auth;
}
var buff = '';
var req = this._request(options);
stream.destroy = function () {
return req.destroy();
};
req.on('data', function (data) {
data = (buff + data).split(/\n+/);
var l = data.length - 1;
var i = 0;
for (; i < l; i++) {
try {
stream.emit('log', JSON.parse(data[i]));
} catch (e) {
stream.emit('error', e);
}
}
buff = data[l];
});
req.on('error', function (err) {
return stream.emit('error', err);
});
return stream;
}
/**
* Make a request to a winstond server or any http server which can
* handle json-rpc.
* @param {function} options - Options to sent the request.
* @param {function} callback - Continuation to respond to when complete.
*/
}, {
key: "_request",
value: function _request(options, callback) {
options = options || {};
var auth = options.auth || this.auth;
var path = options.path || this.path || '';
delete options.auth;
delete options.path; // Prepare options for outgoing HTTP request
var req = (this.ssl ? https : http).request({
method: 'POST',
host: this.host,
port: this.port,
path: "/".concat(path.replace(/^\//, '')),
headers: this.headers,
auth: auth ? "".concat(auth.username, ":").concat(auth.password) : '',
agent: this.agent
});
req.on('error', callback);
req.on('response', function (res) {
return res.on('end', function () {
return callback(null, res);
}).resume();
});
req.end(Buffer.from(JSON.stringify(options), 'utf8'));
}
}]);
return Http;
}(TransportStream);

55
node_modules/winston/dist/winston/transports/index.js generated vendored Normal file
View File

@ -0,0 +1,55 @@
/**
* transports.js: Set of all transports Winston knows about.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
/**
* TODO: add property description.
* @type {Console}
*/
Object.defineProperty(exports, 'Console', {
configurable: true,
enumerable: true,
get: function get() {
return require('./console');
}
});
/**
* TODO: add property description.
* @type {File}
*/
Object.defineProperty(exports, 'File', {
configurable: true,
enumerable: true,
get: function get() {
return require('./file');
}
});
/**
* TODO: add property description.
* @type {Http}
*/
Object.defineProperty(exports, 'Http', {
configurable: true,
enumerable: true,
get: function get() {
return require('./http');
}
});
/**
* TODO: add property description.
* @type {Stream}
*/
Object.defineProperty(exports, 'Stream', {
configurable: true,
enumerable: true,
get: function get() {
return require('./stream');
}
});

113
node_modules/winston/dist/winston/transports/stream.js generated vendored Normal file
View File

@ -0,0 +1,113 @@
/**
* stream.js: Transport for outputting to any arbitrary stream.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var isStream = require('is-stream');
var _require = require('triple-beam'),
MESSAGE = _require.MESSAGE;
var os = require('os');
var TransportStream = require('winston-transport');
/**
* Transport for outputting to any arbitrary stream.
* @type {Stream}
* @extends {TransportStream}
*/
module.exports =
/*#__PURE__*/
function (_TransportStream) {
_inherits(Stream, _TransportStream);
/**
* Constructor function for the Console transport object responsible for
* persisting log messages and metadata to a terminal or TTY.
* @param {!Object} [options={}] - Options for this instance.
*/
function Stream() {
var _this;
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
_classCallCheck(this, Stream);
_this = _possibleConstructorReturn(this, _getPrototypeOf(Stream).call(this, options));
if (!options.stream || !isStream(options.stream)) {
throw new Error('options.stream is required.');
} // We need to listen for drain events when write() returns false. This can
// make node mad at times.
_this._stream = options.stream;
_this._stream.setMaxListeners(Infinity);
_this.isObjectMode = options.stream._writableState.objectMode;
_this.eol = options.eol || os.EOL;
return _this;
}
/**
* Core logging method exposed to Winston.
* @param {Object} info - TODO: add param description.
* @param {Function} callback - TODO: add param description.
* @returns {undefined}
*/
_createClass(Stream, [{
key: "log",
value: function log(info, callback) {
var _this2 = this;
setImmediate(function () {
return _this2.emit('logged', info);
});
if (this.isObjectMode) {
this._stream.write(info);
if (callback) {
callback(); // eslint-disable-line callback-return
}
return;
}
this._stream.write("".concat(info[MESSAGE]).concat(this.eol));
if (callback) {
callback(); // eslint-disable-line callback-return
}
return;
}
}]);
return Stream;
}(TransportStream);

178
node_modules/winston/index.d.ts generated vendored Normal file
View File

@ -0,0 +1,178 @@
// Type definitions for winston 3.0
// Project: https://github.com/winstonjs/winston
/// <reference types="node" />
import * as NodeJSStream from "stream";
import * as logform from 'logform';
import * as Transport from 'winston-transport';
import * as Config from './lib/winston/config/index';
import * as Transports from './lib/winston/transports/index';
declare namespace winston {
// Hoisted namespaces from other modules
export import format = logform.format;
export import config = Config;
export import transports = Transports;
interface ExceptionHandler {
logger: Logger;
handlers: Map<any, any>;
catcher: Function | boolean;
handle(...transports: Transport[]): void;
unhandle(...transports: Transport[]): void;
getAllInfo(err: string | Error): object;
getProcessInfo(): object;
getOsInfo(): object;
getTrace(err: Error): object;
new(logger: Logger): ExceptionHandler;
}
interface QueryOptions {
rows?: number;
limit?: number;
start?: number;
from?: Date;
until?: Date;
order?: "asc" | "desc";
fields: any;
}
interface Profiler {
logger: Logger;
start: Date;
done(info?: any): boolean;
}
type LogCallback = (error?: any, level?: string, message?: string, meta?: any) => void;
interface LogEntry {
level: string;
message: string;
[optionName: string]: any;
}
interface LogMethod {
(level: string, message: string, callback: LogCallback): Logger;
(level: string, message: string, meta: any, callback: LogCallback): Logger;
(level: string, message: string, ...meta: any[]): Logger;
(entry: LogEntry): Logger;
}
interface LeveledLogMethod {
(message: string, callback: LogCallback): Logger;
(message: string, meta: any, callback: LogCallback): Logger;
(message: string, ...meta: any[]): Logger;
(infoObject: object): Logger;
}
interface LoggerOptions {
levels?: Config.AbstractConfigSetLevels;
silent?: boolean;
format?: logform.Format;
level?: string;
exitOnError?: Function | boolean;
defaultMeta?: any;
transports?: Transport[] | Transport;
exceptionHandlers?: any;
}
interface Logger extends NodeJSStream.Transform {
silent: boolean;
format: logform.Format;
levels: Config.AbstractConfigSetLevels;
level: string;
transports: Transport[];
exceptions: ExceptionHandler;
profilers: object;
exitOnError: Function | boolean;
log: LogMethod;
add(transport: Transport): Logger;
remove(transport: Transport): Logger;
clear(): Logger;
close(): Logger;
// for cli and npm levels
error: LeveledLogMethod;
warn: LeveledLogMethod;
help: LeveledLogMethod;
data: LeveledLogMethod;
info: LeveledLogMethod;
debug: LeveledLogMethod;
prompt: LeveledLogMethod;
http: LeveledLogMethod;
verbose: LeveledLogMethod;
input: LeveledLogMethod;
silly: LeveledLogMethod;
// for syslog levels only
emerg: LeveledLogMethod;
alert: LeveledLogMethod;
crit: LeveledLogMethod;
warning: LeveledLogMethod;
notice: LeveledLogMethod;
query(options?: QueryOptions, callback?: (err: Error, results: any) => void): any;
stream(options?: any): NodeJS.ReadableStream;
startTimer(): Profiler;
profile(id: string | number, meta?: LogEntry): Logger;
configure(options: LoggerOptions): void;
child(options: Object): Logger;
new(options?: LoggerOptions): Logger;
}
interface Container {
loggers: Map<string, Logger>;
options: LoggerOptions;
add(id: string, options?: LoggerOptions): Logger;
get(id: string, options?: LoggerOptions): Logger;
has(id: string): boolean;
close(id?: string): void;
new(options?: LoggerOptions): Container;
}
let version: string;
let ExceptionHandler: ExceptionHandler;
let Container: Container;
let loggers: Container;
let addColors: (target: Config.AbstractConfigSetColors) => any;
let createLogger: (options?: LoggerOptions) => Logger;
// Pass-through npm level methods routed to the default logger.
let error: LeveledLogMethod;
let warn: LeveledLogMethod;
let info: LeveledLogMethod;
let http: LeveledLogMethod;
let verbose: LeveledLogMethod;
let debug: LeveledLogMethod;
let silly: LeveledLogMethod;
// Other pass-through methods routed to the default logger.
let log: LogMethod;
let query: (options?: QueryOptions, callback?: (err: Error, results: any) => void) => any;
let stream: (options?: any) => NodeJS.ReadableStream;
let add: (transport: Transport) => Logger;
let remove: (transport: Transport) => Logger;
let clear: () => Logger;
let startTimer: () => Profiler;
let profile: (id: string | number) => Logger;
let configure: (options: LoggerOptions) => void;
let level: string;
let exceptions: ExceptionHandler;
let exitOnError: Function | boolean;
// let default: object;
}
export = winston;

181
node_modules/winston/lib/winston.js generated vendored Normal file
View File

@ -0,0 +1,181 @@
/**
* winston.js: Top-level include defining Winston.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
const logform = require('logform');
const { warn } = require('./winston/common');
/**
* Setup to expose.
* @type {Object}
*/
const winston = exports;
/**
* Expose version. Use `require` method for `webpack` support.
* @type {string}
*/
winston.version = require('../package.json').version;
/**
* Include transports defined by default by winston
* @type {Array}
*/
winston.transports = require('./winston/transports');
/**
* Expose utility methods
* @type {Object}
*/
winston.config = require('./winston/config');
/**
* Hoist format-related functionality from logform.
* @type {Object}
*/
winston.addColors = logform.levels;
/**
* Hoist format-related functionality from logform.
* @type {Object}
*/
winston.format = logform.format;
/**
* Expose core Logging-related prototypes.
* @type {function}
*/
winston.createLogger = require('./winston/create-logger');
/**
* Expose core Logging-related prototypes.
* @type {Object}
*/
winston.ExceptionHandler = require('./winston/exception-handler');
/**
* Expose core Logging-related prototypes.
* @type {Object}
*/
winston.RejectionHandler = require('./winston/rejection-handler');
/**
* Expose core Logging-related prototypes.
* @type {Container}
*/
winston.Container = require('./winston/container');
/**
* Expose core Logging-related prototypes.
* @type {Object}
*/
winston.Transport = require('winston-transport');
/**
* We create and expose a default `Container` to `winston.loggers` so that the
* programmer may manage multiple `winston.Logger` instances without any
* additional overhead.
* @example
* // some-file1.js
* const logger = require('winston').loggers.get('something');
*
* // some-file2.js
* const logger = require('winston').loggers.get('something');
*/
winston.loggers = new winston.Container();
/**
* We create and expose a 'defaultLogger' so that the programmer may do the
* following without the need to create an instance of winston.Logger directly:
* @example
* const winston = require('winston');
* winston.log('info', 'some message');
* winston.error('some error');
*/
const defaultLogger = winston.createLogger();
// Pass through the target methods onto `winston.
Object.keys(winston.config.npm.levels)
.concat([
'log',
'query',
'stream',
'add',
'remove',
'clear',
'profile',
'startTimer',
'handleExceptions',
'unhandleExceptions',
'handleRejections',
'unhandleRejections',
'configure'
])
.forEach(
method => (winston[method] = (...args) => defaultLogger[method](...args))
);
/**
* Define getter / setter for the default logger level which need to be exposed
* by winston.
* @type {string}
*/
Object.defineProperty(winston, 'level', {
get() {
return defaultLogger.level;
},
set(val) {
defaultLogger.level = val;
}
});
/**
* Define getter for `exceptions` which replaces `handleExceptions` and
* `unhandleExceptions`.
* @type {Object}
*/
Object.defineProperty(winston, 'exceptions', {
get() {
return defaultLogger.exceptions;
}
});
/**
* Define getters / setters for appropriate properties of the default logger
* which need to be exposed by winston.
* @type {Logger}
*/
['exitOnError'].forEach(prop => {
Object.defineProperty(winston, prop, {
get() {
return defaultLogger[prop];
},
set(val) {
defaultLogger[prop] = val;
}
});
});
/**
* The default transports and exceptionHandlers for the default winston logger.
* @type {Object}
*/
Object.defineProperty(winston, 'default', {
get() {
return {
exceptionHandlers: defaultLogger.exceptionHandlers,
rejectionHandlers: defaultLogger.rejectionHandlers,
transports: defaultLogger.transports
};
}
});
// Have friendlier breakage notices for properties that were exposed by default
// on winston < 3.0.
warn.deprecated(winston, 'setLevels');
warn.forFunctions(winston, 'useFormat', ['cli']);
warn.forProperties(winston, 'useFormat', ['padLevels', 'stripColors']);
warn.forFunctions(winston, 'deprecated', [
'addRewriter',
'addFilter',
'clone',
'extend'
]);
warn.forProperties(winston, 'deprecated', ['emitErrs', 'levelLength']);
// Throw a useful error when users attempt to run `new winston.Logger`.
warn.moved(winston, 'createLogger', 'Logger');

61
node_modules/winston/lib/winston/common.js generated vendored Normal file
View File

@ -0,0 +1,61 @@
/**
* common.js: Internal helper and utility functions for winston.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
const { format } = require('util');
/**
* Set of simple deprecation notices and a way to expose them for a set of
* properties.
* @type {Object}
* @private
*/
exports.warn = {
deprecated(prop) {
return () => {
throw new Error(format('{ %s } was removed in winston@3.0.0.', prop));
};
},
useFormat(prop) {
return () => {
throw new Error([
format('{ %s } was removed in winston@3.0.0.', prop),
'Use a custom winston.format = winston.format(function) instead.'
].join('\n'));
};
},
forFunctions(obj, type, props) {
props.forEach(prop => {
obj[prop] = exports.warn[type](prop);
});
},
moved(obj, movedTo, prop) {
function movedNotice() {
return () => {
throw new Error([
format('winston.%s was moved in winston@3.0.0.', prop),
format('Use a winston.%s instead.', movedTo)
].join('\n'));
};
}
Object.defineProperty(obj, prop, {
get: movedNotice,
set: movedNotice
});
},
forProperties(obj, type, props) {
props.forEach(prop => {
const notice = exports.warn[type](prop);
Object.defineProperty(obj, prop, {
get: notice,
set: notice
});
});
}
};

98
node_modules/winston/lib/winston/config/index.d.ts generated vendored Normal file
View File

@ -0,0 +1,98 @@
// Type definitions for winston 3.0
// Project: https://github.com/winstonjs/winston
/// <reference types="node" />
declare namespace winston {
interface AbstractConfigSetLevels {
[key: string]: number;
}
interface AbstractConfigSetColors {
[key: string]: string | string[];
}
interface AbstractConfigSet {
levels: AbstractConfigSetLevels;
colors: AbstractConfigSetColors;
}
interface CliConfigSetLevels extends AbstractConfigSetLevels {
error: number;
warn: number;
help: number;
data: number;
info: number;
debug: number;
prompt: number;
verbose: number;
input: number;
silly: number;
}
interface CliConfigSetColors extends AbstractConfigSetColors {
error: string | string[];
warn: string | string[];
help: string | string[];
data: string | string[];
info: string | string[];
debug: string | string[];
prompt: string | string[];
verbose: string | string[];
input: string | string[];
silly: string | string[];
}
interface NpmConfigSetLevels extends AbstractConfigSetLevels {
error: number;
warn: number;
info: number;
http: number;
verbose: number;
debug: number;
silly: number;
}
interface NpmConfigSetColors extends AbstractConfigSetColors {
error: string | string[];
warn: string | string[];
info: string | string[];
verbose: string | string[];
debug: string | string[];
silly: string | string[];
}
interface SyslogConfigSetLevels extends AbstractConfigSetLevels {
emerg: number;
alert: number;
crit: number;
error: number;
warning: number;
notice: number;
info: number;
debug: number;
}
interface SyslogConfigSetColors extends AbstractConfigSetColors {
emerg: string | string[];
alert: string | string[];
crit: string | string[];
error: string | string[];
warning: string | string[];
notice: string | string[];
info: string | string[];
debug: string | string[];
}
interface Config {
allColors: AbstractConfigSetColors;
cli: { levels: CliConfigSetLevels, colors: CliConfigSetColors };
npm: { levels: NpmConfigSetLevels, colors: NpmConfigSetColors };
syslog: { levels: SyslogConfigSetLevels, colors: SyslogConfigSetColors };
addColors(colors: AbstractConfigSetColors): void;
}
}
declare const winston: winston.Config;
export = winston;

35
node_modules/winston/lib/winston/config/index.js generated vendored Normal file
View File

@ -0,0 +1,35 @@
/**
* index.js: Default settings for all levels that winston knows about.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
const logform = require('logform');
const { configs } = require('triple-beam');
/**
* Export config set for the CLI.
* @type {Object}
*/
exports.cli = logform.levels(configs.cli);
/**
* Export config set for npm.
* @type {Object}
*/
exports.npm = logform.levels(configs.npm);
/**
* Export config set for the syslog.
* @type {Object}
*/
exports.syslog = logform.levels(configs.syslog);
/**
* Hoist addColors from logform where it was refactored into in winston@3.
* @type {Object}
*/
exports.addColors = logform.levels;

114
node_modules/winston/lib/winston/container.js generated vendored Normal file
View File

@ -0,0 +1,114 @@
/**
* container.js: Inversion of control container for winston logger instances.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
const createLogger = require('./create-logger');
/**
* Inversion of control container for winston logger instances.
* @type {Container}
*/
module.exports = class Container {
/**
* Constructor function for the Container object responsible for managing a
* set of `winston.Logger` instances based on string ids.
* @param {!Object} [options={}] - Default pass-thru options for Loggers.
*/
constructor(options = {}) {
this.loggers = new Map();
this.options = options;
}
/**
* Retreives a `winston.Logger` instance for the specified `id`. If an
* instance does not exist, one is created.
* @param {!string} id - The id of the Logger to get.
* @param {?Object} [options] - Options for the Logger instance.
* @returns {Logger} - A configured Logger instance with a specified id.
*/
add(id, options) {
if (!this.loggers.has(id)) {
// Remark: Simple shallow clone for configuration options in case we pass
// in instantiated protoypal objects
options = Object.assign({}, options || this.options);
const existing = options.transports || this.options.transports;
// Remark: Make sure if we have an array of transports we slice it to
// make copies of those references.
options.transports = existing ? existing.slice() : [];
const logger = createLogger(options);
logger.on('close', () => this._delete(id));
this.loggers.set(id, logger);
}
return this.loggers.get(id);
}
/**
* Retreives a `winston.Logger` instance for the specified `id`. If
* an instance does not exist, one is created.
* @param {!string} id - The id of the Logger to get.
* @param {?Object} [options] - Options for the Logger instance.
* @returns {Logger} - A configured Logger instance with a specified id.
*/
get(id, options) {
return this.add(id, options);
}
/**
* Check if the container has a logger with the id.
* @param {?string} id - The id of the Logger instance to find.
* @returns {boolean} - Boolean value indicating if this instance has a
* logger with the specified `id`.
*/
has(id) {
return !!this.loggers.has(id);
}
/**
* Closes a `Logger` instance with the specified `id` if it exists.
* If no `id` is supplied then all Loggers are closed.
* @param {?string} id - The id of the Logger instance to close.
* @returns {undefined}
*/
close(id) {
if (id) {
return this._removeLogger(id);
}
this.loggers.forEach((val, key) => this._removeLogger(key));
}
/**
* Remove a logger based on the id.
* @param {!string} id - The id of the logger to remove.
* @returns {undefined}
* @private
*/
_removeLogger(id) {
if (!this.loggers.has(id)) {
return;
}
const logger = this.loggers.get(id);
logger.close();
this._delete(id);
}
/**
* Deletes a `Logger` instance with the specified `id`.
* @param {!string} id - The id of the Logger instance to delete from
* container.
* @returns {undefined}
* @private
*/
_delete(id) {
this.loggers.delete(id);
}
};

104
node_modules/winston/lib/winston/create-logger.js generated vendored Normal file
View File

@ -0,0 +1,104 @@
/**
* create-logger.js: Logger factory for winston logger instances.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
const { LEVEL } = require('triple-beam');
const config = require('./config');
const Logger = require('./logger');
const debug = require('diagnostics')('winston:create-logger');
function isLevelEnabledFunctionName(level) {
return 'is' + level.charAt(0).toUpperCase() + level.slice(1) + 'Enabled';
}
/**
* Create a new instance of a winston Logger. Creates a new
* prototype for each instance.
* @param {!Object} opts - Options for the created logger.
* @returns {Logger} - A newly created logger instance.
*/
module.exports = function (opts = {}) {
//
// Default levels: npm
//
opts.levels = opts.levels || config.npm.levels;
/**
* DerivedLogger to attach the logs level methods.
* @type {DerivedLogger}
* @extends {Logger}
*/
class DerivedLogger extends Logger {
/**
* Create a new class derived logger for which the levels can be attached to
* the prototype of. This is a V8 optimization that is well know to increase
* performance of prototype functions.
* @param {!Object} options - Options for the created logger.
*/
constructor(options) {
super(options);
}
}
const logger = new DerivedLogger(opts);
//
// Create the log level methods for the derived logger.
//
Object.keys(opts.levels).forEach(function (level) {
debug('Define prototype method for "%s"', level);
if (level === 'log') {
// eslint-disable-next-line no-console
console.warn('Level "log" not defined: conflicts with the method "log". Use a different level name.');
return;
}
//
// Define prototype methods for each log level e.g.:
// logger.log('info', msg) implies these methods are defined:
// - logger.info(msg)
// - logger.isInfoEnabled()
//
// Remark: to support logger.child this **MUST** be a function
// so it'll always be called on the instance instead of a fixed
// place in the prototype chain.
//
DerivedLogger.prototype[level] = function (...args) {
// Prefer any instance scope, but default to "root" logger
const self = this || logger;
// Optimize the hot-path which is the single object.
if (args.length === 1) {
const [msg] = args;
const info = msg && msg.message && msg || { message: msg };
info.level = info[LEVEL] = level;
self._addDefaultMeta(info);
self.write(info);
return (this || logger);
}
// When provided nothing assume the empty string
if (args.length === 0) {
self.log(level, '');
return self;
}
// Otherwise build argument list which could potentially conform to
// either:
// . v3 API: log(obj)
// 2. v1/v2 API: log(level, msg, ... [string interpolate], [{metadata}], [callback])
return self.log(level, ...args);
};
DerivedLogger.prototype[isLevelEnabledFunctionName(level)] = function () {
return (this || logger).isLevelEnabled(level);
};
});
return logger;
};

245
node_modules/winston/lib/winston/exception-handler.js generated vendored Normal file
View File

@ -0,0 +1,245 @@
/**
* exception-handler.js: Object for handling uncaughtException events.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
const os = require('os');
const asyncForEach = require('async/forEach');
const debug = require('diagnostics')('winston:exception');
const once = require('one-time');
const stackTrace = require('stack-trace');
const ExceptionStream = require('./exception-stream');
/**
* Object for handling uncaughtException events.
* @type {ExceptionHandler}
*/
module.exports = class ExceptionHandler {
/**
* TODO: add contructor description
* @param {!Logger} logger - TODO: add param description
*/
constructor(logger) {
if (!logger) {
throw new Error('Logger is required to handle exceptions');
}
this.logger = logger;
this.handlers = new Map();
}
/**
* Handles `uncaughtException` events for the current process by adding any
* handlers passed in.
* @returns {undefined}
*/
handle(...args) {
args.forEach(arg => {
if (Array.isArray(arg)) {
return arg.forEach(handler => this._addHandler(handler));
}
this._addHandler(arg);
});
if (!this.catcher) {
this.catcher = this._uncaughtException.bind(this);
process.on('uncaughtException', this.catcher);
}
}
/**
* Removes any handlers to `uncaughtException` events for the current
* process. This does not modify the state of the `this.handlers` set.
* @returns {undefined}
*/
unhandle() {
if (this.catcher) {
process.removeListener('uncaughtException', this.catcher);
this.catcher = false;
Array.from(this.handlers.values())
.forEach(wrapper => this.logger.unpipe(wrapper));
}
}
/**
* TODO: add method description
* @param {Error} err - Error to get information about.
* @returns {mixed} - TODO: add return description.
*/
getAllInfo(err) {
let { message } = err;
if (!message && typeof err === 'string') {
message = err;
}
return {
error: err,
// TODO (indexzero): how do we configure this?
level: 'error',
message: [
`uncaughtException: ${(message || '(no error message)')}`,
err.stack || ' No stack trace'
].join('\n'),
stack: err.stack,
exception: true,
date: new Date().toString(),
process: this.getProcessInfo(),
os: this.getOsInfo(),
trace: this.getTrace(err)
};
}
/**
* Gets all relevant process information for the currently running process.
* @returns {mixed} - TODO: add return description.
*/
getProcessInfo() {
return {
pid: process.pid,
uid: process.getuid ? process.getuid() : null,
gid: process.getgid ? process.getgid() : null,
cwd: process.cwd(),
execPath: process.execPath,
version: process.version,
argv: process.argv,
memoryUsage: process.memoryUsage()
};
}
/**
* Gets all relevant OS information for the currently running process.
* @returns {mixed} - TODO: add return description.
*/
getOsInfo() {
return {
loadavg: os.loadavg(),
uptime: os.uptime()
};
}
/**
* Gets a stack trace for the specified error.
* @param {mixed} err - TODO: add param description.
* @returns {mixed} - TODO: add return description.
*/
getTrace(err) {
const trace = err ? stackTrace.parse(err) : stackTrace.get();
return trace.map(site => {
return {
column: site.getColumnNumber(),
file: site.getFileName(),
function: site.getFunctionName(),
line: site.getLineNumber(),
method: site.getMethodName(),
native: site.isNative()
};
});
}
/**
* Helper method to add a transport as an exception handler.
* @param {Transport} handler - The transport to add as an exception handler.
* @returns {void}
*/
_addHandler(handler) {
if (!this.handlers.has(handler)) {
handler.handleExceptions = true;
const wrapper = new ExceptionStream(handler);
this.handlers.set(handler, wrapper);
this.logger.pipe(wrapper);
}
}
/**
* Logs all relevant information around the `err` and exits the current
* process.
* @param {Error} err - Error to handle
* @returns {mixed} - TODO: add return description.
* @private
*/
_uncaughtException(err) {
const info = this.getAllInfo(err);
const handlers = this._getExceptionHandlers();
// Calculate if we should exit on this error
let doExit = typeof this.logger.exitOnError === 'function'
? this.logger.exitOnError(err)
: this.logger.exitOnError;
let timeout;
if (!handlers.length && doExit) {
// eslint-disable-next-line no-console
console.warn('winston: exitOnError cannot be true with no exception handlers.');
// eslint-disable-next-line no-console
console.warn('winston: not exiting process.');
doExit = false;
}
function gracefulExit() {
debug('doExit', doExit);
debug('process._exiting', process._exiting);
if (doExit && !process._exiting) {
// Remark: Currently ignoring any exceptions from transports when
// catching uncaught exceptions.
if (timeout) {
clearTimeout(timeout);
}
// eslint-disable-next-line no-process-exit
process.exit(1);
}
}
if (!handlers || handlers.length === 0) {
return process.nextTick(gracefulExit);
}
// Log to all transports attempting to listen for when they are completed.
asyncForEach(handlers, (handler, next) => {
const done = once(next);
const transport = handler.transport || handler;
// Debug wrapping so that we can inspect what's going on under the covers.
function onDone(event) {
return () => {
debug(event);
done();
};
}
transport._ending = true;
transport.once('finish', onDone('finished'));
transport.once('error', onDone('error'));
}, () => doExit && gracefulExit());
this.logger.log(info);
// If exitOnError is true, then only allow the logging of exceptions to
// take up to `3000ms`.
if (doExit) {
timeout = setTimeout(gracefulExit, 3000);
}
}
/**
* Returns the list of transports and exceptionHandlers for this instance.
* @returns {Array} - List of transports and exceptionHandlers for this
* instance.
* @private
*/
_getExceptionHandlers() {
// Remark (indexzero): since `logger.transports` returns all of the pipes
// from the _readableState of the stream we actually get the join of the
// explicit handlers and the implicit transports with
// `handleExceptions: true`
return this.logger.transports.filter(wrap => {
const transport = wrap.transport || wrap;
return transport.handleExceptions;
});
}
};

54
node_modules/winston/lib/winston/exception-stream.js generated vendored Normal file
View File

@ -0,0 +1,54 @@
/**
* exception-stream.js: TODO: add file header handler.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
const { Writable } = require('readable-stream');
/**
* TODO: add class description.
* @type {ExceptionStream}
* @extends {Writable}
*/
module.exports = class ExceptionStream extends Writable {
/**
* Constructor function for the ExceptionStream responsible for wrapping a
* TransportStream; only allowing writes of `info` objects with
* `info.exception` set to true.
* @param {!TransportStream} transport - Stream to filter to exceptions
*/
constructor(transport) {
super({ objectMode: true });
if (!transport) {
throw new Error('ExceptionStream requires a TransportStream instance.');
}
// Remark (indexzero): we set `handleExceptions` here because it's the
// predicate checked in ExceptionHandler.prototype.__getExceptionHandlers
this.handleExceptions = true;
this.transport = transport;
}
/**
* Writes the info object to our transport instance if (and only if) the
* `exception` property is set on the info.
* @param {mixed} info - TODO: add param description.
* @param {mixed} enc - TODO: add param description.
* @param {mixed} callback - TODO: add param description.
* @returns {mixed} - TODO: add return description.
* @private
*/
_write(info, enc, callback) {
if (info.exception) {
return this.transport.log(info, callback);
}
callback();
return true;
}
};

662
node_modules/winston/lib/winston/logger.js generated vendored Normal file
View File

@ -0,0 +1,662 @@
/**
* logger.js: TODO: add file header description.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
const { Stream, Transform } = require('readable-stream');
const asyncForEach = require('async/forEach');
const { LEVEL, SPLAT } = require('triple-beam');
const isStream = require('is-stream');
const ExceptionHandler = require('./exception-handler');
const RejectionHandler = require('./rejection-handler');
const LegacyTransportStream = require('winston-transport/legacy');
const Profiler = require('./profiler');
const { warn } = require('./common');
const config = require('./config');
/**
* Captures the number of format (i.e. %s strings) in a given string.
* Based on `util.format`, see Node.js source:
* https://github.com/nodejs/node/blob/b1c8f15c5f169e021f7c46eb7b219de95fe97603/lib/util.js#L201-L230
* @type {RegExp}
*/
const formatRegExp = /%[scdjifoO%]/g;
/**
* TODO: add class description.
* @type {Logger}
* @extends {Transform}
*/
class Logger extends Transform {
/**
* Constructor function for the Logger object responsible for persisting log
* messages and metadata to one or more transports.
* @param {!Object} options - foo
*/
constructor(options) {
super({ objectMode: true });
this.configure(options);
}
child(defaultRequestMetadata) {
const logger = this;
return Object.create(logger, {
write: {
value: function (info) {
const infoClone = Object.assign(
{},
defaultRequestMetadata,
info
);
// Object.assign doesn't copy inherited Error
// properties so we have to do that explicitly
//
// Remark (indexzero): we should remove this
// since the errors format will handle this case.
//
if (info instanceof Error) {
infoClone.stack = info.stack;
infoClone.message = info.message;
}
logger.write(infoClone);
}
}
});
}
/**
* This will wholesale reconfigure this instance by:
* 1. Resetting all transports. Older transports will be removed implicitly.
* 2. Set all other options including levels, colors, rewriters, filters,
* exceptionHandlers, etc.
* @param {!Object} options - TODO: add param description.
* @returns {undefined}
*/
configure({
silent,
format,
defaultMeta,
levels,
level = 'info',
exitOnError = true,
transports,
colors,
emitErrs,
formatters,
padLevels,
rewriters,
stripColors,
exceptionHandlers,
rejectionHandlers
} = {}) {
// Reset transports if we already have them
if (this.transports.length) {
this.clear();
}
this.silent = silent;
this.format = format || this.format || require('logform/json')();
this.defaultMeta = defaultMeta || null;
// Hoist other options onto this instance.
this.levels = levels || this.levels || config.npm.levels;
this.level = level;
this.exceptions = new ExceptionHandler(this);
this.rejections = new RejectionHandler(this);
this.profilers = {};
this.exitOnError = exitOnError;
// Add all transports we have been provided.
if (transports) {
transports = Array.isArray(transports) ? transports : [transports];
transports.forEach(transport => this.add(transport));
}
if (
colors ||
emitErrs ||
formatters ||
padLevels ||
rewriters ||
stripColors
) {
throw new Error(
[
'{ colors, emitErrs, formatters, padLevels, rewriters, stripColors } were removed in winston@3.0.0.',
'Use a custom winston.format(function) instead.',
'See: https://github.com/winstonjs/winston/tree/master/UPGRADE-3.0.md'
].join('\n')
);
}
if (exceptionHandlers) {
this.exceptions.handle(exceptionHandlers);
}
if (rejectionHandlers) {
this.rejections.handle(rejectionHandlers);
}
}
isLevelEnabled(level) {
const givenLevelValue = getLevelValue(this.levels, level);
if (givenLevelValue === null) {
return false;
}
const configuredLevelValue = getLevelValue(this.levels, this.level);
if (configuredLevelValue === null) {
return false;
}
if (!this.transports || this.transports.length === 0) {
return configuredLevelValue >= givenLevelValue;
}
const index = this.transports.findIndex(transport => {
let transportLevelValue = getLevelValue(this.levels, transport.level);
if (transportLevelValue === null) {
transportLevelValue = configuredLevelValue;
}
return transportLevelValue >= givenLevelValue;
});
return index !== -1;
}
/* eslint-disable valid-jsdoc */
/**
* Ensure backwards compatibility with a `log` method
* @param {mixed} level - Level the log message is written at.
* @param {mixed} msg - TODO: add param description.
* @param {mixed} meta - TODO: add param description.
* @returns {Logger} - TODO: add return description.
*
* @example
* // Supports the existing API:
* logger.log('info', 'Hello world', { custom: true });
* logger.log('info', new Error('Yo, it\'s on fire'));
*
* // Requires winston.format.splat()
* logger.log('info', '%s %d%%', 'A string', 50, { thisIsMeta: true });
*
* // And the new API with a single JSON literal:
* logger.log({ level: 'info', message: 'Hello world', custom: true });
* logger.log({ level: 'info', message: new Error('Yo, it\'s on fire') });
*
* // Also requires winston.format.splat()
* logger.log({
* level: 'info',
* message: '%s %d%%',
* [SPLAT]: ['A string', 50],
* meta: { thisIsMeta: true }
* });
*
*/
/* eslint-enable valid-jsdoc */
log(level, msg, ...splat) {
// eslint-disable-line max-params
// Optimize for the hotpath of logging JSON literals
if (arguments.length === 1) {
// Yo dawg, I heard you like levels ... seriously ...
// In this context the LHS `level` here is actually the `info` so read
// this as: info[LEVEL] = info.level;
level[LEVEL] = level.level;
this._addDefaultMeta(level);
this.write(level);
return this;
}
// Slightly less hotpath, but worth optimizing for.
if (arguments.length === 2) {
if (msg && typeof msg === 'object') {
msg[LEVEL] = msg.level = level;
this._addDefaultMeta(msg);
this.write(msg);
return this;
}
this.write({ [LEVEL]: level, level, message: msg });
return this;
}
const [meta] = splat;
if (typeof meta === 'object' && meta !== null) {
// Extract tokens, if none available default to empty array to
// ensure consistancy in expected results
const tokens = msg && msg.match && msg.match(formatRegExp);
if (!tokens) {
const info = Object.assign({}, this.defaultMeta, meta, {
[LEVEL]: level,
[SPLAT]: splat,
level,
message: msg
});
if (meta.message) info.message += `${meta.message}`;
if (meta.stack) info.stack = meta.stack;
this.write(info);
return this;
}
}
this.write(Object.assign({}, this.defaultMeta, {
[LEVEL]: level,
[SPLAT]: splat,
level,
message: msg
}));
return this;
}
/**
* Pushes data so that it can be picked up by all of our pipe targets.
* @param {mixed} info - TODO: add param description.
* @param {mixed} enc - TODO: add param description.
* @param {mixed} callback - Continues stream processing.
* @returns {undefined}
* @private
*/
_transform(info, enc, callback) {
if (this.silent) {
return callback();
}
// [LEVEL] is only soft guaranteed to be set here since we are a proper
// stream. It is likely that `info` came in through `.log(info)` or
// `.info(info)`. If it is not defined, however, define it.
// This LEVEL symbol is provided by `triple-beam` and also used in:
// - logform
// - winston-transport
// - abstract-winston-transport
if (!info[LEVEL]) {
info[LEVEL] = info.level;
}
// Remark: really not sure what to do here, but this has been reported as
// very confusing by pre winston@2.0.0 users as quite confusing when using
// custom levels.
if (!this.levels[info[LEVEL]] && this.levels[info[LEVEL]] !== 0) {
// eslint-disable-next-line no-console
console.error('[winston] Unknown logger level: %s', info[LEVEL]);
}
// Remark: not sure if we should simply error here.
if (!this._readableState.pipes) {
// eslint-disable-next-line no-console
console.error(
'[winston] Attempt to write logs with no transports %j',
info
);
}
// Here we write to the `format` pipe-chain, which on `readable` above will
// push the formatted `info` Object onto the buffer for this instance. We trap
// (and re-throw) any errors generated by the user-provided format, but also
// guarantee that the streams callback is invoked so that we can continue flowing.
try {
this.push(this.format.transform(info, this.format.options));
} catch (ex) {
throw ex;
} finally {
// eslint-disable-next-line callback-return
callback();
}
}
/**
* Delays the 'finish' event until all transport pipe targets have
* also emitted 'finish' or are already finished.
* @param {mixed} callback - Continues stream processing.
*/
_final(callback) {
const transports = this.transports.slice();
asyncForEach(
transports,
(transport, next) => {
if (!transport || transport.finished) return setImmediate(next);
transport.once('finish', next);
transport.end();
},
callback
);
}
/**
* Adds the transport to this logger instance by piping to it.
* @param {mixed} transport - TODO: add param description.
* @returns {Logger} - TODO: add return description.
*/
add(transport) {
// Support backwards compatibility with all existing `winston < 3.x.x`
// transports which meet one of two criteria:
// 1. They inherit from winston.Transport in < 3.x.x which is NOT a stream.
// 2. They expose a log method which has a length greater than 2 (i.e. more then
// just `log(info, callback)`.
const target =
!isStream(transport) || transport.log.length > 2
? new LegacyTransportStream({ transport })
: transport;
if (!target._writableState || !target._writableState.objectMode) {
throw new Error(
'Transports must WritableStreams in objectMode. Set { objectMode: true }.'
);
}
// Listen for the `error` event and the `warn` event on the new Transport.
this._onEvent('error', target);
this._onEvent('warn', target);
this.pipe(target);
if (transport.handleExceptions) {
this.exceptions.handle();
}
if (transport.handleRejections) {
this.rejections.handle();
}
return this;
}
/**
* Removes the transport from this logger instance by unpiping from it.
* @param {mixed} transport - TODO: add param description.
* @returns {Logger} - TODO: add return description.
*/
remove(transport) {
let target = transport;
if (!isStream(transport) || transport.log.length > 2) {
target = this.transports.filter(
match => match.transport === transport
)[0];
}
if (target) {
this.unpipe(target);
}
return this;
}
/**
* Removes all transports from this logger instance.
* @returns {Logger} - TODO: add return description.
*/
clear() {
this.unpipe();
return this;
}
/**
* Cleans up resources (streams, event listeners) for all transports
* associated with this instance (if necessary).
* @returns {Logger} - TODO: add return description.
*/
close() {
this.clear();
this.emit('close');
return this;
}
/**
* Sets the `target` levels specified on this instance.
* @param {Object} Target levels to use on this instance.
*/
setLevels() {
warn.deprecated('setLevels');
}
/**
* Queries the all transports for this instance with the specified `options`.
* This will aggregate each transport's results into one object containing
* a property per transport.
* @param {Object} options - Query options for this instance.
* @param {function} callback - Continuation to respond to when complete.
*/
query(options, callback) {
if (typeof options === 'function') {
callback = options;
options = {};
}
options = options || {};
const results = {};
const queryObject = Object.assign({}, options.query || {});
// Helper function to query a single transport
function queryTransport(transport, next) {
if (options.query && typeof transport.formatQuery === 'function') {
options.query = transport.formatQuery(queryObject);
}
transport.query(options, (err, res) => {
if (err) {
return next(err);
}
if (typeof transport.formatResults === 'function') {
res = transport.formatResults(res, options.format);
}
next(null, res);
});
}
// Helper function to accumulate the results from `queryTransport` into
// the `results`.
function addResults(transport, next) {
queryTransport(transport, (err, result) => {
// queryTransport could potentially invoke the callback multiple times
// since Transport code can be unpredictable.
if (next) {
result = err || result;
if (result) {
results[transport.name] = result;
}
// eslint-disable-next-line callback-return
next();
}
next = null;
});
}
// Iterate over the transports in parallel setting the appropriate key in
// the `results`.
asyncForEach(
this.transports.filter(transport => !!transport.query),
addResults,
() => callback(null, results)
);
}
/**
* Returns a log stream for all transports. Options object is optional.
* @param{Object} options={} - Stream options for this instance.
* @returns {Stream} - TODO: add return description.
*/
stream(options = {}) {
const out = new Stream();
const streams = [];
out._streams = streams;
out.destroy = () => {
let i = streams.length;
while (i--) {
streams[i].destroy();
}
};
// Create a list of all transports for this instance.
this.transports
.filter(transport => !!transport.stream)
.forEach(transport => {
const str = transport.stream(options);
if (!str) {
return;
}
streams.push(str);
str.on('log', log => {
log.transport = log.transport || [];
log.transport.push(transport.name);
out.emit('log', log);
});
str.on('error', err => {
err.transport = err.transport || [];
err.transport.push(transport.name);
out.emit('error', err);
});
});
return out;
}
/**
* Returns an object corresponding to a specific timing. When done is called
* the timer will finish and log the duration. e.g.:
* @returns {Profile} - TODO: add return description.
* @example
* const timer = winston.startTimer()
* setTimeout(() => {
* timer.done({
* message: 'Logging message'
* });
* }, 1000);
*/
startTimer() {
return new Profiler(this);
}
/**
* Tracks the time inbetween subsequent calls to this method with the same
* `id` parameter. The second call to this method will log the difference in
* milliseconds along with the message.
* @param {string} id Unique id of the profiler
* @returns {Logger} - TODO: add return description.
*/
profile(id, ...args) {
const time = Date.now();
if (this.profilers[id]) {
const timeEnd = this.profilers[id];
delete this.profilers[id];
// Attempt to be kind to users if they are still using older APIs.
if (typeof args[args.length - 2] === 'function') {
// eslint-disable-next-line no-console
console.warn(
'Callback function no longer supported as of winston@3.0.0'
);
args.pop();
}
// Set the duration property of the metadata
const info = typeof args[args.length - 1] === 'object' ? args.pop() : {};
info.level = info.level || 'info';
info.durationMs = time - timeEnd;
info.message = info.message || id;
return this.write(info);
}
this.profilers[id] = time;
return this;
}
/**
* Backwards compatibility to `exceptions.handle` in winston < 3.0.0.
* @returns {undefined}
* @deprecated
*/
handleExceptions(...args) {
// eslint-disable-next-line no-console
console.warn(
'Deprecated: .handleExceptions() will be removed in winston@4. Use .exceptions.handle()'
);
this.exceptions.handle(...args);
}
/**
* Backwards compatibility to `exceptions.handle` in winston < 3.0.0.
* @returns {undefined}
* @deprecated
*/
unhandleExceptions(...args) {
// eslint-disable-next-line no-console
console.warn(
'Deprecated: .unhandleExceptions() will be removed in winston@4. Use .exceptions.unhandle()'
);
this.exceptions.unhandle(...args);
}
/**
* Throw a more meaningful deprecation notice
* @throws {Error} - TODO: add throws description.
*/
cli() {
throw new Error(
[
'Logger.cli() was removed in winston@3.0.0',
'Use a custom winston.formats.cli() instead.',
'See: https://github.com/winstonjs/winston/tree/master/UPGRADE-3.0.md'
].join('\n')
);
}
/**
* Bubbles the `event` that occured on the specified `transport` up
* from this instance.
* @param {string} event - The event that occured
* @param {Object} transport - Transport on which the event occured
* @private
*/
_onEvent(event, transport) {
function transportEvent(err) {
this.emit(event, err, transport);
}
if (!transport['__winston' + event]) {
transport['__winston' + event] = transportEvent.bind(this);
transport.on(event, transport['__winston' + event]);
}
}
_addDefaultMeta(msg) {
if (this.defaultMeta) {
Object.assign(msg, this.defaultMeta);
}
}
}
function getLevelValue(levels, level) {
const value = levels[level];
if (!value && value !== 0) {
return null;
}
return value;
}
/**
* Represents the current readableState pipe targets for this Logger instance.
* @type {Array|Object}
*/
Object.defineProperty(Logger.prototype, 'transports', {
configurable: false,
enumerable: true,
get() {
const { pipes } = this._readableState;
return !Array.isArray(pipes) ? [pipes].filter(Boolean) : pipes;
}
});
module.exports = Logger;

51
node_modules/winston/lib/winston/profiler.js generated vendored Normal file
View File

@ -0,0 +1,51 @@
/**
* profiler.js: TODO: add file header description.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
/**
* TODO: add class description.
* @type {Profiler}
* @private
*/
module.exports = class Profiler {
/**
* Constructor function for the Profiler instance used by
* `Logger.prototype.startTimer`. When done is called the timer will finish
* and log the duration.
* @param {!Logger} logger - TODO: add param description.
* @private
*/
constructor(logger) {
if (!logger) {
throw new Error('Logger is required for profiling.');
}
this.logger = logger;
this.start = Date.now();
}
/**
* Ends the current timer (i.e. Profiler) instance and logs the `msg` along
* with the duration since creation.
* @returns {mixed} - TODO: add return description.
* @private
*/
done(...args) {
if (typeof args[args.length - 1] === 'function') {
// eslint-disable-next-line no-console
console.warn('Callback function no longer supported as of winston@3.0.0');
args.pop();
}
const info = typeof args[args.length - 1] === 'object' ? args.pop() : {};
info.level = info.level || 'info';
info.durationMs = (Date.now()) - this.start;
return this.logger.write(info);
}
};

251
node_modules/winston/lib/winston/rejection-handler.js generated vendored Normal file
View File

@ -0,0 +1,251 @@
/**
* exception-handler.js: Object for handling uncaughtException events.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
const os = require('os');
const asyncForEach = require('async/forEach');
const debug = require('diagnostics')('winston:rejection');
const once = require('one-time');
const stackTrace = require('stack-trace');
const ExceptionStream = require('./exception-stream');
/**
* Object for handling unhandledRejection events.
* @type {RejectionHandler}
*/
module.exports = class RejectionHandler {
/**
* TODO: add contructor description
* @param {!Logger} logger - TODO: add param description
*/
constructor(logger) {
if (!logger) {
throw new Error('Logger is required to handle rejections');
}
this.logger = logger;
this.handlers = new Map();
}
/**
* Handles `unhandledRejection` events for the current process by adding any
* handlers passed in.
* @returns {undefined}
*/
handle(...args) {
args.forEach(arg => {
if (Array.isArray(arg)) {
return arg.forEach(handler => this._addHandler(handler));
}
this._addHandler(arg);
});
if (!this.catcher) {
this.catcher = this._unhandledRejection.bind(this);
process.on('unhandledRejection', this.catcher);
}
}
/**
* Removes any handlers to `unhandledRejection` events for the current
* process. This does not modify the state of the `this.handlers` set.
* @returns {undefined}
*/
unhandle() {
if (this.catcher) {
process.removeListener('unhandledRejection', this.catcher);
this.catcher = false;
Array.from(this.handlers.values()).forEach(wrapper =>
this.logger.unpipe(wrapper)
);
}
}
/**
* TODO: add method description
* @param {Error} err - Error to get information about.
* @returns {mixed} - TODO: add return description.
*/
getAllInfo(err) {
let { message } = err;
if (!message && typeof err === 'string') {
message = err;
}
return {
error: err,
// TODO (indexzero): how do we configure this?
level: 'error',
message: [
`unhandledRejection: ${message || '(no error message)'}`,
err.stack || ' No stack trace'
].join('\n'),
stack: err.stack,
exception: true,
date: new Date().toString(),
process: this.getProcessInfo(),
os: this.getOsInfo(),
trace: this.getTrace(err)
};
}
/**
* Gets all relevant process information for the currently running process.
* @returns {mixed} - TODO: add return description.
*/
getProcessInfo() {
return {
pid: process.pid,
uid: process.getuid ? process.getuid() : null,
gid: process.getgid ? process.getgid() : null,
cwd: process.cwd(),
execPath: process.execPath,
version: process.version,
argv: process.argv,
memoryUsage: process.memoryUsage()
};
}
/**
* Gets all relevant OS information for the currently running process.
* @returns {mixed} - TODO: add return description.
*/
getOsInfo() {
return {
loadavg: os.loadavg(),
uptime: os.uptime()
};
}
/**
* Gets a stack trace for the specified error.
* @param {mixed} err - TODO: add param description.
* @returns {mixed} - TODO: add return description.
*/
getTrace(err) {
const trace = err ? stackTrace.parse(err) : stackTrace.get();
return trace.map(site => {
return {
column: site.getColumnNumber(),
file: site.getFileName(),
function: site.getFunctionName(),
line: site.getLineNumber(),
method: site.getMethodName(),
native: site.isNative()
};
});
}
/**
* Helper method to add a transport as an exception handler.
* @param {Transport} handler - The transport to add as an exception handler.
* @returns {void}
*/
_addHandler(handler) {
if (!this.handlers.has(handler)) {
handler.handleExceptions = true;
const wrapper = new ExceptionStream(handler);
this.handlers.set(handler, wrapper);
this.logger.pipe(wrapper);
}
}
/**
* Logs all relevant information around the `err` and exits the current
* process.
* @param {Error} err - Error to handle
* @returns {mixed} - TODO: add return description.
* @private
*/
_unhandledRejection(err) {
const info = this.getAllInfo(err);
const handlers = this._getRejectionHandlers();
// Calculate if we should exit on this error
let doExit =
typeof this.logger.exitOnError === 'function'
? this.logger.exitOnError(err)
: this.logger.exitOnError;
let timeout;
if (!handlers.length && doExit) {
// eslint-disable-next-line no-console
console.warn('winston: exitOnError cannot be true with no rejection handlers.');
// eslint-disable-next-line no-console
console.warn('winston: not exiting process.');
doExit = false;
}
function gracefulExit() {
debug('doExit', doExit);
debug('process._exiting', process._exiting);
if (doExit && !process._exiting) {
// Remark: Currently ignoring any rejections from transports when
// catching unhandled rejections.
if (timeout) {
clearTimeout(timeout);
}
// eslint-disable-next-line no-process-exit
process.exit(1);
}
}
if (!handlers || handlers.length === 0) {
return process.nextTick(gracefulExit);
}
// Log to all transports attempting to listen for when they are completed.
asyncForEach(
handlers,
(handler, next) => {
const done = once(next);
const transport = handler.transport || handler;
// Debug wrapping so that we can inspect what's going on under the covers.
function onDone(event) {
return () => {
debug(event);
done();
};
}
transport._ending = true;
transport.once('finish', onDone('finished'));
transport.once('error', onDone('error'));
},
() => doExit && gracefulExit()
);
this.logger.log(info);
// If exitOnError is true, then only allow the logging of exceptions to
// take up to `3000ms`.
if (doExit) {
timeout = setTimeout(gracefulExit, 3000);
}
}
/**
* Returns the list of transports and exceptionHandlers for this instance.
* @returns {Array} - List of transports and exceptionHandlers for this
* instance.
* @private
*/
_getRejectionHandlers() {
// Remark (indexzero): since `logger.transports` returns all of the pipes
// from the _readableState of the stream we actually get the join of the
// explicit handlers and the implicit transports with
// `handleRejections: true`
return this.logger.transports.filter(wrap => {
const transport = wrap.transport || wrap;
return transport.handleRejections;
});
}
};

124
node_modules/winston/lib/winston/tail-file.js generated vendored Normal file
View File

@ -0,0 +1,124 @@
/**
* tail-file.js: TODO: add file header description.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
const fs = require('fs');
const { StringDecoder } = require('string_decoder');
const { Stream } = require('readable-stream');
/**
* Simple no-op function.
* @returns {undefined}
*/
function noop() {}
/**
* TODO: add function description.
* @param {Object} options - Options for tail.
* @param {function} iter - Iterator function to execute on every line.
* `tail -f` a file. Options must include file.
* @returns {mixed} - TODO: add return description.
*/
module.exports = (options, iter) => {
const buffer = Buffer.alloc(64 * 1024);
const decode = new StringDecoder('utf8');
const stream = new Stream();
let buff = '';
let pos = 0;
let row = 0;
if (options.start === -1) {
delete options.start;
}
stream.readable = true;
stream.destroy = () => {
stream.destroyed = true;
stream.emit('end');
stream.emit('close');
};
fs.open(options.file, 'a+', '0644', (err, fd) => {
if (err) {
if (!iter) {
stream.emit('error', err);
} else {
iter(err);
}
stream.destroy();
return;
}
(function read() {
if (stream.destroyed) {
fs.close(fd, noop);
return;
}
return fs.read(fd, buffer, 0, buffer.length, pos, (err, bytes) => {
if (err) {
if (!iter) {
stream.emit('error', err);
} else {
iter(err);
}
stream.destroy();
return;
}
if (!bytes) {
if (buff) {
// eslint-disable-next-line eqeqeq
if (options.start == null || row > options.start) {
if (!iter) {
stream.emit('line', buff);
} else {
iter(null, buff);
}
}
row++;
buff = '';
}
return setTimeout(read, 1000);
}
let data = decode.write(buffer.slice(0, bytes));
if (!iter) {
stream.emit('data', data);
}
data = (buff + data).split(/\n+/);
const l = data.length - 1;
let i = 0;
for (; i < l; i++) {
// eslint-disable-next-line eqeqeq
if (options.start == null || row > options.start) {
if (!iter) {
stream.emit('line', data[i]);
} else {
iter(null, data[i]);
}
}
row++;
}
buff = data[l];
pos += bytes;
return read();
});
}());
});
if (!iter) {
return stream;
}
return stream.destroy;
};

117
node_modules/winston/lib/winston/transports/console.js generated vendored Normal file
View File

@ -0,0 +1,117 @@
/* eslint-disable no-console */
/*
* console.js: Transport for outputting to the console.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
const os = require('os');
const { LEVEL, MESSAGE } = require('triple-beam');
const TransportStream = require('winston-transport');
/**
* Transport for outputting to the console.
* @type {Console}
* @extends {TransportStream}
*/
module.exports = class Console extends TransportStream {
/**
* Constructor function for the Console transport object responsible for
* persisting log messages and metadata to a terminal or TTY.
* @param {!Object} [options={}] - Options for this instance.
*/
constructor(options = {}) {
super(options);
// Expose the name of this Transport on the prototype
this.name = options.name || 'console';
this.stderrLevels = this._stringArrayToSet(options.stderrLevels);
this.consoleWarnLevels = this._stringArrayToSet(options.consoleWarnLevels);
this.eol = options.eol || os.EOL;
this.setMaxListeners(30);
}
/**
* Core logging method exposed to Winston.
* @param {Object} info - TODO: add param description.
* @param {Function} callback - TODO: add param description.
* @returns {undefined}
*/
log(info, callback) {
setImmediate(() => this.emit('logged', info));
// Remark: what if there is no raw...?
if (this.stderrLevels[info[LEVEL]]) {
if (console._stderr) {
// Node.js maps `process.stderr` to `console._stderr`.
console._stderr.write(`${info[MESSAGE]}${this.eol}`);
} else {
// console.error adds a newline
console.error(info[MESSAGE]);
}
if (callback) {
callback(); // eslint-disable-line callback-return
}
return;
} else if (this.consoleWarnLevels[info[LEVEL]]) {
if (console._stderr) {
// Node.js maps `process.stderr` to `console._stderr`.
// in Node.js console.warn is an alias for console.error
console._stderr.write(`${info[MESSAGE]}${this.eol}`);
} else {
// console.warn adds a newline
console.warn(info[MESSAGE]);
}
if (callback) {
callback(); // eslint-disable-line callback-return
}
return;
}
if (console._stdout) {
// Node.js maps `process.stdout` to `console._stdout`.
console._stdout.write(`${info[MESSAGE]}${this.eol}`);
} else {
// console.log adds a newline.
console.log(info[MESSAGE]);
}
if (callback) {
callback(); // eslint-disable-line callback-return
}
}
/**
* Returns a Set-like object with strArray's elements as keys (each with the
* value true).
* @param {Array} strArray - Array of Set-elements as strings.
* @param {?string} [errMsg] - Custom error message thrown on invalid input.
* @returns {Object} - TODO: add return description.
* @private
*/
_stringArrayToSet(strArray, errMsg) {
if (!strArray)
return {};
errMsg = errMsg || 'Cannot make set from type other than Array of string elements';
if (!Array.isArray(strArray)) {
throw new Error(errMsg);
}
return strArray.reduce((set, el) => {
if (typeof el !== 'string') {
throw new Error(errMsg);
}
set[el] = true;
return set;
}, {});
}
};

698
node_modules/winston/lib/winston/transports/file.js generated vendored Normal file
View File

@ -0,0 +1,698 @@
/* eslint-disable complexity,max-statements */
/**
* file.js: Transport for outputting to a local log file.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
const fs = require('fs');
const path = require('path');
const asyncSeries = require('async/series');
const zlib = require('zlib');
const { MESSAGE } = require('triple-beam');
const { Stream, PassThrough } = require('readable-stream');
const TransportStream = require('winston-transport');
const debug = require('diagnostics')('winston:file');
const os = require('os');
const tailFile = require('../tail-file');
/**
* Transport for outputting to a local log file.
* @type {File}
* @extends {TransportStream}
*/
module.exports = class File extends TransportStream {
/**
* Constructor function for the File transport object responsible for
* persisting log messages and metadata to one or more files.
* @param {Object} options - Options for this instance.
*/
constructor(options = {}) {
super(options);
// Expose the name of this Transport on the prototype.
this.name = options.name || 'file';
// Helper function which throws an `Error` in the event that any of the
// rest of the arguments is present in `options`.
function throwIf(target, ...args) {
args.slice(1).forEach(name => {
if (options[name]) {
throw new Error(`Cannot set ${name} and ${target} together`);
}
});
}
// Setup the base stream that always gets piped to to handle buffering.
this._stream = new PassThrough();
this._stream.setMaxListeners(30);
// Bind this context for listener methods.
this._onError = this._onError.bind(this);
if (options.filename || options.dirname) {
throwIf('filename or dirname', 'stream');
this._basename = this.filename = options.filename
? path.basename(options.filename)
: 'winston.log';
this.dirname = options.dirname || path.dirname(options.filename);
this.options = options.options || { flags: 'a' };
} else if (options.stream) {
// eslint-disable-next-line no-console
console.warn('options.stream will be removed in winston@4. Use winston.transports.Stream');
throwIf('stream', 'filename', 'maxsize');
this._dest = this._stream.pipe(this._setupStream(options.stream));
this.dirname = path.dirname(this._dest.path);
// We need to listen for drain events when write() returns false. This
// can make node mad at times.
} else {
throw new Error('Cannot log to file without filename or stream.');
}
this.maxsize = options.maxsize || null;
this.rotationFormat = options.rotationFormat || false;
this.zippedArchive = options.zippedArchive || false;
this.maxFiles = options.maxFiles || null;
this.eol = options.eol || os.EOL;
this.tailable = options.tailable || false;
// Internal state variables representing the number of files this instance
// has created and the current size (in bytes) of the current logfile.
this._size = 0;
this._pendingSize = 0;
this._created = 0;
this._drain = false;
this._opening = false;
this._ending = false;
if (this.dirname) this._createLogDirIfNotExist(this.dirname);
this.open();
}
finishIfEnding() {
if (this._ending) {
if (this._opening) {
this.once('open', () => {
this._stream.once('finish', () => this.emit('finish'));
setImmediate(() => this._stream.end());
});
} else {
this._stream.once('finish', () => this.emit('finish'));
setImmediate(() => this._stream.end());
}
}
}
/**
* Core logging method exposed to Winston. Metadata is optional.
* @param {Object} info - TODO: add param description.
* @param {Function} callback - TODO: add param description.
* @returns {undefined}
*/
log(info, callback = () => {}) {
// Remark: (jcrugzz) What is necessary about this callback(null, true) now
// when thinking about 3.x? Should silent be handled in the base
// TransportStream _write method?
if (this.silent) {
callback();
return true;
}
// Output stream buffer is full and has asked us to wait for the drain event
if (this._drain) {
this._stream.once('drain', () => {
this._drain = false;
this.log(info, callback);
});
return;
}
if (this._rotate) {
this._stream.once('rotate', () => {
this._rotate = false;
this.log(info, callback);
});
return;
}
// Grab the raw string and append the expected EOL.
const output = `${info[MESSAGE]}${this.eol}`;
const bytes = Buffer.byteLength(output);
// After we have written to the PassThrough check to see if we need
// to rotate to the next file.
//
// Remark: This gets called too early and does not depict when data
// has been actually flushed to disk.
function logged() {
this._size += bytes;
this._pendingSize -= bytes;
debug('logged %s %s', this._size, output);
this.emit('logged', info);
// Do not attempt to rotate files while opening
if (this._opening) {
return;
}
// Check to see if we need to end the stream and create a new one.
if (!this._needsNewFile()) {
return;
}
// End the current stream, ensure it flushes and create a new one.
// This could potentially be optimized to not run a stat call but its
// the safest way since we are supporting `maxFiles`.
this._rotate = true;
this._endStream(() => this._rotateFile());
}
// Keep track of the pending bytes being written while files are opening
// in order to properly rotate the PassThrough this._stream when the file
// eventually does open.
this._pendingSize += bytes;
if (this._opening
&& !this.rotatedWhileOpening
&& this._needsNewFile(this._size + this._pendingSize)) {
this.rotatedWhileOpening = true;
}
const written = this._stream.write(output, logged.bind(this));
if (!written) {
this._drain = true;
this._stream.once('drain', () => {
this._drain = false;
callback();
});
} else {
callback(); // eslint-disable-line callback-return
}
debug('written', written, this._drain);
this.finishIfEnding();
return written;
}
/**
* Query the transport. Options object is optional.
* @param {Object} options - Loggly-like query options for this instance.
* @param {function} callback - Continuation to respond to when complete.
* TODO: Refactor me.
*/
query(options, callback) {
if (typeof options === 'function') {
callback = options;
options = {};
}
options = normalizeQuery(options);
const file = path.join(this.dirname, this.filename);
let buff = '';
let results = [];
let row = 0;
const stream = fs.createReadStream(file, {
encoding: 'utf8'
});
stream.on('error', err => {
if (stream.readable) {
stream.destroy();
}
if (!callback) {
return;
}
return err.code !== 'ENOENT' ? callback(err) : callback(null, results);
});
stream.on('data', data => {
data = (buff + data).split(/\n+/);
const l = data.length - 1;
let i = 0;
for (; i < l; i++) {
if (!options.start || row >= options.start) {
add(data[i]);
}
row++;
}
buff = data[l];
});
stream.on('close', () => {
if (buff) {
add(buff, true);
}
if (options.order === 'desc') {
results = results.reverse();
}
// eslint-disable-next-line callback-return
if (callback) callback(null, results);
});
function add(buff, attempt) {
try {
const log = JSON.parse(buff);
if (check(log)) {
push(log);
}
} catch (e) {
if (!attempt) {
stream.emit('error', e);
}
}
}
function push(log) {
if (
options.rows &&
results.length >= options.rows &&
options.order !== 'desc'
) {
if (stream.readable) {
stream.destroy();
}
return;
}
if (options.fields) {
log = options.fields.reduce((obj, key) => {
obj[key] = log[key];
return obj;
}, {});
}
if (options.order === 'desc') {
if (results.length >= options.rows) {
results.shift();
}
}
results.push(log);
}
function check(log) {
if (!log) {
return;
}
if (typeof log !== 'object') {
return;
}
const time = new Date(log.timestamp);
if (
(options.from && time < options.from) ||
(options.until && time > options.until) ||
(options.level && options.level !== log.level)
) {
return;
}
return true;
}
function normalizeQuery(options) {
options = options || {};
// limit
options.rows = options.rows || options.limit || 10;
// starting row offset
options.start = options.start || 0;
// now
options.until = options.until || new Date();
if (typeof options.until !== 'object') {
options.until = new Date(options.until);
}
// now - 24
options.from = options.from || (options.until - (24 * 60 * 60 * 1000));
if (typeof options.from !== 'object') {
options.from = new Date(options.from);
}
// 'asc' or 'desc'
options.order = options.order || 'desc';
// which fields to select
options.fields = options.fields;
return options;
}
}
/**
* Returns a log stream for this transport. Options object is optional.
* @param {Object} options - Stream options for this instance.
* @returns {Stream} - TODO: add return description.
* TODO: Refactor me.
*/
stream(options = {}) {
const file = path.join(this.dirname, this.filename);
const stream = new Stream();
const tail = {
file,
start: options.start
};
stream.destroy = tailFile(tail, (err, line) => {
if (err) {
return stream.emit('error', err);
}
try {
stream.emit('data', line);
line = JSON.parse(line);
stream.emit('log', line);
} catch (e) {
stream.emit('error', e);
}
});
return stream;
}
/**
* Checks to see the filesize of.
* @returns {undefined}
*/
open() {
// If we do not have a filename then we were passed a stream and
// don't need to keep track of size.
if (!this.filename) return;
if (this._opening) return;
this._opening = true;
// Stat the target file to get the size and create the stream.
this.stat((err, size) => {
if (err) {
return this.emit('error', err);
}
debug('stat done: %s { size: %s }', this.filename, size);
this._size = size;
this._dest = this._createStream(this._stream);
this._opening = false;
this.once('open', () => {
if (this._stream.eventNames().includes('rotate')) {
this._stream.emit('rotate');
} else {
this._rotate = false;
}
});
});
}
/**
* Stat the file and assess information in order to create the proper stream.
* @param {function} callback - TODO: add param description.
* @returns {undefined}
*/
stat(callback) {
const target = this._getFile();
const fullpath = path.join(this.dirname, target);
fs.stat(fullpath, (err, stat) => {
if (err && err.code === 'ENOENT') {
debug('ENOENT ok', fullpath);
// Update internally tracked filename with the new target name.
this.filename = target;
return callback(null, 0);
}
if (err) {
debug(`err ${err.code} ${fullpath}`);
return callback(err);
}
if (!stat || this._needsNewFile(stat.size)) {
// If `stats.size` is greater than the `maxsize` for this
// instance then try again.
return this._incFile(() => this.stat(callback));
}
// Once we have figured out what the filename is, set it
// and return the size.
this.filename = target;
callback(null, stat.size);
});
}
/**
* Closes the stream associated with this instance.
* @param {function} cb - TODO: add param description.
* @returns {undefined}
*/
close(cb) {
if (!this._stream) {
return;
}
this._stream.end(() => {
if (cb) {
cb(); // eslint-disable-line callback-return
}
this.emit('flush');
this.emit('closed');
});
}
/**
* TODO: add method description.
* @param {number} size - TODO: add param description.
* @returns {undefined}
*/
_needsNewFile(size) {
size = size || this._size;
return this.maxsize && size >= this.maxsize;
}
/**
* TODO: add method description.
* @param {Error} err - TODO: add param description.
* @returns {undefined}
*/
_onError(err) {
this.emit('error', err);
}
/**
* TODO: add method description.
* @param {Stream} stream - TODO: add param description.
* @returns {mixed} - TODO: add return description.
*/
_setupStream(stream) {
stream.on('error', this._onError);
return stream;
}
/**
* TODO: add method description.
* @param {Stream} stream - TODO: add param description.
* @returns {mixed} - TODO: add return description.
*/
_cleanupStream(stream) {
stream.removeListener('error', this._onError);
return stream;
}
/**
* TODO: add method description.
*/
_rotateFile() {
this._incFile(() => this.open());
}
/**
* Unpipe from the stream that has been marked as full and end it so it
* flushes to disk.
*
* @param {function} callback - Callback for when the current file has closed.
* @private
*/
_endStream(callback = () => {}) {
if (this._dest) {
this._stream.unpipe(this._dest);
this._dest.end(() => {
this._cleanupStream(this._dest);
callback();
});
} else {
callback(); // eslint-disable-line callback-return
}
}
/**
* Returns the WritableStream for the active file on this instance. If we
* should gzip the file then a zlib stream is returned.
*
* @param {ReadableStream} source – PassThrough to pipe to the file when open.
* @returns {WritableStream} Stream that writes to disk for the active file.
*/
_createStream(source) {
const fullpath = path.join(this.dirname, this.filename);
debug('create stream start', fullpath, this.options);
const dest = fs.createWriteStream(fullpath, this.options)
// TODO: What should we do with errors here?
.on('error', err => debug(err))
.on('close', () => debug('close', dest.path, dest.bytesWritten))
.on('open', () => {
debug('file open ok', fullpath);
this.emit('open', fullpath);
source.pipe(dest);
// If rotation occured during the open operation then we immediately
// start writing to a new PassThrough, begin opening the next file
// and cleanup the previous source and dest once the source has drained.
if (this.rotatedWhileOpening) {
this._stream = new PassThrough();
this._stream.setMaxListeners(30);
this._rotateFile();
this.rotatedWhileOpening = false;
this._cleanupStream(dest);
source.end();
}
});
debug('create stream ok', fullpath);
if (this.zippedArchive) {
const gzip = zlib.createGzip();
gzip.pipe(dest);
return gzip;
}
return dest;
}
/**
* TODO: add method description.
* @param {function} callback - TODO: add param description.
* @returns {undefined}
*/
_incFile(callback) {
debug('_incFile', this.filename);
const ext = path.extname(this._basename);
const basename = path.basename(this._basename, ext);
if (!this.tailable) {
this._created += 1;
this._checkMaxFilesIncrementing(ext, basename, callback);
} else {
this._checkMaxFilesTailable(ext, basename, callback);
}
}
/**
* Gets the next filename to use for this instance in the case that log
* filesizes are being capped.
* @returns {string} - TODO: add return description.
* @private
*/
_getFile() {
const ext = path.extname(this._basename);
const basename = path.basename(this._basename, ext);
const isRotation = this.rotationFormat
? this.rotationFormat()
: this._created;
// Caveat emptor (indexzero): rotationFormat() was broken by design When
// combined with max files because the set of files to unlink is never
// stored.
const target = !this.tailable && this._created
? `${basename}${isRotation}${ext}`
: `${basename}${ext}`;
return this.zippedArchive && !this.tailable
? `${target}.gz`
: target;
}
/**
* Increment the number of files created or checked by this instance.
* @param {mixed} ext - TODO: add param description.
* @param {mixed} basename - TODO: add param description.
* @param {mixed} callback - TODO: add param description.
* @returns {undefined}
* @private
*/
_checkMaxFilesIncrementing(ext, basename, callback) {
// Check for maxFiles option and delete file.
if (!this.maxFiles || this._created < this.maxFiles) {
return setImmediate(callback);
}
const oldest = this._created - this.maxFiles;
const isOldest = oldest !== 0 ? oldest : '';
const isZipped = this.zippedArchive ? '.gz' : '';
const filePath = `${basename}${isOldest}${ext}${isZipped}`;
const target = path.join(this.dirname, filePath);
fs.unlink(target, callback);
}
/**
* Roll files forward based on integer, up to maxFiles. e.g. if base if
* file.log and it becomes oversized, roll to file1.log, and allow file.log
* to be re-used. If file is oversized again, roll file1.log to file2.log,
* roll file.log to file1.log, and so on.
* @param {mixed} ext - TODO: add param description.
* @param {mixed} basename - TODO: add param description.
* @param {mixed} callback - TODO: add param description.
* @returns {undefined}
* @private
*/
_checkMaxFilesTailable(ext, basename, callback) {
const tasks = [];
if (!this.maxFiles) {
return;
}
// const isZipped = this.zippedArchive ? '.gz' : '';
const isZipped = this.zippedArchive ? '.gz' : '';
for (let x = this.maxFiles - 1; x > 1; x--) {
tasks.push(function (i, cb) {
let fileName = `${basename}${(i - 1)}${ext}${isZipped}`;
const tmppath = path.join(this.dirname, fileName);
fs.exists(tmppath, exists => {
if (!exists) {
return cb(null);
}
fileName = `${basename}${i}${ext}${isZipped}`;
fs.rename(tmppath, path.join(this.dirname, fileName), cb);
});
}.bind(this, x));
}
asyncSeries(tasks, () => {
fs.rename(
path.join(this.dirname, `${basename}${ext}`),
path.join(this.dirname, `${basename}1${ext}${isZipped}`),
callback
);
});
}
_createLogDirIfNotExist(dirPath) {
/* eslint-disable no-sync */
if (!fs.existsSync(dirPath)) {
fs.mkdirSync(dirPath, { recursive: true });
}
/* eslint-enable no-sync */
}
};

196
node_modules/winston/lib/winston/transports/http.js generated vendored Normal file
View File

@ -0,0 +1,196 @@
/**
* http.js: Transport for outputting to a json-rpcserver.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
const http = require('http');
const https = require('https');
const { Stream } = require('readable-stream');
const TransportStream = require('winston-transport');
/**
* Transport for outputting to a json-rpc server.
* @type {Stream}
* @extends {TransportStream}
*/
module.exports = class Http extends TransportStream {
/**
* Constructor function for the Http transport object responsible for
* persisting log messages and metadata to a terminal or TTY.
* @param {!Object} [options={}] - Options for this instance.
*/
constructor(options = {}) {
super(options);
this.name = options.name || 'http';
this.ssl = !!options.ssl;
this.host = options.host || 'localhost';
this.port = options.port;
this.auth = options.auth;
this.path = options.path || '';
this.agent = options.agent;
this.headers = options.headers || {};
this.headers['content-type'] = 'application/json';
if (!this.port) {
this.port = this.ssl ? 443 : 80;
}
}
/**
* Core logging method exposed to Winston.
* @param {Object} info - TODO: add param description.
* @param {function} callback - TODO: add param description.
* @returns {undefined}
*/
log(info, callback) {
this._request(info, (err, res) => {
if (res && res.statusCode !== 200) {
err = new Error(`Invalid HTTP Status Code: ${res.statusCode}`);
}
if (err) {
this.emit('warn', err);
} else {
this.emit('logged', info);
}
});
// Remark: (jcrugzz) Fire and forget here so requests dont cause buffering
// and block more requests from happening?
if (callback) {
setImmediate(callback);
}
}
/**
* Query the transport. Options object is optional.
* @param {Object} options - Loggly-like query options for this instance.
* @param {function} callback - Continuation to respond to when complete.
* @returns {undefined}
*/
query(options, callback) {
if (typeof options === 'function') {
callback = options;
options = {};
}
options = {
method: 'query',
params: this.normalizeQuery(options)
};
if (options.params.path) {
options.path = options.params.path;
delete options.params.path;
}
if (options.params.auth) {
options.auth = options.params.auth;
delete options.params.auth;
}
this._request(options, (err, res, body) => {
if (res && res.statusCode !== 200) {
err = new Error(`Invalid HTTP Status Code: ${res.statusCode}`);
}
if (err) {
return callback(err);
}
if (typeof body === 'string') {
try {
body = JSON.parse(body);
} catch (e) {
return callback(e);
}
}
callback(null, body);
});
}
/**
* Returns a log stream for this transport. Options object is optional.
* @param {Object} options - Stream options for this instance.
* @returns {Stream} - TODO: add return description
*/
stream(options = {}) {
const stream = new Stream();
options = {
method: 'stream',
params: options
};
if (options.params.path) {
options.path = options.params.path;
delete options.params.path;
}
if (options.params.auth) {
options.auth = options.params.auth;
delete options.params.auth;
}
let buff = '';
const req = this._request(options);
stream.destroy = () => req.destroy();
req.on('data', data => {
data = (buff + data).split(/\n+/);
const l = data.length - 1;
let i = 0;
for (; i < l; i++) {
try {
stream.emit('log', JSON.parse(data[i]));
} catch (e) {
stream.emit('error', e);
}
}
buff = data[l];
});
req.on('error', err => stream.emit('error', err));
return stream;
}
/**
* Make a request to a winstond server or any http server which can
* handle json-rpc.
* @param {function} options - Options to sent the request.
* @param {function} callback - Continuation to respond to when complete.
*/
_request(options, callback) {
options = options || {};
const auth = options.auth || this.auth;
const path = options.path || this.path || '';
delete options.auth;
delete options.path;
// Prepare options for outgoing HTTP request
const req = (this.ssl ? https : http).request({
method: 'POST',
host: this.host,
port: this.port,
path: `/${path.replace(/^\//, '')}`,
headers: this.headers,
auth: auth ? (`${auth.username}:${auth.password}`) : '',
agent: this.agent
});
req.on('error', callback);
req.on('response', res => (
res.on('end', () => callback(null, res)).resume()
));
req.end(Buffer.from(JSON.stringify(options), 'utf8'));
}
};

100
node_modules/winston/lib/winston/transports/index.d.ts generated vendored Normal file
View File

@ -0,0 +1,100 @@
// Type definitions for winston 3.0
// Project: https://github.com/winstonjs/winston
/// <reference types="node" />
import {Agent} from "http";
import * as Transport from 'winston-transport';
declare namespace winston {
interface ConsoleTransportOptions extends Transport.TransportStreamOptions {
consoleWarnLevels?: string[],
stderrLevels?: string[];
debugStdout?: boolean;
eol?: string;
}
interface ConsoleTransportInstance extends Transport {
name: string;
stderrLevels: string[];
eol: string;
new(options?: ConsoleTransportOptions): ConsoleTransportInstance;
}
interface FileTransportOptions extends Transport.TransportStreamOptions {
filename?: string;
dirname?: string;
options?: object;
maxsize?: number;
stream?: NodeJS.WritableStream;
rotationFormat?: Function;
zippedArchive?: boolean;
maxFiles?: number;
eol?: string;
tailable?: boolean;
}
interface FileTransportInstance extends Transport {
name: string;
filename: string;
dirname: string;
options: object;
maxsize: number | null;
rotationFormat: Function | boolean;
zippedArchive: boolean;
maxFiles: number | null;
eol: string;
tailable: boolean;
new(options?: FileTransportOptions): FileTransportInstance;
}
interface HttpTransportOptions extends Transport.TransportStreamOptions {
ssl?: any;
host?: string;
port?: number;
auth?: { username: string; password: string; };
path?: string;
agent?: Agent;
headers?: object;
}
interface HttpTransportInstance extends Transport {
name: string;
ssl: boolean;
host: string;
port: number;
auth?: { username: string, password: string };
path: string;
agent?: Agent | null;
new(options?: HttpTransportOptions): HttpTransportInstance;
}
interface StreamTransportOptions extends Transport.TransportStreamOptions {
stream: NodeJS.WritableStream;
eol?: string;
}
interface StreamTransportInstance extends Transport {
eol: string;
new(options?: StreamTransportOptions): StreamTransportInstance;
}
interface Transports {
FileTransportOptions: FileTransportOptions;
File: FileTransportInstance;
ConsoleTransportOptions: ConsoleTransportOptions;
Console: ConsoleTransportInstance;
HttpTransportOptions: HttpTransportOptions;
Http: HttpTransportInstance;
StreamTransportOptions: StreamTransportOptions;
Stream: StreamTransportInstance;
}
}
declare const winston: winston.Transports;
export = winston;

56
node_modules/winston/lib/winston/transports/index.js generated vendored Normal file
View File

@ -0,0 +1,56 @@
/**
* transports.js: Set of all transports Winston knows about.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
/**
* TODO: add property description.
* @type {Console}
*/
Object.defineProperty(exports, 'Console', {
configurable: true,
enumerable: true,
get() {
return require('./console');
}
});
/**
* TODO: add property description.
* @type {File}
*/
Object.defineProperty(exports, 'File', {
configurable: true,
enumerable: true,
get() {
return require('./file');
}
});
/**
* TODO: add property description.
* @type {Http}
*/
Object.defineProperty(exports, 'Http', {
configurable: true,
enumerable: true,
get() {
return require('./http');
}
});
/**
* TODO: add property description.
* @type {Stream}
*/
Object.defineProperty(exports, 'Stream', {
configurable: true,
enumerable: true,
get() {
return require('./stream');
}
});

63
node_modules/winston/lib/winston/transports/stream.js generated vendored Normal file
View File

@ -0,0 +1,63 @@
/**
* stream.js: Transport for outputting to any arbitrary stream.
*
* (C) 2010 Charlie Robbins
* MIT LICENCE
*/
'use strict';
const isStream = require('is-stream');
const { MESSAGE } = require('triple-beam');
const os = require('os');
const TransportStream = require('winston-transport');
/**
* Transport for outputting to any arbitrary stream.
* @type {Stream}
* @extends {TransportStream}
*/
module.exports = class Stream extends TransportStream {
/**
* Constructor function for the Console transport object responsible for
* persisting log messages and metadata to a terminal or TTY.
* @param {!Object} [options={}] - Options for this instance.
*/
constructor(options = {}) {
super(options);
if (!options.stream || !isStream(options.stream)) {
throw new Error('options.stream is required.');
}
// We need to listen for drain events when write() returns false. This can
// make node mad at times.
this._stream = options.stream;
this._stream.setMaxListeners(Infinity);
this.isObjectMode = options.stream._writableState.objectMode;
this.eol = options.eol || os.EOL;
}
/**
* Core logging method exposed to Winston.
* @param {Object} info - TODO: add param description.
* @param {Function} callback - TODO: add param description.
* @returns {undefined}
*/
log(info, callback) {
setImmediate(() => this.emit('logged', info));
if (this.isObjectMode) {
this._stream.write(info);
if (callback) {
callback(); // eslint-disable-line callback-return
}
return;
}
this._stream.write(`${info[MESSAGE]}${this.eol}`);
if (callback) {
callback(); // eslint-disable-line callback-return
}
return;
}
};

115
node_modules/winston/package.json generated vendored Normal file
View File

@ -0,0 +1,115 @@
{
"_from": "winston",
"_id": "winston@3.2.1",
"_inBundle": false,
"_integrity": "sha512-zU6vgnS9dAWCEKg/QYigd6cgMVVNwyTzKs81XZtTFuRwJOcDdBg7AU0mXVyNbs7O5RH2zdv+BdNZUlx7mXPuOw==",
"_location": "/winston",
"_phantomChildren": {},
"_requested": {
"type": "tag",
"registry": true,
"raw": "winston",
"name": "winston",
"escapedName": "winston",
"rawSpec": "",
"saveSpec": null,
"fetchSpec": "latest"
},
"_requiredBy": [
"#USER",
"/"
],
"_resolved": "https://registry.npmjs.org/winston/-/winston-3.2.1.tgz",
"_shasum": "63061377976c73584028be2490a1846055f77f07",
"_spec": "winston",
"_where": "/Users/josh.burman/Projects/braid",
"author": {
"name": "Charlie Robbins",
"email": "charlie.robbins@gmail.com"
},
"browser": "./dist/winston",
"bugs": {
"url": "https://github.com/winstonjs/winston/issues"
},
"bundleDependencies": false,
"dependencies": {
"async": "^2.6.1",
"diagnostics": "^1.1.1",
"is-stream": "^1.1.0",
"logform": "^2.1.1",
"one-time": "0.0.4",
"readable-stream": "^3.1.1",
"stack-trace": "0.0.x",
"triple-beam": "^1.3.0",
"winston-transport": "^4.3.0"
},
"deprecated": false,
"description": "A logger for just about everything.",
"devDependencies": {
"@babel/cli": "^7.2.3",
"@babel/core": "^7.2.2",
"@babel/preset-env": "^7.3.1",
"@types/node": "^10.12.19",
"abstract-winston-transport": ">= 0.5.1",
"assume": "^2.1.0",
"colors": "^1.3.3",
"cross-spawn-async": "^2.2.5",
"eslint-config-populist": "^4.2.0",
"hock": "^1.3.3",
"mocha": "^5.2.0",
"nyc": "^13.1.0",
"rimraf": "^2.6.3",
"split2": "^3.1.0",
"std-mocks": "^1.0.1",
"through2": "^3.0.0",
"winston-compat": "^0.1.4"
},
"engines": {
"node": ">= 6.4.0"
},
"homepage": "https://github.com/winstonjs/winston#readme",
"keywords": [
"winston",
"logger",
"logging",
"logs",
"sysadmin",
"bunyan",
"pino",
"loglevel",
"tools",
"json",
"stream"
],
"license": "MIT",
"main": "./lib/winston",
"maintainers": [
{
"name": "Jarrett Cruger",
"email": "jcrugzz@gmail.com"
},
{
"name": "Chris Alderson",
"email": "chrisalderson@protonmail.com"
},
{
"name": "David Hyde",
"email": "dabh@stanford.edu"
}
],
"name": "winston",
"repository": {
"type": "git",
"url": "git+https://github.com/winstonjs/winston.git"
},
"scripts": {
"build": "rimraf dist && babel lib -d dist",
"lint": "populist lib/*.js lib/winston/*.js lib/winston/**/*.js",
"prepublishOnly": "npm run build",
"pretest": "npm run lint",
"test": "nyc --reporter=text --reporter lcov npm run test:mocha",
"test:mocha": "mocha test/*.test.js test/**/*.test.js --exit"
},
"types": "./index.d.ts",
"version": "3.2.1"
}

153
node_modules/winston/test/transports/00-file-stress.test.js generated vendored Normal file
View File

@ -0,0 +1,153 @@
'use strict';
/*
* file-stress.test.js: Tests for stressing File transport: volume, ambient event loop lag.
*
* (C) 2016 Charlie Robbins
* MIT LICENSE
*
*/
const fs = require('fs');
const os = require('os');
const path = require('path');
const assume = require('assume');
const helpers = require('../helpers');
const split = require('split2');
const winston = require('../../lib/winston');
describe('File (stress)', function () {
this.timeout(30 * 1000);
const logPath = path.resolve(__dirname, '../fixtures/logs/file-stress-test.log');
beforeEach(function () {
try {
fs.unlinkSync(logPath);
} catch (ex) {
if (ex && ex.code !== 'ENOENT') { return done(ex); }
}
});
it('should handle a high volume of writes', function (done) {
const logger = winston.createLogger({
transports: [new winston.transports.File({
filename: logPath
})]
});
const counters = {
write: 0,
read: 0
};
const interval = setInterval(function () {
logger.info(++counters.write);
}, 0);
setTimeout(function () {
clearInterval(interval);
helpers.tryRead(logPath)
.on('error', function (err) {
assume(err).false();
logger.close();
done();
})
.pipe(split())
.on('data', function (d) {
const json = JSON.parse(d);
assume(json.level).equal('info');
assume(json.message).equal(++counters.read);
})
.on('end', function () {
assume(counters.write).equal(counters.read);
logger.close();
done();
});
}, 10000);
});
it('should handle a high volume of large writes', function (done) {
const logger = winston.createLogger({
transports: [new winston.transports.File({
filename: logPath
})]
});
const counters = {
write: 0,
read: 0
};
const interval = setInterval(function () {
const msg = {
counter: ++counters.write,
message: 'a'.repeat(16384 - os.EOL.length - 1)
};
logger.info(msg);
}, 0);
setTimeout(function () {
clearInterval(interval);
helpers.tryRead(logPath)
.on('error', function (err) {
assume(err).false();
logger.close();
done();
})
.pipe(split())
.on('data', function (d) {
const json = JSON.parse(d);
assume(json.level).equal('info');
assume(json.message).equal('a'.repeat(16384 - os.EOL.length - 1));
assume(json.counter).equal(++counters.read);
})
.on('end', function () {
assume(counters.write).equal(counters.read);
logger.close();
done();
});
}, 10000);
});
it('should handle a high volume of large writes synchronous', function (done) {
const logger = winston.createLogger({
transports: [new winston.transports.File({
filename: logPath
})]
});
const counters = {
write: 0,
read: 0
};
const msgs = new Array(10).fill().map(() => ({
counter: ++counters.write,
message: 'a'.repeat(16384 - os.EOL.length - 1)
}));
msgs.forEach(msg => logger.info(msg));
setTimeout(function () {
helpers.tryRead(logPath)
.on('error', function (err) {
assume(err).false();
logger.close();
done();
})
.pipe(split())
.on('data', function (d) {
const json = JSON.parse(d);
assume(json.level).equal('info');
assume(json.message).equal('a'.repeat(16384 - os.EOL.length - 1));
assume(json.counter).equal(++counters.read);
})
.on('end', function () {
assume(counters.write).equal(counters.read);
logger.close();
done();
});
}, 10000);
});
});

121
node_modules/winston/test/transports/01-file-maxsize.test.js generated vendored Normal file
View File

@ -0,0 +1,121 @@
/*
* file-test.js: Tests for instances of the File transport
*
* (C) 2010 Charlie Robbins
* MIT LICENSE
*
*/
const rimraf = require('rimraf');
const fs = require('fs');
const path = require('path');
const assume = require('assume');
const winston = require('../../');
const MESSAGE = Symbol.for('message');
//
// Remove all log fixtures
//
function removeFixtures(done) {
rimraf(path.join(__dirname, '..', 'fixtures', 'logs', 'testmaxsize*'), done);
}
describe('File (maxsize)', function () {
this.timeout(10000);
let testDone = false;
before(removeFixtures);
after(done => {
testDone = true;
removeFixtures(done);
});
it('should create multiple files correctly when passed more than the maxsize', function (done) {
const fillWith = ['a', 'b', 'c', 'd', 'e'];
const maxsizeTransport = new winston.transports.File({
level: 'info',
format: winston.format.printf(info => info.message),
filename: path.join(__dirname, '..', 'fixtures', 'logs', 'testmaxsize.log'),
maxsize: 4096
})
//
// Have to wait for `fs.stats` to be done in `maxsizeTransport.open()`.
// Otherwise the maxsizeTransport._dest is undefined. See https://github.com/winstonjs/winston/issues/1174
//
setTimeout(() => logKbytes(4), 100);
//
// Setup a list of files which we will later stat.
//
const files = [];
//
// Assets all the files have been created with the
// correct filesize
//
function assumeFilesCreated() {
files.map(function (file, i) {
let stats;
try {
stats = fs.statSync(file);
} catch (ex) {
assume(stats).is.an('object', `${file} failed to open: ${ex.message}`);
}
const text = fs.readFileSync(file, 'utf8');
assume(text[0]).equals(fillWith[i]);
// Either 4096 on Unix or 4100 on Windows
// because of the eol.
if (process.platform === 'win32') {
assume(stats.size).equals(4100);
} else {
assume(stats.size).equals(4096);
}
});
done();
}
//
// Log the specified kbytes to the transport
//
function logKbytes(kbytes) {
//
// Shift the next fill char off the array then push it back
// to rotate the chars.
//
const filler = fillWith.shift();
fillWith.push(filler);
//
//
// To not make each file not fail the assertion of the filesize we can
// make the array 1023 characters long.
//
const kbStr = Array(1023).fill(filler).join('');
//
// With printf format that displays the message only
// winston adds exactly 0 characters.
//
for (var i = 0; i < kbytes; i++) {
maxsizeTransport.log({ level: 'info', [MESSAGE]: kbStr });
}
}
maxsizeTransport.on('open', function (file) {
if (testDone) return; // ignore future notifications
const match = file.match(/(\d+)\.log$/);
const count = match ? match[1] : 0;
if (files.length === 5) {
return assumeFilesCreated();
}
files.push(file);
setImmediate(() => logKbytes(4));
});
});
});

188
node_modules/winston/test/transports/console.test.js generated vendored Normal file
View File

@ -0,0 +1,188 @@
'use strict';
/*
* console-test.js: Tests for instances of the Console transport
*
* (C) 2010 Charlie Robbins
* MIT LICENSE
*
*/
const path = require('path');
const assume = require('assume');
const { LEVEL, MESSAGE } = require('triple-beam');
const winston = require('../../lib/winston');
const helpers = require('../helpers');
const stdMocks = require('std-mocks');
const defaultLevels = winston.config.npm.levels;
const transports = {
defaults: new winston.transports.Console(),
noStderr: new winston.transports.Console({ stderrLevels: [] }),
stderrLevels: new winston.transports.Console({
stderrLevels: ['info', 'error']
}),
consoleWarnLevels: new winston.transports.Console({
consoleWarnLevels: ['warn', 'debug']
}),
eol: new winston.transports.Console({ eol: 'X' }),
syslog: new winston.transports.Console({
levels: winston.config.syslog.levels
}),
customLevelStderr: new winston.transports.Console({
levels: {
alpha: 0,
beta: 1,
gamma: 2,
delta: 3,
epsilon: 4,
},
stderrLevels: ['delta', 'epsilon']
})
};
/**
* Returns a function that asserts the `transport` has the specified
* logLevels values in the appropriate logLevelsName member.
*
* @param {TransportStream} transport Transport to assert against
* @param {Array} logLevels Set of levels assumed to exist for the specified map
* @param {String} logLevelsName The name of the array/map that holdes the log leveles values (ie: 'stderrLevels', 'consoleWarnLevels')
* @return {function} Assertion function to execute comparison
*/
function assertLogLevelsValues(transport, logLevels, logLevelsName = 'stderrLevels') {
return function () {
assume(JSON.stringify(Object.keys(transport[logLevelsName]).sort()))
.equals(JSON.stringify(logLevels.sort()));
};
}
describe('Console transport', function () {
describe('with defaults', function () {
it('logs all levels to stdout', function () {
stdMocks.use();
transports.defaults.levels = defaultLevels;
Object.keys(defaultLevels)
.forEach(function (level) {
const info = {
[LEVEL]: level,
message: `This is level ${level}`,
level
};
info[MESSAGE] = JSON.stringify(info);
transports.defaults.log(info);
});
stdMocks.restore();
var output = stdMocks.flush();
assume(output.stderr).is.an('array');
assume(output.stderr).length(0);
assume(output.stdout).is.an('array');
assume(output.stdout).length(7);
});
it("should set stderrLevels to [] by default", assertLogLevelsValues(
transports.defaults,
[],
'stderrLevels'
));
});
describe('throws an appropriate error when', function () {
it("if stderrLevels is set, but not an Array { stderrLevels: 'Not an Array' }", function () {
assume(function () {
let throwing = new winston.transports.Console({
stderrLevels: 'Not an Array'
})
}).throws(/Cannot make set from type other than Array of string elements/);
});
it("if stderrLevels contains non-string elements { stderrLevels: ['good', /^invalid$/, 'valid']", function () {
assume(function () {
let throwing = new winston.transports.Console({
stderrLevels: ['good', /^invalid$/, 'valid']
})
}).throws(/Cannot make set from type other than Array of string elements/);
});
});
it("{ stderrLevels: ['info', 'error'] } logs to them appropriately", assertLogLevelsValues(
transports.stderrLevels,
['info', 'error'],
'stderrLevels'
));
it("{ consoleWarnLevels: ['warn', 'debug'] } logs to them appropriately", assertLogLevelsValues(
transports.consoleWarnLevels,
['warn', 'debug'],
'consoleWarnLevels'
));
it('{ eol } adds a custom EOL delimiter', function (done) {
stdMocks.use();
transports.eol.log({ [MESSAGE]: 'info: testing. 1 2 3...' }, function () {
stdMocks.restore();
var output = stdMocks.flush(),
line = output.stdout[0];
assume(line).equal('info: testing. 1 2 3...X');
done();
});
});
});
require('abstract-winston-transport')({
name: 'Console',
Transport: winston.transports.Console
});
// vows.describe('winston/transports/console').addBatch({
// "An instance of the Console Transport": {
// "with syslog levels": {
// "should have the proper methods defined": function () {
// helpers.assertConsole(syslogTransport);
// },
// "the log() method": helpers.testSyslogLevels(syslogTransport, "should respond with true", function (ign, err, logged) {
// assert.isNull(err);
// assert.isTrue(logged);
// })
// }
// }
// }).addBatch({
// "An instance of the Console Transport with no options": {
// "should log only 'error' and 'debug' to stderr": helpers.testLoggingToStreams(
// winston.config.npm.levels, defaultTransport, ['debug', 'error'], stdMocks
// )
// }
// }).addBatch({
// "An instance of the Console Transport with debugStdout set": {
// "should set stderrLevels to 'error' by default": helpers.assertStderrLevels(
// debugStdoutTransport,
// ['error']
// ),
// "should log only the 'error' level to stderr": helpers.testLoggingToStreams(
// winston.config.npm.levels, debugStdoutTransport, ['error'], stdMocks
// )
// }
// }).addBatch({
// "An instance of the Console Transport with stderrLevels set": {
// "should log only the levels in stderrLevels to stderr": helpers.testLoggingToStreams(
// winston.config.npm.levels, stderrLevelsTransport, ['info', 'warn'], stdMocks
// )
// }
// }).addBatch({
// "An instance of the Console Transport with stderrLevels set to an empty array": {
// "should log only to stdout, and not to stderr": helpers.testLoggingToStreams(
// winston.config.npm.levels, noStderrTransport, [], stdMocks
// )
// }
// }).addBatch({
// "An instance of the Console Transport with custom levels and stderrLevels set": {
// "should log only the levels in stderrLevels to stderr": helpers.testLoggingToStreams(
// customLevels, customLevelsAndStderrTransport, ['delta', 'epsilon'], stdMocks
// )
// }
// }).export(module);

93
node_modules/winston/test/transports/file-archive.test.js generated vendored Normal file
View File

@ -0,0 +1,93 @@
/*
* file-archive-test.js: Tests for instances of the File transport setting the archive option,
*
* (C) 2015 Nimrod Becker
* MIT LICENSE
*
*/
/* eslint-disable no-sync */
const assert = require('assert');
const rimraf = require('rimraf');
const fs = require('fs');
const path = require('path');
const winston = require('../../lib/winston');
const { MESSAGE } = require('triple-beam');
//
// Remove all log fixtures
//
function removeFixtures(done) {
rimraf(path.join(__dirname, '..', 'fixtures', 'logs', 'testarchive*'), done);
}
let archiveTransport = null;
describe('winston/transports/file/zippedArchive', function () {
describe('An instance of the File Transport with tailable true', function () {
before(removeFixtures);
after(removeFixtures);
it('init logger AFTER cleaning up old files', function () {
archiveTransport = new winston.transports.File({
timestamp: true,
json: false,
zippedArchive: true,
tailable: true,
filename: 'testarchive.log',
dirname: path.join(__dirname, '..', 'fixtures', 'logs'),
maxsize: 4096,
maxFiles: 3
});
});
it('when created archived files are rolled', function (done) {
let created = 0;
let loggedTotal = 0;
function data(ch, kb) {
return String.fromCharCode(65 + ch).repeat(kb * 1024 - 1);
}
function logKbytes(kbytes, txt) {
const toLog = {};
toLog[MESSAGE] = data(txt, kbytes);
archiveTransport.log(toLog);
}
archiveTransport.on('logged', function (info) {
loggedTotal += info[MESSAGE].length + 1;
if (loggedTotal >= 14 * 1024) { // just over 3 x 4kb files
return done();
}
if (loggedTotal % 4096 === 0) {
created++;
}
// eslint-disable-next-line max-nested-callbacks
setTimeout(() => logKbytes(1, created), 1);
});
logKbytes(1, created);
});
it('should be only 3 files called testarchive.log, testarchive1.log.gz and testarchive2.log.gz', function () {
for (var num = 0; num < 4; num++) {
const file = !num ? 'testarchive.log' : 'testarchive' + num + '.log.gz';
const fullpath = path.join(__dirname, '..', 'fixtures', 'logs', file);
if (num === 3) {
return assert.throws(function () {
fs.statSync(fullpath);
}, Error);
}
assert.doesNotThrow(function () {
fs.statSync(fullpath);
}, Error);
}
});
});
});

43
node_modules/winston/test/transports/file-create-dir-test.js generated vendored Normal file
View File

@ -0,0 +1,43 @@
'use strict';
const fs = require('fs');
const assert = require('assert');
const path = require('path');
const winston = require('../../lib/winston');
/* eslint-disable no-sync */
describe('winston/transports/file/createLogDir', function () {
const logDir = path.resolve(__dirname, '../fixtures/temp_logs');
beforeEach(function () {
fs.rmdirSync(logDir);
});
it('should create directory if it does not exist', function () {
winston.createLogger({
transports: [
new winston.transports.File({
filename: path.join(logDir, 'file.log')
})
]
});
assert(fs.existsSync(logDir));
});
it('should create directory if it does not exist when write to the stream', function () {
const streamfile = path.join(logDir, 'simple-stream.log');
const stream = fs.createWriteStream(streamfile);
winston.createLogger({
transports: [
new winston.transports.File({
stream: stream
})
]
});
assert(fs.existsSync(logDir));
});
});

99
node_modules/winston/test/transports/file-maxfiles-test.js generated vendored Normal file
View File

@ -0,0 +1,99 @@
/*
* file-maxfiles-test.js: Tests for instances of the File transport setting the max file size,
* and setting a number for max files created.
* maxSize * maxFiles = total storage used by winston.
*
* (C) 2011 Daniel Aristizabal
* MIT LICENSE
*
*/
var assert = require('assert'),
exec = require('child_process').exec,
fs = require('fs'),
path = require('path'),
vows = require('vows'),
winston = require('../../lib/winston'),
helpers = require('../helpers');
var maxfilesTransport = new winston.transports.File({
timestamp: false,
json: false,
filename: path.join(__dirname, '..', 'fixtures', 'logs', 'testmaxfiles.log'),
maxsize: 4096,
maxFiles: 3
});
vows.describe('winston/transports/file/maxfiles').addBatch({
"An instance of the File Transport": {
"when passed a valid filename": {
topic: maxfilesTransport,
"should set the maxFiles option correctly": function (transportTest) {
assert.isNumber(transportTest.maxFiles);
}
},
"when delete old test files": {
topic: function () {
exec('rm -rf ' + path.join(__dirname, '..', 'fixtures', 'logs', 'testmaxfiles*'), this.callback);
},
"and when passed more files than the maxFiles": {
topic: function () {
var that = this,
created = 0;
function data(ch) {
return new Array(1018).join(String.fromCharCode(65 + ch));
};
function logKbytes(kbytes, txt) {
//
// With no timestamp and at the info level,
// winston adds exactly 7 characters:
// [info](4)[ :](2)[\n](1)
//
for (var i = 0; i < kbytes; i++) {
maxfilesTransport.log('info', data(txt), null, function () { });
}
}
maxfilesTransport.on('logged', function () {
if (++created === 6) {
return that.callback();
}
logKbytes(4, created);
});
logKbytes(4, created);
},
"should be only 3 files called 5.log, 4.log and 3.log": function () {
for (var num = 0; num < 6; num++) {
var file = !num ? 'testmaxfiles.log' : 'testmaxfiles' + num + '.log',
fullpath = path.join(__dirname, '..', 'fixtures', 'logs', file);
// There should be no files with that name
if (num >= 0 && num < 3) {
assert.throws(function () {
fs.statSync(fullpath);
}, Error);
} else {
// The other files should be exist
assert.doesNotThrow(function () {
fs.statSync(fullpath);
}, Error);
}
}
},
"should have the correct content": function () {
['D', 'E', 'F'].forEach(function (name, inx) {
var counter = inx + 3,
logsDir = path.join(__dirname, '..', 'fixtures', 'logs'),
content = fs.readFileSync(path.join(logsDir, 'testmaxfiles' + counter + '.log'), 'utf-8');
// The content minus the 7 characters added by winston
assert.lengthOf(content.match(new RegExp(name, 'g')), 4068);
});
}
}
}
}
}).export(module);

93
node_modules/winston/test/transports/file-tailrolling.test.js generated vendored Normal file
View File

@ -0,0 +1,93 @@
/* eslint-disable no-sync */
const assert = require('assert');
const rimraf = require('rimraf');
const fs = require('fs');
const path = require('path');
const winston = require('../../lib/winston');
const { MESSAGE } = require('triple-beam');
//
// Remove all log fixtures
//
function removeFixtures(done) {
rimraf(path.join(__dirname, '..', 'fixtures', 'logs', 'testtailrollingfiles*'), done);
}
let tailrollTransport = null;
describe('winston/transports/file/tailrolling', function () {
describe('An instance of the File Transport', function () {
before(removeFixtures);
after(removeFixtures);
it('init logger AFTER cleaning up old files', function () {
tailrollTransport = new winston.transports.File({
timestamp: false,
json: false,
filename: path.join(__dirname, '..', 'fixtures', 'logs', 'testtailrollingfiles.log'),
maxsize: 4096,
maxFiles: 3,
tailable: true
})
.on('open', console.log); // eslint-disable-line no-console
});
it('and when passed more files than the maxFiles', function (done) {
let created = 0;
let loggedTotal = 0;
function data(ch, kb) {
return String.fromCharCode(65 + ch).repeat(kb * 1024 - 1);
}
function logKbytes(kbytes, txt) {
const toLog = {};
toLog[MESSAGE] = data(txt, kbytes);
tailrollTransport.log(toLog);
}
tailrollTransport.on('logged', function (info) {
loggedTotal += info[MESSAGE].length + 1;
if (loggedTotal >= 14 * 1024) { // just over 3 x 4kb files
return done();
}
if (loggedTotal % 4096 === 0) {
created++;
}
// eslint-disable-next-line max-nested-callbacks
setTimeout(() => logKbytes(1, created), 1);
});
logKbytes(1, created);
});
it('should be 3 log files, base to maxFiles - 1', function () {
for (var num = 0; num < 4; num++) {
const file = !num ? 'testtailrollingfiles.log' : 'testtailrollingfiles' + num + '.log';
const fullpath = path.join(__dirname, '..', 'fixtures', 'logs', file);
if (num === 3) {
return assert.ok(!fs.existsSync(fullpath));
}
assert.ok(fs.existsSync(fullpath));
}
return false;
});
it('should have files in correct order', function () {
['D', 'C', 'B'].forEach(function (letter, i) {
const file = !i ? 'testtailrollingfiles.log' : 'testtailrollingfiles' + i + '.log';
let content = fs.readFileSync(path.join(__dirname, '..', 'fixtures', 'logs', file), 'ascii');
content = content.replace(/\s+/g, '');
assert(content.match(new RegExp(letter, 'g'))[0].length, content.length);
});
});
});
});

122
node_modules/winston/test/transports/file.test.js generated vendored Normal file
View File

@ -0,0 +1,122 @@
'use strict';
const path = require('path');
const winston = require('../../');
const helpers = require('../helpers');
const fs = require('fs');
const { MESSAGE } = require('triple-beam');
const split = require('split2');
const assume = require('assume');
function noop() {};
describe('File({ filename })', function () {
this.timeout(10 * 1000);
it('should write to the file when logged to with expected object', function (done) {
var filename = path.join(__dirname, '..', 'fixtures', 'file', 'simple.log');
var transport = new winston.transports.File({
filename: filename
});
var info = { [MESSAGE]: 'this is my log message' };
var logged = 0;
var read = 0
function cleanup() {
fs.unlinkSync(filename);
}
transport.log(info, noop);
setImmediate(function () {
helpers.tryRead(filename)
.on('error', function (err) {
assume(err).false();
cleanup();
done();
})
.pipe(split())
.on('data', function (d) {
assume(++read).lte(logged);
assume(d).to.equal(info[MESSAGE]);
})
.on('end', function () {
cleanup();
done();
});
});
transport.once('logged', function () {
logged++;
});
});
//
// TODO: Rewrite these tests in mocha
//
// "Error object in metadata #610": {
// topic: function () {
// var myErr = new Error("foo");
//
// fileTransport.log('info', 'test message', myErr, this.callback.bind(this, null, myErr));
// },
// "should not be modified": function (err, myErr) {
// assert.equal(myErr.message, "foo");
// // Not sure if this is the best possible way to check if additional props appeared
// assert.deepEqual(Object.getOwnPropertyNames(myErr), Object.getOwnPropertyNames(new Error("foo")));
// }
// }
//
// "Date object in metadata": {
// topic: function () {
// var obj = new Date(1000);
// fileTransport.log('info', 'test message', obj, this.callback.bind(this, null, obj));
// },
// "should not be modified": function (err, obj) {
// // Not sure if this is the best possible way to check if additional props appeared
// assert.deepEqual(Object.getOwnPropertyNames(obj), Object.getOwnPropertyNames(new Date()));
// }
// }
//
// "Plain object in metadata": {
// topic: function () {
// var obj = { message: "foo" };
// fileTransport.log('info', 'test message', obj, this.callback.bind(this, null, obj));
// },
// "should not be modified": function (err, obj) {
// assert.deepEqual(obj, { message: "foo" });
// }
// }
//
// "An instance of the File Transport": require('./transport')(winston.transports.File, {
// filename: path.join(__dirname, '..', 'fixtures', 'logs', 'testfile.log')
// })
});
describe('File({ stream })', function () {
it('should display the deprecation notice');
it('should write to the stream when logged to with expected object', function (done) {
var streamfile = path.join(__dirname, '..', 'fixtures', 'file', 'simple-stream.log');
var stream = fs.createWriteStream(streamfile);
var streamTransport = new winston.transports.File({
stream: stream
});
done();
//
// TODO: Flesh out these assertions
//
});
});
require('abstract-winston-transport')({
name: 'File',
Transport: winston.transports.File,
construct: {
filename: path.join(__dirname, '..', 'fixtures', 'file', 'abstract.log')
},
after(opts, done) {
const abstractFile = opts.construct.filename;
fs.unlink(abstractFile, done.bind(null, null));
}
});

77
node_modules/winston/test/transports/http.test.js generated vendored Normal file
View File

@ -0,0 +1,77 @@
/*
* http-test.js: Tests for instances of the HTTP transport
*
* MIT LICENSE
*/
var path = require('path'),
http = require('http'),
fs = require('fs'),
hock = require('hock'),
assume = require('assume'),
Http = require('../../lib/winston/transports/http'),
helpers = require('../helpers');
var host = '127.0.0.1';
function mockHttpServer(opts, done) {
if (!done && typeof opts === 'function') {
done = opts;
opts = {};
}
var mock = hock.createHock();
opts.path = opts.path || 'log';
opts.payload = opts.payload || {
level: 'info',
message: 'hello',
meta: {}
};
mock
.post('/' + opts.path, opts.payload)
.min(1)
.max(1)
.reply(200);
var server = http.createServer(mock.handler);
server.listen(0, '0.0.0.0', done);
return { server, mock };
}
describe('Http({ host, port, path })', function () {
var context;
var server;
beforeEach(function (done) {
context = mockHttpServer(done);
server = context.server;
});
it('should send logs over HTTP', function (done) {
var port = server.address().port;
var httpTransport = new Http({
host: host,
port: port,
path: 'log'
}).on('error', function (err) {
assume(err).falsy();
}).on('logged', function () {
context.mock.done(function (err) {
if (err) { assume(err).falsy(); }
done();
});
});
httpTransport.log({
level: 'info',
message: 'hello',
meta: {}
}, function (err) {
if (err) { assume(err).falsy(); }
});
});
afterEach(function (done) {
server.close(done.bind(null, null));
});
});

48
node_modules/winston/test/transports/stream.test.js generated vendored Normal file
View File

@ -0,0 +1,48 @@
'use strict';
const path = require('path');
const writeable = require('../helpers').writeable;
const { MESSAGE } = require('triple-beam');
const os = require('os');
const winston = require('../../');
const split = require('split2');
const assume = require('assume');
describe('Stream({ stream })', function () {
it('should support objectMode streams', function (done) {
const expected = {
level: 'info',
message: 'lolwut testing!'
};
const stream = writeable(function (info) {
assume(info).equals(expected);
done();
});
const transport = new winston.transports.Stream({ stream });
transport.log(expected);
});
it('should support UTF8 encoding streams', function (done) {
const expected = {
level: 'info',
message: 'lolwut testing!',
[MESSAGE]: 'info: lolwut testing!'
};
const stream = writeable(function (raw) {
assume(raw.toString()).equals(`${expected[MESSAGE]}${os.EOL}`);
done();
}, false);
const transport = new winston.transports.Stream({ stream });
transport.log(expected);
});
it('should throw when not passed a stream', function () {
assume(function () {
const stream = new winston.transports.Stream()
}).throws('options.stream is required.');''
});
});

25
node_modules/winston/tsconfig.json generated vendored Normal file
View File

@ -0,0 +1,25 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"target": "es6",
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"baseUrl": "./",
"typeRoots": [
"./node_modules/@types",
"./node_modules"
],
"types": ["node"],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"lib/winston/config/index.d.ts",
"lib/winston/transports/index.d.ts"
]
}