# morgan

***

**1. Simple Request and Response Logging**

```javascript
const morgan = require('morgan');

const app = express();
app.use(morgan('tiny'));
```

**2. Custom Logging Format**

```javascript
const morgan = require('morgan');

const app = express();
app.use(morgan(':remote-addr :remote-user :method :url :status :res[content-length] - :response-time ms'));
```

**3. Ignore Certain Routes**

```javascript
const morgan = require('morgan');
const ignore = ['/favicon.ico'];

const app = express();
app.use(morgan('tiny', { skip: (req, res) => ignore.includes(req.url) }));
```

**4. Log to a File**

```javascript
const morgan = require('morgan');
const fs = require('fs');
const path = require('path');

const app = express();
const logfile = fs.createWriteStream(path.join(__dirname, 'access.log'));
app.use(morgan('combined', { stream: logfile }));
```

**5. Log to Multiple Destinations**

```javascript
const morgan = require('morgan');
const fs = require('fs');
const path = require('path');
const app = express();

const logfile = fs.createWriteStream(path.join(__dirname, 'access.log'));
app.use(morgan('tiny', { stream: [logfile, stdout] }));
```

**6. Exclude Sensitive Information**

```javascript
const morgan = require('morgan');
const sanitize = require('sanitize-html');

const app = express();
app.use(morgan('combined', { stream: process.stdout, sanitize: true }));
```

**7. Format Log Message**

```javascript
const morgan = require('morgan');
const format = require('util').format;

const app = express();
app.use(morgan(logger, { stream: process.stdout }));

function logger(tokens, req, res) {
  return format('[%s] %s %s %s %s %s',
    Date.now(),
    tokens.method(req, res),
    tokens.url(req, res),
    tokens.status(req, res),
    tokens.res(req, res, 'content-length'),
    tokens['response-time'](req, res)
  );
}
```

**8. Skip Logging for Static Files**

```javascript
const morgan = require('morgan');
const expressStaticGzip = require('express-static-gzip');

const app = express();
app.use(expressStaticGzip(path.join(__dirname, 'public')));
app.use(morgan('tiny', { skip: (req, res) => req.url.match(/^\/public\//) }));
```

**9. Log HTTP Errors**

```javascript
const morgan = require('morgan');
const chalk = require('chalk');

const app = express();
app.use(morgan('combined', {
  stream: {
    write: (message) => {
      if (message.includes('404') || message.includes('403')) {
        console.log(chalk.red(message));
      } else if (message.includes('500')) {
        console.log(chalk.yellow(message));
      } else {
        console.log(message);
      }
    }
  }
}));
```

**10. Log Request and Response Body**

```javascript
const morgan = require('morgan');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json());
app.use(morgan('combined', {
  stream: process.stdout,
  skip: (req, res) => req.method !== 'POST'
}));
```

**11. Include Header Information**

```javascript
const morgan = require('morgan');

const app = express();
app.use(morgan('combined', {
  stream: process.stdout,
  tokens: (req, res) => {
    return {
      'custom-header': req.headers['custom-header'],
    };
  }
}));
```

**12. Log Request Duration**

```javascript
const morgan = require('morgan');

const app = express();
app.use(morgan('combined', {
  stream: process.stdout,
  tokens: (req, res) => {
    return {
      'request-duration': Date.now() - req._startTime,
    };
  }
}));
```

**13. Customize Token Format**

```javascript
const morgan = require('morgan');

const app = express();
app.use(morgan('combined', {
  stream: process.stdout,
  tokens: {
    method: (req, res) => {
      return req.method.toUpperCase();
    }
  }
}));
```

**14. Log API Response Time**

```javascript
const morgan = require('morgan');
const chalk = require('chalk');

const app = express();
app.use(morgan('combined', {
  stream: {
    write: (message) => {
      if (message.includes('500')) {
        console.log(chalk.yellow(message));
      } else {
        console.log(chalk.green(message));
      }
    }
  },
  tokens: {
    'api-response-time': (req, res) => {
      return res.get('X-Response-Time');
    }
  }
}));
```

**15. Ignore Logging for Health Checks**

```javascript
const morgan = require('morgan');

const app = express();
app.use(morgan('tiny', { skip: (req, res) => req.path === '/health' }));
```

**16. Tokenize Custom Middleware**

```javascript
const morgan = require('morgan');
const customMiddleware = (req, res, next) => {
  req.customToken = 'custom-value';
  next();
};

const app = express();
app.use(customMiddleware);
app.use(morgan('combined', {
  tokens: {
    'custom-token': (req, res) => {
      return req.customToken;
    }
  }
}));
```

**17. Use Morgan with Passport**

```javascript
const morgan = require('morgan');
const passport = require('passport');

const app = express();
app.use(passport.initialize());
app.use(passport.session());
app.use(morgan('combined', {
  tokens: {
    user: (req, res) => {
      return req.user ? req.user.username : 'anonymous';
    }
  }
}));
```

**18. Log Exception Details**

```javascript
const morgan = require('morgan');

const app = express();
app.use(morgan('combined', {
  stream: {
    write: (message) => {
      if (message.includes('Error')) {
        console.log(chalk.red(message));
      } else {
        console.log(message);
      }
    }
  },
  tokens: {
    'error-details': (req, res) => {
      return req.error ? req.error.stack : 'no error';
    }
  }
}));
```

**19. Log Query Parameters**

```javascript
const morgan = require('morgan');

const app = express();
app.use(morgan('combined', {
  tokens: {
    'query-params': (req, res) => {
      return JSON.stringify(req.query);
    }
  }
}));
```

**20. Log Request Body**

```javascript
const morgan = require('morgan');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json());
app.use(morgan('combined', {
  tokens: {
    'request-body': (req, res) => {
      return JSON.stringify(req.body);
    }
  }
}));
```

**21. Log Response Headers**

```javascript
const morgan = require('morgan');

const app = express();
app.use(morgan('combined', {
  tokens: {
    'response-headers': (req, res) => {
      return JSON.stringify(res.getHeaders());
    }
  }
}));
```

**22. Log Database Queries**

```javascript
const morgan = require('morgan');
const Sequelize = require('sequelize');

const app = express();
const sequelize = new Sequelize('database', 'user', 'password', { host: 'host', dialect: 'postgres' });
sequelize.addHook('afterQuery', (query) => {
  console.log(morgan('tiny')(query));
});
```

**23. Log Redis Commands**

```javascript
const morgan = require('morgan');
const Redis = require('redis');

const app = express();
const redis = new Redis({ host: 'host', port: 6379 });
redis.on('command', (command) => {
  console.log(morgan('tiny')(command));
});
```

**24. Log MongoDB Queries**

```javascript
const morgan = require('morgan');
const mongoose = require('mongoose');

const app = express();
mongoose.connect('mongodb://host:port/database', { useNewUrlParser: true, useUnifiedTopology: true });
mongoose.connection.on('query', (query) => {
  console.log(morgan('tiny')(query));
});
```

**25. Log Kafka Messages**

```javascript
const morgan = require('morgan');
const Kafka = require('kafkajs');

const app = express();
const kafka = new Kafka({ clientId: 'client', brokers: ['host:port'] });
const consumer = kafka.consumer({ groupId: 'group' });
consumer.connect();
consumer.subscribe({ topic: 'topic' });
consumer.run({
  eachMessage: async ({ message, partition, topic }) => {
    console.log(morgan('tiny')({ message, partition, topic }));
  }
});
```