Wie implementiert man eine Trace-Funktion für Tabelle zu Funktionen?

Question

Ich habe eine Tabelle wie diese

local ftable = { 
    getPinId = app.getPinId 
} 

ftable an eine andere Funktion übergeben wird, die es als eine RPC-Schnittstelle exportiert. Das funktioniert, aber jetzt möchte ich Funktionsaufrufverfolgung zu einer Protokolldatei hinzufügen.

Der einfache Ansatz ist

local ftable = { 
    getPinId = function(...) print("getPinId") app.getPinId(...) end 
} 

Aber, das ist nicht besonders schön ist. Ich mag etwas setzen wie:

local trace = function(func, ...) 
    return function(...) print(func) func(...) end 
end 

local ftable = { 
    getPinId = trace(app.getPinId) 
} 

Aber diese produzieren nicht ganz das gewünschte Ergebnis. Die Parameter werden nicht übergeben.

Eine andere Möglichkeit ist, eine Metatabelle wie diese verwenden:

local ftable = {} 
setmetatable(ftable, { 
    __index = function(_, k) 
    printf("Call: app.%s\n", k) return app[k] end 
}) 

Welche funktioniert. Aber ich möchte auch die Parameter, die nach Möglichkeit übergeben werden, drucken können.

Irgendwelche Vorschläge? Ich verwende ausschließlich luajit, wenn das einen Unterschied macht. stattdessen

Answer 1

einen Funktionsaufruf Verpackung ist leicht in Lua:

local function wrap(f) 
    local function after(...) 
    -- code to execute *after* function call to f 
    print("return values:", ...) 
    return ... 
    end 
    return function(...) 
    -- code to execute *before* function call to f 
    print("arguments:", ...) 
    return after(f(...)) 
    end 
end 


local function f(a, b, c) 
    return a+b, c-a 
end 

local f_wrapped = wrap(f) 
f_wrapped(1, 2, 3) 

Ausgang ist:

arguments: 1 2 3 
return values: 3 2 

Ein Problem für die Protokollierung/Tracing ist dass Lua-Werte (einschließlich Funktionen) selbst keine Namen haben. Die Debugbibliothek versucht, geeignete Namen für Funktionen zu finden, indem überprüft wird, wie sie aufgerufen werden oder wo sie gespeichert sind. Wenn Sie jedoch sicherstellen möchten, dass Sie einen Namen selbst angeben müssen. wenn Ihre Funktionen gespeichert sind, in (verschachtelten) Tabellen jedoch (wie in einem Kommentar angezeigt), können Sie eine Funktion schreiben, die die verschachtelten Tabellen iteriert, und wickeln alle Funktionen findet es den Tabellenschlüssel als Name:

local function trace(name, value) 
    local t = type(value) 
    if t == "function" then -- do the wrapping 
    local function after(...) 
     print(name.." returns:", ...) 
     return ... 
    end 
    return function(...) 
     print("calling "..name..":", ...) 
     return after(value(...)) 
    end 
    elseif t == "table" then -- recurse into subtables 
    local copy = nil 
    for k,v in pairs(value) do 
     local nv = trace(name.."."..tostring(k), v) 
     if nv ~= v then 
     copy = copy or setmetatable({}, { __index = value }) 
     copy[ k ] = nv 
     end 
    end 
    return copy or value 
    else -- other values are ignored (returned as is) 
    return value 
    end 
end 


local ftable = { 
    getPinId = function(...) return "x", ... end, 
    nested = { 
    getPinId = function(...) return "y", ... end 
    } 
} 

local ftableTraced = trace("ftable", ftable) 
ftableTraced.getPinId(1, 2, 3) 
ftableTraced.nested.getPinId(2, 3, 4) 

Ausgang ist:

calling ftable.getPinId: 1 2 3 
ftable.getPinId returns: x 1 2 3 
calling ftable.nested.getPinId: 2 3 4 
ftable.nested.getPinId returns: y 2 3 4 

Einige Dinge zu beachten:

1. Tabelle Tasten beliebig Lua Werte sein können, nicht nur ganz kurze Ketten von druckbaren Zeichen bestehen.
2. Tabellen können zyklische Referenzen enthalten. Wenn sie dies tun, wird die obige naive Implementierung mit einem Stapelüberlauf enden.

Answer 2

Verwenden metamethod die __call:

M = { __call = 
    function (t,...) print("calling ",t.name,...) return t.func(...) end 
} 

trace = function(func,name) 
    return setmetatable({func=func,name=name},M) 
end 

function f(...) 
    print("in f",...) 
end 

g=trace(f,"f") 
g(10,20,30)