Get name of function that called current function

I want to be able to get the function name of the function that calls the log function for logging purposes without slowing down or making the log function too complicated.

.log.err:{[x;y]x y}[-2;]

For example, if I call .log.err"log error msg" inside function f1, I want it to append the function name. So it would print "log error msg f1".

I know I could run value .z.s and pass that through to .log.err but I don't want to add an additional argument to the function. Is there any good way to do this?

An alternative to Terry's solution, using some undocumented internal functions (i.e. could be subject to change in future versions of q). If we look at the code for the (documented) function .Q.bt, we find .Q.Ll and .Q.btx - we can use these to get the current call stack without trapping an error.

Here's an example script that extracts the function name (as well as file & line number) of the caller:

.log.err:{[x;y]
 d:dbg0[2]y;
 x d[`func]," [",d[`file],":",string[d`line],"] : ",y;
 }[-2]

dbg0:{[x;y]
 f:first x _ .Q.btx .Q.Ll`;
 d:`func`file`line!3#f[1];
 d[`line]+:sum"\n"=f[2]#f[1;3];
 d
 }

f1:{.log.err"test"}
f2:{.log.err"test"}
.jm.f:{.log.err"test"}

Note: we pass the arg 2 to dbg0 to remove dbg0 and .log.err from the call stack, thus leaving the top frame as the caller of .log.err. If you were to move the code from dbg0 into .log.err instead of a separate function, you'd want to change this to only drop 1 frame i.e. .log.err.

Demo of this in use:

q)f1[]
..f1 [/home/jmcmurray/test.q:15] : test
q)f2[]
..f2 [/home/jmcmurray/test.q:16] : test
q).jm.f[]
.jm.f [/home/jmcmurray/test.q:17] : test

Note that functions in top-level namespace are prefaced with .. to indicate this. Of course you could change how this is formatted etc.

For a function defined interactively, rather than within a script, this is shown with no file & line number 0 i.e.

q)f3:{.log.err"test"}
q)f3[]
..f3 [:0] : test

Again as Terry mentioned you may want to look more at the backtrace output to generalise this.

Credit to Steve Caron for this approach which was posted to the k4 listbox on 2023.05.24:

f1:{a:1;.log.err"foo";a+x};
f2:{a:2;.log.err"bar";a+x};
curstack:{.Q.trp[{'err};();{3_y}]};
.log.err:{[x;y]x y," - ",last[curstack`][1;3]}[-2;];

q)f1[10]
foo - f1[10]
11
q)f2[10]
bar - f2[10]
12

I don't think this will work in every situation - you should study the backtrace output in more detail as you would likely need to generalise this a bit more. https://code.kx.com/q/ref/dotq/#trp-extend-trap