Méthode de Morgan du composant de journal par défaut express

Morgan est le middleware de journalisation par défaut d'Express. Cet article présente principalement la méthode du composant de journalisation par défaut d'Express, Morgan. Je vais maintenant le partager avec vous et lui donner une référence.

Aperçu du chapitre

Morgan est le middleware de journalisation par défaut d'Express et peut également être séparé d'Express et utilisé comme node.js composant de journalisation À utiliser seul. Cet article va du superficiel au profond, et le contenu comprend principalement :

1. Exemples d'introduction à l'utilisation de Morgan

2. Comment enregistrer les journaux dans des fichiers locaux

3. Instructions et exemples d'utilisation de l'API principale

4. Utilisation avancée : 1. Fractionnement des journaux 2. Écrire les journaux dans la base de données

5. Analyse du code source : format de journal de Morgan et précompilation

Exemple de démarrage

Tout d'abord, initialisez le projet.

npm install express morgan

Ensuite, ajoutez le code suivant dans basic.js.

var express = require('express');
var app = express();
var morgan = require('morgan');

app.use(morgan('short'));
app.use(function(req, res, next){
 res.send('ok');
});

app.listen(3000);

node basic.jsExécutez le programme et accédez à http://127.0.0.1:3000 dans le navigateur Le journal d'impression est le suivant<🎜. >

➜ 2016.12.11-advanced-morgan git:(master) ✗ node basic.js

::ffff:127.0.0.1 - GET / HTTP/1.1 304 - - 3.019 ms
::ffff: 127.0.0.1 - GET /favicon.ico HTTP/1.1 200 2 - 0,984 ms

Imprimer le journal dans un fichier local

morgan prend en charge les éléments de configuration du flux , qui peut être transmis Il est utilisé pour obtenir l'effet des journaux d'atterrissage. Le code est le suivant :

var express = require('express');
var app = express();
var morgan = require('morgan');
var fs = require('fs');
var path = require('path');
var accessLogStream = fs.createWriteStream(path.join(__dirname, 'access.log'), {flags: 'a'});
app.use(morgan('short', {stream: accessLogStream}));
app.use(function(req, res, next){
 res.send('ok');
});
app.listen(3000);

Explication de l'utilisation<🎜. >
API de base

morgan a très peu d'API. La plus fréquemment utilisée est morgan(), qui renvoie un middleware de journalisation express.

morgan(format, options)

La description du paramètre est la suivante :

format : facultatif, morgan et Plusieurs formats de journaux sont définis, chaque format a un nom correspondant, tel que combiné, court, etc. La valeur par défaut est par défaut. Les différences entre les différents formats peuvent être trouvées ici. Ce qui suit explique comment personnaliser le format du journal.
options : facultatives, éléments de configuration, y compris le flux (couramment utilisé), le saut et l'immédiat.
stream : configuration du flux de sortie du journal, la valeur par défaut est process.stdout.
ignorer : si vous souhaitez ignorer la journalisation, veuillez vous référer à ici pour l'utilisation.
immédiat : valeur booléenne, la valeur par défaut est false. Lorsque vrai, le journal sera enregistré dès que la demande est reçue ; si faux, le journal sera enregistré après le retour de la demande.

5. 
   

Format de journal personnalisé

Comprenez d'abord les deux concepts de Morgan : le format et le jeton. Très simple :

format : format du journal, qui est essentiellement une chaîne représentant le format du journal, tel que : méthode :url :status :res[content-length] - : temps de réponse ms.
Jeton : les composants de format, tels que :method et :url ci-dessus, sont ce qu'on appelle des jetons.
Après avoir compris la différence entre le format et le jeton, vous pouvez jeter un œil aux API clés concernant la personnalisation des formats de journaux dans Morgan.

morgan.format(name, format); // 自定义日志格式
morgan.token(name, fn); // 自定义token

Format personnalisé

C'est très simple, premier passage morgan.format () Définissez le format de journal nommé joke, puis appelez-le via morgan('joke').

var express = require('express');
var app = express();
var morgan = require('morgan');
morgan.format('joke', '[joke] :method :url :status');
app.use(morgan('joke'));
app.use(function(req, res, next){
 res.send('ok');
});
app.listen(3000);

Jetons un coup d'œil aux résultats en cours

➜ 2016.12.11-advanced-morgan git:(master ) ✗ nœud morgan.format.js

[blague] GET / 304

[blague] GET /favicon.ico 200

jeton personnalisé

Le code est le suivant, personnalisez le jeton via morgan.token(), puis ajoutez le jeton personnalisé au format personnalisé.

var express = require('express');
var app = express();
var morgan = require('morgan');
// 自定义token
morgan.token('from', function(req, res){
 return req.query.from || '-';
});
// 自定义format，其中包含自定义的token
morgan.format('joke', '[joke] :method :url :status :from');

// 使用自定义的format
app.use(morgan('joke'));
app.use(function(req, res, next){
 res.send('ok');
});
app.listen(3000);

Exécutez le programme et visitez http://127.0.0.1:3000/hello?from=app et

dans le navigateur http. ://127.0.0.1:3000/hello?from=pc

➜ 2016.12.11-advanced-morgan git:(master) ✗ node morgan.token.js

[blague] GET /hello?from=app 200 app

[blague] GET /favicon.ico 304 -
[blague] GET /hello?from=pc 200 pc
[blague] GET /favicon.ico 304 -

Utilisation avancée

Découpe de bûches

Une candidature en ligne, si tous les journaux sont stockés dans le même fichier local, le fichier deviendra très volumineux avec le temps, ce qui affectera les performances et sera peu pratique à visualiser. À ce stade, vous devez utiliser la segmentation des journaux.

Avec le plug-in file-stream-rotator, le fractionnement des bûches peut être facilement réalisé. À l’exception du code de configuration lié à file-stream-rotator, le reste est similaire à l’exemple précédent, je n’entrerai donc pas dans les détails ici.

var FileStreamRotator = require('file-stream-rotator')
var express = require('express')
var fs = require('fs')
var morgan = require('morgan')
var path = require('path')

var app = express()
var logDirectory = path.join(__dirname, 'log')

// ensure log directory exists
fs.existsSync(logDirectory) || fs.mkdirSync(logDirectory)

// create a rotating write stream
var accessLogStream = FileStreamRotator.getStream({
 date_format: 'YYYYMMDD',
 filename: path.join(logDirectory, 'access-%DATE%.log'),
 frequency: 'daily',
 verbose: false
})

// setup the logger
app.use(morgan('combined', {stream: accessLogStream}))

app.get('/', function (req, res) {
 res.send('hello, world!')
})

Le journal est écrit dans la base de données

Parfois, nous avons un tel besoin , écrit le journal d'accès à la base de données. Cette exigence est courante dans les systèmes de journalisation qui nécessitent des statistiques de requête en temps réel.

在morgan里该如何实现呢？从文档上，并没有看到适合的扩展接口。于是查阅了下morgan的源码，发现实现起来非常简单。

回顾下之前日志写入本地文件的例子，最关键的两行代码如下。通过stream指定日志的输出流。

var accessLogStream = fs.createWriteStream(path.join(__dirname, 'access.log'), {flags: 'a'});
app.use(morgan('short', {stream: accessLogStream}));

在morgan内部，大致实现是这样的（简化后）。

// opt为配置文件
var stream = opts.stream || process.stdout;
var logString = createLogString(); // 伪代码，根据format、token的定义，生成日志
stream.write(logString);

于是，可以用比较取巧的方式来实现目的：声明一个带write方法的对象，并作为stream配置传入。

var express = require('express');
var app = express();
var morgan = require('morgan');

// 带write方法的对象
var dbStream = {
 write: function(line){
 saveToDatabase(line); // 伪代码，保存到数据库
 }
};

// 将 dbStream 作为 stream 配置项的值
app.use(morgan('short', {stream: dbStream}));
app.use(function(req, res, next){
 res.send('ok');
});

app.listen(3000);

深入剖析

morgan的代码非常简洁，从设计上来说，morgan的生命周期包含：

token定义 --> 日志格式定义 -> 日志格式预编译 --> 请求达到/返回 --> 写日志

其中，token定义、日志格式定义前面已经讲到，这里就只讲下 日志格式预编译 的细节。

跟模板引擎预编译一样，日志格式预编译，也是为了提升性能。源码如下，最关键的代码就是compile(fmt)。

 function getFormatFunction (name) {
 // lookup format
 var fmt = morgan[name] || name || morgan.default

 // return compiled format
 return typeof fmt !== 'function'
 ? compile(fmt)
 : fmt
}

compile()方法的实现细节这里不赘述，着重看下compile(fmt)返回的内容：

var morgan = require('morgan');
var format = morgan['tiny'];
var fn = morgan.compile(format);

console.log(fn.toString());

运行上面程序，输出内容如下，其中tokens其实就是morgan。

function anonymous(tokens, req, res
/**/) {
 return ""
 + (tokens["method"](req, res, undefined) || "-") + " "
 + (tokens["url"](req, res, undefined) || "-") + " "
 + (tokens["status"](req, res, undefined) || "-") + " "
 + (tokens["res"](req, res, "content-length") || "-") + " - "
 + (tokens["response-time"](req, res, undefined) || "-") + " ms";
}

看下morgan.token()的定义，就很清晰了

function token (name, fn) {
 morgan[name] = fn
 return this
}

上面是我整理给大家的，希望今后会对大家有帮助。

相关文章：

ajax请求之返回数据的顺序问题分析

解决ajax返回验证的时候总是弹出error错误的方法

防止重复发送Ajax请求的解决方案

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!