Wie Zeilennummern zugreifen, wenn die Konsolen Firebug (oder ähnlich) api Einwickeln

Question

ich die Konsole API granulare Protokolliergrade sowie einige andere Zucker Funktionen zur Verfügung zu stellen gewickelt haben.

Dies funktioniert gut, ist das einzige Problem, dass Firebug (oder was auch immer andere Konsole) wird die Zeilennummer des Protokoll aus als die Linie kam die Konsole API selbst aufgerufen wird immer berichten.

Wie würden Sie vorschlagen, ich mache die Konsole die Zeilennummer melden Sie sich an dem ich meine Wrapper-Funktion aufrufen?

würde ich eine Cross-Browser-Lösung bevorzugen, aber in Ermangelung eines solchen eine Firebug-Plugin ein guter Anfang sein könnte.

FYI nenne ich meine loging Funktion wie so:

db.log(db.LogLevel.WARN, "Blah Blah Blah"); 

Answer 1

So ist das kürzlich wieder kam so habe ich beschlossen, besuche es noch einmal.

Jetzt bin ich älter und weiser, es ist mir klar, eine viel bessere Lösung als das, was ich versuchte zu tun, ist die Konsole Funktionen wie sie sind, aber selektiv ersetzen sie mit Dummy-Funktionen, wenn das Niveau heruntergefahren wird. Dies gibt mir eine feinkörnige Protokollierung und eine genaue Zeilennummernmeldung. Einige Funktionen sind von meiner vorherigen Lösung verloren gegangen, aber ich denke, dass dies ein akzeptabler Kompromiss ist.

Hier ist ein Teil-Schnipsel meines neuen Logging-lib, die die Hauptlösung

... 
levels : ["debug","info","warn","error"], 

    init : function(minLevel) { 
     var params = abm.getUrlParams(); 
     minLevel = params["debug"] || minLevel; 

     //TODO: firebug lite 
     window.console = window.console || {}; 

     var clear = false; 
     for (var i=0; i<self.levels.length; i++) { 
      var level = self.levels[i]; 
      originalFunctions[i] = originalFunctions[i] 
      || console[level] || fallback; 

      if (level && (clear || level===minLevel)) { 
       console[level] = originalFunctions[i]; 
       clear=true; 
      } else { 
       console[level] = suppressed(level); 
      } 
     } 

    } 
... 

Sie die vollständige Sache hier sehen zeigt: https://github.com/antiBaconMachine/abm-log

Answer 2

Regel die debug() oder Fehler mit() anstelle von log() Funktionen Zahlen verursachen Zeile angezeigt werden. Ich glaube, die Google Chrome-Konsole funktioniert ähnlich. (firebug reference)

Answer 3

Interessantes Problem ... kann ich für Sie einen Hack hat. Ich kann das jetzt nicht testen, aber ich denke, es könnte funktionieren.

Wir wissen, dass ein regelmäßiger Funktionsaufruf wird nicht funktionieren, also begann ich über #defines in C und Makros in verschiedenen anderen Sprachen zu denken. Leider hat Javascript das nicht, aber vielleicht ein eval Hack wird funktionieren. Ich erwarte, dass eval den Code ausführen wird, als ob es aus der gleichen Zeile kam - wenn nicht, bleh, den Rest dieser Antwort ignorieren.

Meine Methode funktioniert wie folgt:

1. Ihre db.log Funktion ändern zu eval-zu-Punkt (ja, ew)
2. Statt in Ihrem Loglevel als Argument vorbei, schaffen Funktionen für jeden von ihnen das gibt eine Zeichenfolge mit console.log darin und eine benutzerdefinierte Nachricht zurück.

Es sollte wie folgt aussehen:

db = {LogLevel: {}}; 
db.log = eval; 
db.LogLevel.warn = function(message) { 
    return "console.log('THIS IS A WARNING: " + message + "');"; 
}; 

Sie sollte der Lage sein, es so jetzt zu nennen:

db.log(db.LogLevel.warn("Blah blah blah")); 

Answer 4

//trust me, this way rocks! Auto prepend a logHead, yet keep correct line number displayed debug view. 
//Output sample: 
// 5/10 1:13:52.553 hi         a.js:100 
// 5/10 1:13:52.553 err         b.js:200 

    var Log = { 
     debug : true, 

     /* 
     * log.d(logData1, logData2, ...) 
     * --> console.log(getLogHead(), logData1, logData2, ...) 
     * 
     * @comment Using bind and property accesser 
     * @see http://ejohn.org/blog/javascript-getters-and-setters/ 
     */ 
     get d() { 
      if (!this.debug) return _emptyFunc; 
      return console.log.bind(console, this._getLogHeader()); 
     }, 

     /* 
     * output error info 
     */ 
     get e() { 
      return console.error.bind(console, this._getLogHeader()); 
     }, 

     /** 
     * get current time in 01/31 23:59:59.999 format 
     */ 
     _getLogHeader : function() { 

      var millisec = Date.now(); 
      this._dtNow.setTime(millisec); 
      //toLocaleString is 2013/01/31 23:59:59 
      return this._dtNow.toLocaleString().slice(5) + '.' + ('000' + millisec).slice(-3) + ' '; 
     }, 
     _dtNow: new Date(), 
     _emptyFunc: function() {} 
    }; 


    //enjoy it ! 
     Log.d('hi'); 
     Log.e('err'); 

Answer 5

Es gibt zwei Möglichkeiten, um die Protokollierung zu wickeln, ohne zu verlieren Kontext. Der erste ist ein bisschen hässlich von der Seite des Anrufers. Die zweite ist nur verwendbar, wenn Sie nicht die Details dessen, was protokolliert wurde, benötigen.

Siehe JSFiddle für eine Demo: http://jsfiddle.net/epQ95/1/

// logger method 1: allows for fully functional log-wrapping without losing context, 
//     but, it is very ugly from the caller's perspective. 
var debug = function() { 
    // do my extra special stuff 
    window.console.log("logging to server 1: ", arguments); 

    // do regular console logging, if possible 
    if (window.console && window.console.log) { 
     return window.console.log.apply.bind(window.console.log, window.console, arguments); 
    } else { 
     return function() {}; 
    } 
}; 

// caller 
debug("logger method", 1)(); 

// logger method 2: pretty calling, but you don't know what was logged, 
//     just that something definitely was. 
var Logger = {}; 
Logger.__defineGetter__("debug", function() { 
    // do my extra special stuff 
    window.console.log("logging to server 2: don't know what was logged"); 

    // do regular console logging, if possible 
    if (window.console && window.console.log) { 
     return console.log.bind(window.console); 
    } else { 
     return function() {}; 
    } 
}); 

// caller 
Logger.debug("logger method", 2);