Cómo obtener Llamadas a Funciones Javascript / Seguimiento en Tiempo de ejecución

Esto se llama perfilado y Chrome y Firebug lo tienen incorporado. En Chrome developer Tools, ve a la pestaña perfiles y haz clic en el botón grabar (círculo). Realice su ajax y después de su respuesta, haga clic en el botón grabar de nuevo para detenerse. Los resultados del perfil aparecerán en el panel derecho.

Tenga en cuenta que esto le dará todo así que si está utilizando una biblioteca como jQuery, la gran mayoría de las llamadas a funciones serán basura para usted. He probé esto un par de veces y me parece que es mucho más útil hacer la cosa console.log('inside <method>').

Tal vez puedas hacer que JavaScript haga parte del trabajo de agregar consola.registro para usted:

Añadir consola.registro de cada función automáticamente

También este blog de Paul Irish podría ayudar:

Http://paulirish.com/2009/log-a-lightweight-wrapper-for-consolelog /

Incluye un enlace a algunos JavaScript dirigidos específicamente a los argumentos de registro:

Http://pastie.org/1033665

Pruebe diyism_trace_for_javascript.htm:

Https://code.google.com/p/diyism-trace/downloads/list

eval('window.c=function(){3+5;}');
declare_ticks_for(window);

function a(k, c) {
  return k + 2;
}

function b() {
  4 + 3;
  a(3, {'a':'c','b':'d'});
  c();
  return 5 + 4;
}

b();

Ver los registros en la pestaña consola de chrome o firefox

Una variación de la solución de Briguy37, escribí una que acepta una función para llamar antes de cada método. También funciona con clases ECMAScript 6, donde los métodos no son enumerados por for...in. Lo estoy usando para modificar prototipos de objetos, para agregar registros a todas las nuevas instancias de mi objeto.

function inject(obj, beforeFn) {
    for (let propName of Object.getOwnPropertyNames(obj)) {
        let prop = obj[propName];
        if (Object.prototype.toString.call(prop) === '[object Function]') {
            obj[propName] = (function(fnName) {
                return function() {
                    beforeFn.call(this, fnName, arguments);
                    return prop.apply(this, arguments);
                }
            })(propName);
        }
    }
}

function logFnCall(name, args) {
    let s = name + '(';
    for (let i = 0; i < args.length; i++) {
        if (i > 0)
            s += ', ';
        s += String(args[i]);
    }
    s += ')';
    console.log(s);
}

inject(Foo.prototype, logFnCall);

He utilizado la solución de @Briguy37 con una mejora. En mi caso, no quería rastrear funciones de algunas bibliotecas, así que agregué algún código para excluirlas. Así es como se usa:

• Primero, incluya la definición de las funciones que no desea rastrear;
• excludeLoggingToNamespace para listar las funciones definidas hasta ahora y excluirlas;
• Incluya la definición de las funciones que desea rastrear;
• Llame a addLoggingToNamespace para agregar el registro capacidad para las funciones definidas en el paso anterior.

Ejemplo:

<script src="js/someLibrary.js"></script>
<script>
    functionLogger.excludeLoggingToNamespace(window);
</script>
<script src="js/codeIWantToTraceHere.js"></script>
<script>
    functionLogger.addLoggingToNamespace(window);
</script>

Aquí está el código que agregué a la solución de @Briguy37:

var excludedFunctions = {};

        functionLogger.excludeLoggingToNamespace = function(namespaceObject){
            for(var name in namespaceObject){
                var potentialFunction = namespaceObject[name];

                if(Object.prototype.toString.call(potentialFunction) === '[object Function]') {
                    excludedFunctions[name] = name;
                }
            }
        }; 

Y tuve que modificar el método addLoggingToNamespace de @Briguy37 para tener en cuenta el hash excludedFunctions:

functionLogger.addLoggingToNamespace = function(namespaceObject){
    for(var name in namespaceObject){
        var potentialFunction = namespaceObject[name];

        if(Object.prototype.toString.call(potentialFunction) === '[object Function]' && 
           !excludedFunctions[name]) {
            namespaceObject[name] = functionLogger.getLoggableFunction(potentialFunction, name);
        }
    }
};