SSDP服务端和客户端js脚本

Bunyan is **a simple and fast JSON logging library** for node.js services: var bunyan = require('bunyan'); var log = bunyan.createLogger({name: "myapp"}); log.info("hi"); and **a `bunyan` CLI tool** for nicely viewing those logs:  Manifesto: Server logs should be structured. JSON's a good format. Let's do that. A log record is one line of `JSON.stringify`'d output. Let's also specify some common names for the requisite and common fields for a log record (see below). Also: log4j is way more than you need. # Current Status Solid core functionality is there. Joyent is using this for a number of production services. Bunyan supports node 0.6 and greater. Follow <a href="https://twitter.com/intent/user?screen_name=trentmick" target="_blank">@trentmick</a> for updates to Bunyan. There is an email discussion list [bunyan-logging@googlegroups.com](mailto:bunyan-logging@googlegroups.com), also [as a forum in the browser](https://groups.google.com/forum/?fromgroups#!forum/bunyan-logging). # Installation npm install bunyan **Tip**: The `bunyan` CLI tool is written to be compatible (within reason) with all versions of Bunyan logs. Therefore you might want to `npm install -g bunyan` to get the bunyan CLI on your PATH, then use local bunyan installs for node.js library usage of bunyan in your apps. # Features - elegant [log method API](#log-method-api) - extensible [streams](#streams) system for controlling where log records go (to a stream, to a file, [log file rotation](#stream-type-rotating-file), etc.) - [`bunyan` CLI](#cli-usage) for pretty-printing and filtering of Bunyan logs - simple include of log call source location (file, line, function) with [`src: true`](#src) - light-weight specialization of Logger instances with [`log.child`](#logchild) - custom rendering of logged objects with ["serializers"](#serializers) - [Runtime log snooping via Dtrace support](#dtrace-support) # Introduction Like most logging libraries you create a Logger instance and call methods named after the logging levels: $ cat hi.js var bunyan = require('bunyan'); var log = bunyan.createLogger({name: 'myapp'}); log.info('hi'); log.warn({lang: 'fr'}, 'au revoir'); All loggers must provide a "name". This is somewhat akin to the log4j logger "name", but Bunyan doesn't do hierarchical logger names. **Bunyan log records are JSON.** A few fields are added automatically: "pid", "hostname", "time" and "v". $ node hi.js {"name":"myapp","hostname":"banana.local","pid":40161,"level":30,"msg":"hi","time":"2013-01-04T18:46:23.851Z","v":0} {"name":"myapp","hostname":"banana.local","pid":40161,"level":40,"lang":"fr","msg":"au revoir","time":"2013-01-04T18:46:23.853Z","v":0} ## Log Method API The example above shows two different ways to call `log.info(...)`. The full API is: log.info(); // Returns a boolean: is the "info" level enabled? // This is equivalent to `log.isInfoEnabled()` or // `log.isEnabledFor(INFO)` in log4j. log.info('hi'); // Log a simple string message (or number). log.info('hi %s', bob, anotherVar); // Uses `util.format` for msg formatting. log.info({foo: 'bar'}, 'hi'); // Adds "foo" field to log record. You can add any number // of additional fields here. log.info(err); // Special case to log an `Error` instance to the record. // This adds an "err" field with exception details // (including the stack) and sets "msg" to the exception // message. log.info(err, 'more on this: %s', more); // ... or you can specify the "msg". Note that this implies **you cannot pass any object as the first argument to log it**. IOW, `log.info(mywidget)` may not be what you expect. Instead of a string representation of `mywidget` that other logging libraries may give you, Bunyan will try to JSON-ify your object. It is a Bunyan best practice to always give a field name to included objects, e.g.: log.info({widget: mywidget}, ...) This will dove-tail with [Bunyan serializer support](#serializers), discussed later. The same goes for all of Bunyan's log levels: `log.trace`, `log.debug`, `log.info`, `log.warn`, `log.error`, and `log.fatal`. See the [levels section](#levels) below for details and suggestions. ## CLI Usage Bunyan log output is a stream of JSON objects. This is great for processing, but not for reading directly. A **`bunyan` tool** is provided **for pretty-printing bunyan logs** and for **filtering** (e.g. `| bunyan -c 'this.foo == "bar"'`). Using our example above: $ node hi.js | ./bin/bunyan [2013-01-04T19:01:18.241Z] INFO: myapp/40208 on banana.local: hi [2013-01-04T19:01:18.242Z] WARN: myapp/40208 on banana.local: au revoir (lang=fr) See the screenshot above for an example of the default coloring of rendered log output. That example also shows the nice formatting automatically done for some well-known log record fields (e.g. `req` is formatted like an HTTP request, `res` like an HTTP response, `err` like an error stack trace). One interesting feature is **filtering** of log content, which can be useful for digging through large log files or for analysis. We can filter only records above a certain level: $ node hi.js | bunyan -l warn [2013-01-04T19:08:37.182Z] WARN: myapp/40353 on banana.local: au revoir (lang=fr) Or filter on the JSON fields in the records (e.g. only showing the French records in our contrived example): $ node hi.js | bunyan -c 'this.lang == "fr"' [2013-01-04T19:08:26.411Z] WARN: myapp/40342 on banana.local: au revoir (lang=fr) See `bunyan --help` for other facilities. ## Streams Introduction By default, log output is to stdout and at the "info" level. Explicitly that looks like: var log = bunyan.createLogger({ name: 'myapp', stream: process.stdout, level: 'info' }); That is an abbreviated form for a single stream. **You can define multiple streams at different levels**. var log = bunyan.createLogger({ name: 'myapp', streams: [ { level: 'info', stream: process.stdout, // log INFO and above to stdout }, { level: 'error', path: '/var/log/myapp-error.log' // log ERROR and above to a file } ] }); More on streams in the [Streams section](#streams) below. ## log.child Bunyan has a concept of a child logger to **specialize a logger for a sub-component of your application**, i.e. to create a new logger with additional bound fields that will be included in its log records. A child logger is created with `log.child(...)`. In the following example, logging on a "Wuzzle" instance's `this.log` will be exactly as on the parent logger with the addition of the `widget_type` field: var bunyan = require('bunyan'); var log = bunyan.createLogger({name: 'myapp'}); function Wuzzle(options) { this.log = options.log.child({widget_type: 'wuzzle'}); this.log.info('creating a wuzzle') } Wuzzle.prototype.woos = function () { this.log.warn('This wuzzle is woosey.') } log.info('start'); var wuzzle = new Wuzzle({log: log}); wuzzle.woos(); log.info('done'); Running that looks like (raw): $ node myapp.js {"name":"myapp","hostname":"myhost","pid":34572,"level":30,"msg":"start","time":"2013-01-04T07:47:25.814Z","v":0} {"name":"myapp","hostname":"myhost","pid":34572,"widget_type":"wuzzle","level":30,"msg":"creating a wuzzle","time":"2013-01-04T07:47:25.815Z","v":0} {"name":"myapp","hostname":"myhost","pid":34572,"widget_type":"wuzzle","level":40,"msg":"This wuzzle is woosey.","time":"2013-01-04T07:47:25.815Z","v":0} {"name":"myapp","hostname"