Jak korzystać z rejestratora Morgan?

Nie mogę zalogować się do Morgana. Nie rejestruje informacji w konsoli. Dokumentacja nie mówi, jak go używać.

Chcę zobaczyć, czym jest zmienna. To jest kod z response.jspliku frameworka expressjs:

var logger = require("morgan");

res.render = function(view, options, fn){
  options = options || {};
  var self = this;
  var req = this.req;
  var app = req.app;

  // support callback function as second arg
  if ('function' == typeof options) {
    fn = options, options = {};
  }

  // merge res.locals
  options._locals = self.locals;

  // default callback to respond
  fn = fn || function(err, str){
    if (err) return req.next(err);
    self.send(str);
  };

  // Here I want to see what fn is
  // But it doesn't show me anything in console
  // How to use it?
  logger(fn);

  // render
  app.render(view, options, fn);
};

Jak używać Morgana?

Wygląda na to, że ty także jesteś zdezorientowany z tym samym co ja, powodem, dla którego natknąłem się na to pytanie. Myślę, że kojarzymy rejestrowanie z ręcznym rejestrowaniem, tak jak w Javie z log4j (jeśli znasz java), gdzie tworzymy instancję Loggera i mówimy log „this”.

Potem wkopałem się w kod morgana, okazuje się, że nie jest to rejestrator tego typu, służy on do automatycznego rejestrowania żądań, odpowiedzi i powiązanych danych. Po dodaniu jako oprogramowanie pośredniczące do aplikacji express / connect, domyślnie powinno rejestrować instrukcje na stdout pokazujące szczegóły: zdalnego adresu IP, metody żądania, wersji http, statusu odpowiedzi, agenta użytkownika itp. Pozwala modyfikować dziennik za pomocą tokenów lub dodaj do nich kolor, definiując „dev” lub nawet wylogowując się do strumienia wyjściowego, takiego jak plik.

W tym celu pomyśleliśmy, że możemy go użyć, ponieważ w tym przypadku nadal musimy użyć:

console.log(..);

Lub jeśli chcesz, aby dane wyjściowe były ładne dla obiektów:

var util = require("util");
console.log(util.inspect(..));

Myślę, że mam sposób, w którym możesz nie uzyskać dokładnie tego, czego chcesz, ale możesz zintegrować rejestrowanie Morgana z log4js - innymi słowy, cała twoja aktywność związana z rejestrowaniem może iść w to samo miejsce. Mam nadzieję, że ten skrót z serwera Express jest mniej więcej zrozumiały:

var express = require("express");
var log4js = require("log4js");
var morgan = require("morgan");
...
var theAppLog = log4js.getLogger();
var theHTTPLog = morgan({
  "format": "default",
  "stream": {
    write: function(str) { theAppLog.debug(str); }
  }
});
....
var theServer = express();
theServer.use(theHTTPLog);

Teraz możesz napisać do AppLog, co chcesz, a Morgan napisze to, co chce, w tym samym miejscu, używając tych samych programów, itp. Itd. Oczywiście możesz wywołać info () lub cokolwiek chcesz w opakowaniu strumienia zamiast debugowania () - to tylko odzwierciedla poziom logowania, który chcesz nadać rejestrowaniu wymagań / rozdzielczości Morgana.

Morgan nie powinien być używany do logowania się w sposób, który opisujesz. Morgan został zbudowany do rejestrowania w sposób, w jaki serwery takie jak Apache i Nginx logują się do error_log lub access_log. Dla porównania, w ten sposób używasz morgana:

var express     = require('express'),
    app         = express(),
    morgan      = require('morgan'); // Require morgan before use

// You can set morgan to log differently depending on your environment
if (app.get('env') == 'production') {
  app.use(morgan('common', { skip: function(req, res) { return res.statusCode < 400 }, stream: __dirname + '/../morgan.log' }));
} else {
  app.use(morgan('dev'));
}

Zwróć uwagę na linię produkcyjną, na której widzisz wywołanie morgana z hashem opcji {skip: ..., stream: __dirname + '/../morgan.log'}

streamWłasność tego obiektu określa gdzie wyjść rejestratora. Domyślnie jest to STDOUT (twoja konsola, tak jak chcesz), ale rejestruje tylko dane żądań. Nie zrobi tego, co console.log()robi.

Jeśli chcesz sprawdzić rzeczy w locie, skorzystaj z wbudowanej utilbiblioteki:

var util = require('util');
console.log(util.inspect(anyObject)); // Will give you more details than console.log

Zatem odpowiedź na twoje pytanie brzmi: zadajesz niewłaściwe pytanie. Ale jeśli nadal chcesz używać Morgana do rejestrowania żądań, gotowe.

Miałem ten sam problem wcześniej i zamiast tego użyłem winstona. Jak wspomniano powyżej, morgan służy do automatycznego rejestrowania żądań / odpowiedzi. Winston można skonfigurować prawie tak samo, jak log4Net / log4J, ma poziomy ważności, różne strumienie, do których można się logować itp.

Na przykład:

npm install winston

Następnie, jeśli wywołasz poniższy kod gdzieś podczas inicjalizacji aplikacji:

var winston = require('winston');

// setup default logger (no category)
winston.loggers.add('default', {
    console: {
        colorize: 'true',
        handleExceptions: true,
        json: false,
        level: 'silly',
        label: 'default',
    },
    file: {
        filename: 'some/path/where/the/log/file/reside/default.log',
        level: 'silly',
        json: false,
        handleExceptions: true,
    },
});

//
// setup logger for category `usersessions`
// you can define as many looggers as you like
//
winston.loggers.add('usersessions', {
    console: {
        level: 'silly',
        colorize: 'true',
        label: 'usersessions',
        json: false,
        handleExceptions: true,
    },
    file: {
        filename: 'some/path/where/the/log/file/reside/usersessions.log',
        level: 'silly',
        json: false,
        handleExceptions: true,
    },
});

uwaga: przed wywołaniem powyższego kodu winston.loggers jest pusty, tzn. nie masz jeszcze skonfigurowanych żadnych loggerów. Prawie jak metody Log4Net / J XmlConfigure - musisz je najpierw wywołać, aby zainicjować logowanie.

Następnie, gdziekolwiek w kodzie po stronie serwera aplikacji możesz zrobić:

var winston = require('winston');
// log instances as defined in first snippet
var defaultLog = winston.loggers.get('default'); 
var userSessionsLog = winston.loggers.get('usersessions');

defaultLog.info('this goes to file default.log');
userSessionsLog.debug('this goes to file usersessions.log')

Mam nadzieję, że to pomoże.

dalsze odniesienia do dokumentacji: https://www.npmjs.com/package/winston

Morgan: - Morgan to oprogramowanie pośredniczące, które pomoże nam zidentyfikować klientów uzyskujących dostęp do naszej aplikacji. Zasadniczo logger.

Aby użyć Morgana, musimy wykonać poniższe kroki: -

1. Zainstaluj morgan za pomocą poniższego polecenia:

npm install --save morgan

Spowoduje to dodanie morgana do pliku json.package

2. Uwzględnij morgan w swoim projekcie

var morgan = require('morgan');

3> // stwórz strumień zapisu (w trybie dopisywania)

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

Uwaga: Upewnij się, że nie wspinasz się na oślep powyżej, upewnij się, że masz wszystkie warunki, w których potrzebujesz.

Powyższe spowoduje automatyczne utworzenie pliku access.log w katalogu głównym, gdy użytkownik uzyska dostęp do aplikacji.

var express = require('express');

var fs = require('fs');

var morgan = require('morgan')

var app = express();

// create a write stream (in append mode)
var accessLogStream = fs.createWriteStream(__dirname + '/access.log',{flags: 'a'});


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


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

przykład nodejs + express + morgan

W moim przypadku:

-console.log()  // works
-console.error() // works
-app.use(logger('dev')) // Morgan is NOT logging requests that look like "GET /myURL 304 9.072 ms - -"

NAPRAW: Używałem kodu Visual Studio i musiałem dodać to do mojego Launch Config

"outputCapture": "std"

Sugestia: jeśli korzystasz z IDE, uruchom bezpośrednio z wiersza poleceń, aby upewnić się, że IDE nie powoduje problemu.

Możesz spróbować użyć mongo-morgan-ext

Zastosowanie to:

var logger = require('mongo-morgan-ext');

var db = 'mongodb://localhost:27017/MyDB';

var collection = 'Logs'

var skipfunction = function(req, res) {

return res.statusCode > 399;
} //Thiw would skip if HTTP request response is less than 399 i.e no errors.

app.use(logger(db,collection,skipfunction)); //In your express-application

Oczekiwany wynik to

{
    "RequestID": "",
    "status": "",
    "method": "",
    "Remote-user": "",
    "Remote-address": "",
    "URL": "",
    "HTTPversion": "",
    "Response-time": "",
    "date":"",
    "Referrer": "",
    "REQUEST": { //10
        "Accept": "",
        "Accept-Charset": "",
        "Accept-Encoding": "",
        "Accept-Language": "",
        "Authorization": "",
        "Cache-Control": "",
        "Connection": "",
        "Cookie": "",
        "Content-Length": "",
        "Content-MD5": "",
        "Content-Type": "",
        "Expect": "",
        "Forwarded": "",
        "From": "",
        "Host": "",
        "Max-Forwards": "",
        "Origin": "",
        "Pragma": "",
        "Proxy-Authorization": "",
        "Range": "",
        "TE": "",
        "User-Agent": "",
        "Via": "",
        "Warning": "",
        "Upgrade": "",
        "Referer": "",
        "Date": "",
        "X-requested-with": "",
        "X-Csrf-Token": "",
        "X-UIDH": "",
        "Proxy-Connection": "",
        "X-Wap-Profile": "",
        "X-ATT-DeviceId": "",
        "X-Http-Method-Override":"",
        "Front-End-Https": "",
        "X-Forwarded-Proto": "",
        "X-Forwarded-Host": "",
        "X-Forwarded-For": "",
        "DNT": "",
        "Accept-Datetime": "",
        "If-Match": "",
        "If-Modified-Since": "",
        "If-None-Match": "",
        "If-Range": "",
        "If-Unmodified-Since": ""
    },
    "RESPONSE": {
        "Status": "",
        "Content-MD5":"",
        "X-Frame-Options": "",
        "Accept-Ranges": "",
        "Age": "",
        "Allow": "",
        "Cache-Control": "",
        "Connection": "",
        "Content-Disposition": "",
        "Content-Encoding": "",
        "Content-Language": "",
        "Content-Length": "",
        "Content-Location": "",
        "Content-Range": "",
        "Content-Type":"",
        "Date":"",
        "Last-Modified": "",
        "Link": "",
        "Location": "",
        "P3P": "",
        "Pragma": "",
        "Proxy-Authenticate": "",
        "Public-Key-Pins": "",
        "Retry-After": "",
        "Server": "",
        "Trailer": "",
        "Transfer-Encoding": "",
        "TSV": "",
        "Upgrade": "",
        "Vary": "",
        "Via": "",
        "Warning": "",
        "WWW-Authenticate": "",
        "Expires": "",
        "Set-Cookie": "",
        "Strict-Transport-Security": "",
        "Refresh":"",
        "Access-Control-Allow-Origin": "",
        "X-XSS-Protection": "",
        "X-WebKit-CSP":"",
        "X-Content-Security-Policy": "",
        "Content-Security-Policy": "",
        "X-Content-Type-Options": "",
        "X-Powered-By": "",
        "X-UA-Compatible": "",
        "X-Content-Duration": "",
        "Upgrade-Insecure-Requests": "",
        "X-Request-ID": "",
        "ETag": "",
        "Accept-Patch": ""
    }

}

Używanie morgana jest dość proste. Jak sugeruje dokumentacja , istnieją różne sposoby uzyskania pożądanego wyniku za pomocą morgana. Zawiera wstępnie skonfigurowane metody logowania lub możesz je zdefiniować samodzielnie. Na przykład.

const morgan = require ('morgan')

app.use (morgan ('malutki')

To da ci wstępną konfigurację o nazwie tiny. Zauważysz w swoim terminalu, co robi. Jeśli nie jesteś z tego zadowolony i chcesz głębiej, np. Powiedzmy adres URL żądania, to tutaj pojawiają się tokeny.

morgan.token ('url', function (req, res) {return '/ api / myendpoint'})

następnie użyj go w ten sposób:

app.use (morgan (': url')

Sprawdź dokumentację, która jest tam wyróżniona.