How to get name of 'calling' module and/or function?

For Macro’s you can access the callers environment inside the __CALLER__ argument (implicitly passed in to every macro call).

It’s just a normal Macro.Env struct.

__CALLER__ returns the current calling environment as a Macro.Env struct; a struct that holds compile time environment information. That’s why you can’t use it in a quote block.

However, I need run time information. When function Two.foo/1 is calling function One.bar/1 as in the example, the caller should be Two.foo/1 (info might be split in callingMod en callingFunc)

A function should not care from where it is called. It should return the same regardless the caller.

If though you really have to, you could do it similar how logger injects metadata.

Use a macro which takes the arguments defined by your API, injects code to collect metadata and then delegates to a function that takes the actual arguments AND the collected metadata.

You can use Process.info(self(), :current_stacktrace) to get the current stacktrace (and the calling function should be there), but this is generally considered a debugging utility, not something to be used in production.

Additionally, be aware that tail calls don’t produce stack entries, so in a code like this:

def foo(), do: bar()
def bar(), do: Process.info(self(), :current_stacktrace)

The stacktrace information won’t include foo().

Figured it out myself, but michalmuska was right. Code became:

{callingMod, callingFunc, callingFuncArity, [file: _file, line: _line]} =
      Process.info(self(), :current_stacktrace) |> elem(1) |> Enum.fetch!(2)

Now I need to handle the ‘no stack entry’ situation, somehow

@NobbZ Will have a look at the proposal. Thanks for the input.

I’m exceptionally curious, “what” are you trying to accomplish? o.O

An insane experiment to build a non plug-based authorization code which can easily applied on existing modules, functions, con(n/text) and even arguments. In Phoenix applications authorization is quite easy as Phoenix uses conventions and does normalize a lot to (conn, object map, current_user). Custom applications don’t have such thing. I doubt I will even succeed, but it’s worth to spend a week of my free time on as I learn a lot

Had a working POC which needed environment variables to work; which would make it useless. If I can take those out, it might actually be a nice solution to secure an otherwise insecure codebase without much rewrites.

  @doc """
  Replace a function definition, adding a call to the authorization function.
  Example:
      defprot function(arg1, arg2), do: IO.inspect({arg1,arg2})
      function(1,2)

  will call authorize with this parameters

      authorizate(__MODULE__, :function, [arg1: 1, arg2: 2], nil)

  """

If there is a solid way to track which Module and Function did the request, it will also be possible to pattern match at those. Allowing (for example) to mimic defp (just because we can…) or reject all calls to functions which write to the database unless the authorization rules allow them to.

Edit: If I ever find a good solution, I will try to have it added to GitHub - arjan/decorator: Function decorators for Elixir · GitHub, as that lib is doing 90% of what I wrote already. Now only those few last bits…

Edit2: Gotta get some sleep…sigh

Status update:

It is possible, yet it has so many side effects it will never see an open repository for too many good reasons.

iex(auth@127.0.0.1)1> Example.test3
Example.test3() was called when no origin was set. Are you using IEX?
Example.test1() was called by an anonymous function with was called by Example.test3()
Example.test0() was called by Example.test1()
[info] Example.test0 requested authorization to access Example.test/3
[info] Access granted
#PID<0.421.0>
iex(auth@127.0.0.1)2>

Conclusion: Meta programming and message passing between processes rock. Never underestimate their power, but use them wisely.

Hah, interesting though. ^.^

I’ll clean up the POC one day and request some additional functionality in Elixir to make it possible without a zillion hacks. Now I have a demo to demonstrate the concept