# winston

***

**1. Basic Usage**

```js
const { createLogger, format, transports } = require('winston');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console()
  ]
});

logger.info('Hello world!');
```

**2. Custom Format**

```js
const { createLogger, format, transports } = require('winston');

const myFormat = format.printf(({ level, message }) => {
  return `${level}: ${message}`;
});

const logger = createLogger({
  level: 'info',
  format: myFormat,
  transports: [
    new transports.Console()
  ]
});

logger.info('Hello world!'); // Output: "info: Hello world!"
```

**3. Multiple Transports**

```js
const { createLogger, format, transports } = require('winston');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new transports.File({ filename: 'mylog.log' })
  ]
});

logger.info('Hello world!'); // Output: Writes to both console and log file
```

**4. Exception Handling**

```js
const { createLogger, format, transports } = require('winston');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console()
  ],
  exceptionHandlers: [
    new transports.File({ filename: 'exceptions.log' })
  ]
});

try {
  throw new Error('This is an exception');
} catch (err) {
  logger.error(err); // Output: Writes exception to "exceptions.log" file
}
```

**5. Rotating Files**

```js
const { createLogger, format, transports } = require('winston');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new transports.File({ filename: 'mylog.log', maxFiles: 5, maxSize: '20mb' })
  ]
});

logger.info('Hello world!'); // Output: Rotates log files when they reach the specified size or number
```

**6. Cloud Logging**

```js
const { createLogger, format, transports } = require('winston');
const { LoggingWinston } = require('@google-cloud/logging-winston');

const loggingWinston = new LoggingWinston();

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    loggingWinston
  ]
});

logger.info('Hello world!'); // Output: Writes to Google Cloud Logging
```

**7. Filtering Logs**

```js
const { createLogger, format, transports } = require('winston');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new transports.File({ filename: 'mylog.log' })
  ],
  filter: (level) => level === 'error'
});

logger.error('This is an error'); // Output: Writes only errors to the console and log file
```

**8. Local Storage**

```js
const { createLogger, format, transports } = require('winston');
const { LocalStorage } = require('winston-mongodb');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new transports.LocalStorage({ db: 'myDb', collection: 'myLogs' })
  ]
});

logger.info('Hello world!'); // Output: Stores logs in a MongoDB database
```

**9. Remote Logging**

```js
const { createLogger, format, transports } = require('winston');
const { Loggly } = require('winston-loggly-bulk');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new Loggly({
      token: 'YOUR_LOGGLY_TOKEN',
      subdomain: 'YOUR_LOGGLY_SUBDOMAIN',
      tags: ['your', 'tags'],
      json: true
    })
  ]
});

logger.info('Hello world!'); // Output: Sends logs to Loggly
```

**10. Custom Transports**

```js
const { createLogger, format, transports } = require('winston');
const customTransport = new transports.Http({
  host: 'localhost',
  port: 8080,
  path: '/api/logs'
});

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    customTransport
  ]
});

logger.info('Hello world!'); // Output: Custom transport for sending logs to an HTTP endpoint
```

**11. Throttling**

```js
const { createLogger, format, transports } = require('winston');
const { ThrottleTransport } = require('winston-transport');

const transport = new ThrottleTransport({
  host: 'localhost',
  port: 8080,
  path: '/api/logs',
  throttle: {
    delay: 1000,
    count: 5
  }
});

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    transport
  ]
});

logger.info('Hello world!'); // Output: Throttles log messages to an HTTP endpoint
```

**12. Aggregating Logs**

```js
const { createLogger, format, transports } = require('winston');
const { AggregateError } = require('winston');

const errorLogger = createLogger({
  level: 'error',
  format: format.json(),
  transports: [
    new transports.File({ filename: 'errors.log' })
  ]
});

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new AggregateError({ childLogger: errorLogger })
  ]
});

logger.info('Hello world!');
errorLogger.error('This is an error'); // Output: Aggregates errors from both loggers into a single file
```

**13. Contextual Logging**

```js
const { createLogger, format, transports } = require('winston');
const { LoggerWithContext } = require('winston-ctx');

const logger = new LoggerWithContext({
  logger: createLogger({
    level: 'info',
    format: format.json(),
    transports: [
      new transports.Console()
    ]
  })
});

logger.info('Hello world!', { user: 'John Doe' }); // Output: Adds contextual information to log messages
```

**14. Correlated Logging**

```js
const { createLogger, format, transports } = require('winston');
const { CorrelationId } = require('winston-correlation-id');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console()
  ],
  defaultMeta: { correlationId: new CorrelationId() }
});

logger.info('Hello world!'); // Output: Adds a correlation ID to all log messages
```

**15. Profiling**

```js
const { createLogger, format, transports } = require('winston');
const { Profile } = require('winston-profile');

const profile = new Profile();

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console()
  ],
  defaultMeta: { profile }
});

logger.profile('My Profile'); // Output: Profiles the execution time of a block of code
```

**16. HTTP Request Logging**

```js
const { createLogger, format, transports } = require('winston');
const { HttpLogger } = require('winston-http-logger');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console()
  ],
  requestWhitelist: ['url', 'method', 'headers', 'statusCode']
});

const httpLogger = new HttpLogger({ logger });

app.use(httpLogger.requestLogger()); // Output: Logs incoming HTTP requests
```

**17. Error Handling Middleware**

```js
const { createLogger, format, transports } = require('winston');
const { ErrorHandler } = require('winston-express-middleware');

const logger = createLogger({
  level: 'error',
  format: format.json(),
  transports: [
    new transports.File({ filename: 'errors.log' })
  ]
});

const errorHandler = new ErrorHandler({ logger });

app.use(errorHandler); // Output: Logs unhandled errors from Express applications
```

**18. Rolling File**

```js
const { createLogger, format, transports } = require('winston');
const { RollingFile } = require('winston-daily-rotate-file');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new RollingFile({ filename: 'mylog-%DATE%.log', datePattern: 'YYYY-MM-DD' })
  ]
});

logger.info('Hello world!'); // Output: Rolls log files daily
```

**19. MySQL**

```js
const { createLogger, format, transports } = require('winston');
const { MySQL } = require('winston-mysql');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new MySQL({
      host: 'localhost',
      user: 'root',
      password: 'password',
      database: 'myDb',
      table: 'myLogs'
    })
  ]
});

logger.info('Hello world!'); // Output: Stores logs in a MySQL database
```

**20. InfluxDB**

```js
const { createLogger, format, transports } = require('winston');
const { InfluxDB } = require('winston-influxdb3');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new InfluxDB({
      host: 'localhost',
      port: 8086,
      database: 'myDb',
      measurement: 'myLogs'
    })
  ]
});

logger.info('Hello world!'); // Output: Stores logs in an InfluxDB database
```

**21. MongoDB Atlas**

```js
const { createLogger, format, transports } = require('winston');
const { MongoDB } = require('winston-mongodb');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new MongoDB({
      connectionString: 'mongodb+srv://user:password@cluster.mongodb.net/myDb',
      collection: 'myLogs'
    })
  ]
});

logger.info('Hello world!'); // Output: Stores logs in a MongoDB Atlas database
```

**22. Kubernetes Event Recorder**

```js
const { createLogger, format, transports } = require('winston');
const { KubeEventRecorder } = require('winston-kube-event-recorder');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new KubeEventRecorder()
  ]
});

logger.info('Hello world!'); // Output: Records events in Kubernetes events API
```

**23. Vector**

```js
const { createLogger, format, transports } = require('winston');
const { Vector } = require('winston-vector');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new Vector({
      hostname: 'localhost',
      port: 8900,
      sampleRate: 1
    })
  ]
});

logger.info('Hello world!'); // Output: Sends logs to a Vector database
```

**24. OpenCensus**

```js
const { createLogger, format, transports } = require('winston');
const { OpenCensus } = require('winston-opentracing');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new OpenCensus()
  ]
});

logger.info('Hello world!'); // Output: Integrates with OpenCensus tracing
```

**25. Jaeger**

```js
const { createLogger, format, transports } = require('winston');
const { Jaeger } = require('winston-jaeger');

const logger = createLogger({
  level: 'info',
  format: format.json(),
  transports: [
    new transports.Console(),
    new Jaeger()
  ]
});

logger.info('Hello world!'); // Output: Integrates with Jaeger tracing
```