मॉर्गन लॉगर का उपयोग कैसे करें?

Question

मैं मॉर्गन के साथ लॉग इन नहीं कर सकता। यह कंसोल के लिए जानकारी लॉग नहीं करता है। प्रलेखन यह नहीं बताता कि इसका उपयोग कैसे किया जाए।

मैं देखना चाहता हूं कि एक चर क्या है। यह response.jsएक्सप्रेस फ्रेमवर्क की फाइल का एक कोड है :

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);
};

मॉर्गन का उपयोग कैसे करें?

Answer 1

लगता है कि आप भी उसी बात को लेकर भ्रमित हैं जैसे मैं था, इस सवाल पर मैं लड़खड़ा गया। मुझे लगता है कि हम मैन्युअल लॉगिंग के साथ लॉगिंग को जोड़ते हैं जैसा कि हम जावा में लॉग 4 जे (यदि आप जावा जानते हैं) के साथ करते हैं, जहां हम एक लकड़हारे को तुरंत कहते हैं और लॉग 'इस' कहते हैं।

फिर मैंने मॉर्गन कोड में खोदा, पता चला कि यह एक लकड़हारा का प्रकार नहीं है, यह अनुरोधों, प्रतिक्रियाओं और संबंधित डेटा के स्वचालित लॉगिंग के लिए है। जब एक्सप्रेस / कनेक्ट ऐप में मिडलवेयर के रूप में जोड़ा जाता है, तो डिफ़ॉल्ट रूप से विवरण दिखाने के लिए स्टेटमेंट लॉग करना चाहिए: दूरस्थ आईपी, अनुरोध विधि, http संस्करण, प्रतिक्रिया स्थिति, उपयोगकर्ता एजेंट आदि। यह आपको टोकन का उपयोग करके लॉग को संशोधित करने की अनुमति देता है। 'देव' को परिभाषित करके या आउटपुट स्ट्रीम में एक फाइल की तरह लॉग करके उनमें रंग जोड़ें।

इस उद्देश्य के लिए हमने सोचा कि हम इसका उपयोग कर सकते हैं, जैसा कि इस मामले में, हमें अभी भी उपयोग करना है:

console.log(..);

या यदि आप वस्तुओं के लिए आउटपुट को सुंदर बनाना चाहते हैं:

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

Answer 2

मुझे लगता है कि मेरे पास एक ऐसा तरीका है जहां आप ठीक-ठीक वह नहीं पा सकते हैं जो आप चाहते हैं, लेकिन आप मॉर्गन के लॉगिंग को log4js के साथ एकीकृत कर सकते हैं - दूसरे शब्दों में, आपकी सभी लॉगिंग गतिविधि उसी स्थान पर जा सकती है। मुझे उम्मीद है कि एक्सप्रेस सर्वर से यह पचाना कमोबेश आत्म-व्याख्यात्मक है:

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);

अब आप TheAppLog और Morgan के लिए जो चाहें लिख सकते हैं, वही लिखेंगे जो उसी जगह चाहते हैं, उसी अपेंडिक्स वगैरह का इस्तेमाल करके आदि। आप डिबग () के बजाय इनफॉर्मेशन () या जो भी आपको स्ट्रीम रैपर में पसंद हो उसे कॉल कर सकते हैं। - यह सिर्फ उस लॉगिंग स्तर को दर्शाता है जिसे आप मॉर्गन के रीक / रेस लॉगिंग को देना चाहते हैं।

Answer 3

मॉर्गन का उपयोग उस तरीके से लॉग इन करने के लिए नहीं किया जाना चाहिए जिसका आप वर्णन कर रहे हैं। मॉर्गन का निर्माण उस तरह से लॉगिंग करने के लिए किया गया था जैसे कि Apache और Nginx जैसे सर्वर error_log या access_log में लॉग इन करते हैं। संदर्भ के लिए, यह है कि आप मॉर्गन का उपयोग कैसे करते हैं:

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'));
}

उत्पादन लाइन पर ध्यान दें जहाँ आप एक विकल्प हैश के साथ मॉर्गन कहते हैं {skip: ..., stream: __dirname + '/../morgan.log'}

streamउस ऑब्जेक्ट की संपत्ति निर्धारित करती है कि लकड़हारा कहां आउटपुट करता है। डिफ़ॉल्ट रूप से यह STDOUT है (आपका कंसोल, जैसे आप चाहते हैं) लेकिन यह केवल अनुरोध डेटा लॉग करेगा। यह क्या console.log()करता है नहीं जा रहा है।

यदि आप फ्लाई इन utilलाइब्रेरी में निर्मित चीजों का निरीक्षण करना चाहते हैं :

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

तो आपके प्रश्न का उत्तर यह है कि आप गलत प्रश्न पूछ रहे हैं। लेकिन अगर आप अभी भी लॉग इन अनुरोधों के लिए मॉर्गन का उपयोग करना चाहते हैं, तो आप जाएं।

Comments

उस तरह की लॉगिंग के लिए आप क्या सलाह देते हैं?

— नूह

डीबग पैकेज वह है जो आप चाहते हैं। वास्तविक मूल विचार यह है कि console.log()आप अपने कोड में कहीं भी डिबग लिब का उपयोग कर सकते हैं और आपको इसे उत्पादन में हटाने के बारे में चिंता करने की आवश्यकता नहीं है। github.com/visionmedia/debug

— wgp

मुझे यह नहीं मिलता है ... अगर मेरे NodeJS ऐप में कोई त्रुटि होती है, तो क्या मैं उस त्रुटि को मॉर्गन का उपयोग करके लॉगफ़ाइल में रिकॉर्ड नहीं कर सकता हूं ? या विंस्टन, या बनियान? यदि नहीं तो मैं उसके लिए क्या उपयोग करूंगा?

— रैंडी एल

ओपी ने निहित किया कि वह मॉर्गन का उपयोग डेटा का निरीक्षण करने और विकास में अपने ऐप को डिबग करने के लिए करना चाहता है जो वास्तव में डिबग मॉड्यूल जैसी चीज के साथ किया जाना चाहिए। आपको उत्पादन में किसी फ़ाइल में त्रुटियों को पूरी तरह से लॉग इन करना चाहिए। यदि आप अपना ऐप सेट करते हैं जैसा कि मैं ऊपर दिए गए मेरे उत्तर में सुझाता हूं, तो त्रुटियां उत्पादन में फ़ाइल और विकास में कंसोल के लिए लॉग इन हो जाती हैं। यह स्पष्ट बातें करता है?

— wgp

Answer 4

मैंने पहले भी इसी समस्या का सामना किया था और इसके बजाय, मैंने विनस्टन का उपयोग किया था। जैसा कि ऊपर कहा गया है, मॉर्गन अनुरोध / प्रतिक्रिया के स्वचालित लॉगिंग के लिए है। विंस्टन को बहुत ही उसी तरह से कॉन्फ़िगर किया जा सकता है जैसे कि log4Net / log4J, में गंभीरता का स्तर, विभिन्न धाराएँ हैं जिनसे आप लॉग इन कर सकते हैं आदि।

उदाहरण के लिए:

npm install winston

फिर, यदि आप अनुप्रयोग प्रारंभ पर कहीं नीचे दिए गए कोड को कहते हैं:

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,
    },
});

नोट: ऊपर दिए गए कोड को कॉल करने से पहले, winston.loggers खाली है, यानी आपके पास अभी तक कोई भी लॉगर कॉन्फ़िगर नहीं है। Log4Net / J XmlConfigure विधियों की तरह बहुत सुंदर - आपको पहले अपने लॉगिंग को निकालने के लिए, उन्हें कॉल करने की आवश्यकता है।

फिर, बाद में जहाँ कहीं भी आप सर्वर साइड कोड अप्लाई कर सकते हैं:

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')

उम्मीद है की वो मदद करदे।

आगे के प्रलेखन संदर्भ के लिए: https://www.npmjs.com/package/winston

Comments

मुझे कहना होगा, डेवलपर्स के लिए जावा प्रकार की भाषाओं से MEAN स्टैक पर स्विच करने के लिए, यह उन्हें आरामदायक और परिचित बना देगा। धन्यवाद

— जयेश

क्या आप मुझे बता सकते हैं कि जब मेरा ऐप तैनात किया जाता है तो मैं इस लॉग फ़ाइल का उपयोग कैसे कर सकता हूं, वास्तव में मैं क्लाउड स्टोरेज पर लॉग फाइल को सहेजना चाहता हूं, लेकिन एक उचित तरीका नहीं खोज पा रहा हूं

— अभय सहगल

Answer 5

मॉर्गन: - मॉर्गन एक मिडलवेयर है जो हमें उन ग्राहकों की पहचान करने में मदद करेगा जो हमारे एप्लिकेशन को एक्सेस कर रहे हैं। मूल रूप से एक लकड़हारा।

मॉर्गन का उपयोग करने के लिए, हमें निम्न चरणों का पालन करने की आवश्यकता है: -

1. नीचे दिए गए कमांड का उपयोग करके मॉर्गन स्थापित करें:

npm install --save morgan

यह json.package फ़ाइल में मॉर्गन जोड़ देगा

2. अपने प्रोजेक्ट में मॉर्गन को शामिल करें

var morgan = require('morgan');

3> // एक राइट स्ट्रीम बनाएं (एपेंड मोड में)

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

नोट: सुनिश्चित करें कि आप आँख बंद करके ऊपर नहीं गिरते हैं सुनिश्चित करें कि आपके पास हर वह स्थिति है जहाँ आपको ज़रूरत है।

उपयोगकर्ता द्वारा आपके ऐप तक पहुंचने के बाद ऊपर एक स्वचालित रूप से आपके रूट पर एक एक्सेस .log फ़ाइल बन जाएगी।

Answer 6

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!')
});

उदाहरण नोडज + एक्सप्रेस + मॉर्गन

Answer 7

मेरे मामले में:

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

FIX: मैं विज़ुअल स्टूडियो कोड का उपयोग कर रहा था, और मुझे इसे अपने लॉन्च कॉन्फ़िगरेशन में जोड़ना था

"outputCapture": "std"

सुझाव, यदि आप एक IDE से चल रहे हैं, तो यह सुनिश्चित करने के लिए कमांड लाइन से सीधे चलाएँ कि IDE समस्या का कारण नहीं है।

Comments

console.log()मानक उत्पादन के लिए भी नहीं लिख रहा है?

— पुरानी गीजर

Answer 8

आप मोंगो-मॉर्गन-एक्सट का उपयोग करके प्रयास करना चाह सकते हैं

उपयोग है:

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

अपेक्षित आउटपुट है

{
    "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": ""
    }

}

Answer 9

मॉर्गन का उपयोग करना बहुत सीधा है। जैसा कि प्रलेखन से पता चलता है, मॉर्गन के साथ अपने वांछित आउटपुट प्राप्त करने के विभिन्न तरीके हैं। यह प्रीकोफिगर्ड लॉगिंग विधियों के साथ आता है या आप स्वयं को परिभाषित कर सकते हैं। उदाहरण के लिए।

कॉन्स्ट मॉर्गन = आवश्यकता ('मॉर्गन')

app.use (मॉर्गन ( 'छोटे')

यह आपको प्रीकोन्फिगरेशन देगा जिसे छोटा कहा जाता है। आप अपने टर्मिनल में देखेंगे कि यह क्या करता है। यदि आप इस से संतुष्ट नहीं हैं और आप चाहते हैं कि उदाहरण के लिए अनुरोध url कह दें, तो यह वह जगह है जहाँ टोकन आते हैं।

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

फिर इसे इस तरह उपयोग करें:

app.use (मॉर्गन (': url')

इसके सभी हाइलाइट किए गए दस्तावेज़ों की जाँच करें।