https://github.com/Unitech/PM2/blob/development/ADVANCED_README.md#stateless-apps

Instead of passing the settings per request (too much overhead, too unconventional for documenting/implementing), we do the following

• Optionally provide a json file with configuration groups by keys (so angular-project1 : ... would be a set of configuration that we can access through angular-project1 key, etc). These definitions live on the server and must be hardcoded into the application (NOT the repo)
• The post route for logging has a parameter that will accept a configuration key string. If it's empty or it doesn't match a configuration, the default configuration will be used, otherwise we will extend the default configuration with the preconfigured key one.
• Same for the get method to retrieve an effective configuration.

This is much better since it's very simple to implement on the client side (no extra parameters on the client side), has no overhead on the log requests, and basically makes sense since the server will usually take logging from a small set of applications that can be preconfigured instead of some random request that would need really dynamic configuration

https://www.npmjs.com/package/winston-hipchat

Problem

We are already using internally the node environment variables. We need to populate those variables from a standard .env file.

Solution

Use one of these packages to handle environment passthrough

• https://github.com/motdotla/dotenv
• https://github.com/flatiron/nconf

We need a way for a client to set the logging configuration once and that that will be used for all the calls within the session/or that use the given token. Easiest probably would be

• Client provides logging configuration to server before first time it needs to log something (logging can be behind a promise that sends the configuration and afterwards adds the token to the header or something like that).

Alternatively:

• Client appends the configuration in a header on each log call.

Alternatively:

• Limited configuration through different endpoints (not good idea)

Using https://github.com/inakianduaga/node-express-boilerplate as base project

https://github.com/flatiron/winston
http://www.softwareontheroad.it/devlife/2014/01/winston-on-rsyslog/

We need to be able to throttle log requests from single clients otherwise we might log too much

https://www.npmjs.com/package/limiter (not sure if this is for clients or server, I think it's ok for server)

Preparations:

• Setup testing environment (use mocha)

Tests

• Test the services

Instead of generating a new logger instance per request (which probably is bad performance-wise), now that we've moved to using predefined settings, we should use fixed loggers as Winston categories, and retrieve that to do the logging (if the logging is not there we initialize it the first time).

https://github.com/winstonjs/winston#working-with-multiple-loggers-in-winston

Update:

Perhaps it's best to initialize all the loggers based on all configurations all at once, then we can just use them. I don't think it should be such a hit in performance

Preparations

• Setup testing environment

Tests:

• Write test to check the settings route is returning the standard settings
• Write tests by posting to the log service and checking that the calls send packages to the respective endpoints according to each configured transport

We need to be able to handle json/form-multipart posts to the given endpoint.

Using Swagger official integration

https://github.com/swagger-api/swagger-node-express

This uses a swagger object where we insert definitions of the spec. Advantage seems to be that we can use for the errors the same code we would throw inside the methods. Bad thing is that it seems to couple the integration with swagger tightly into the controllers

Using jsdoc/yaml based documentation

https://www.npmjs.com/package/swagger-express

This one we add jsdoc comments to each controller route definition for example specifying the API for that endpoint

Update: No 2.0 support!

Use swagger tools:

https://www.npmjs.com/package/swagger-tools

https://github.com/apigee-127/swagger-tools/blob/master/docs/QuickStart.md

This basically uses the swagger spec as the defining document and injects a few pieces of middleware that add the swagger routes to the app (using connect middleware)

• Takes care of validating request values, and also applies default values automatically
• Maps routes to controllers
• Adds validation middleware
  • Configuring the routing middleware:
    https://github.com/apigee-127/swagger-tools/blob/master/docs/Middleware.md#swagger-20-1