How to set source code path in umbrella application?

[hkrutzer]

Environment

• Elixir version (elixir -v): 1.8
• Erlang/OTP version (erl): 22
• Sentry version (mix deps): 7
• Operating system:

Description

root_source_code_path takes a string for a single path, but an umbrella applications has multiple paths. Does the client support this? If so how should I configure this?

[mitchellhenke]

@hkrutzer hey, thanks for opening an issue!

I haven't done as much testing on umbrella applications compared to standard applications, but things should work for the most part.

I'll dig deeper later this week to see how well source code path stuff works for umbrella apps, but I would start by trying:

root_source_code_path: "apps/**/lib/**/*.ex"
# OR
root_source_code_path: "apps/{app1, app2}/lib/**/*.ex"

If it's helpful in your attempts, Sentry uses Path.wildcard/2 under the hood to build the list of files

[hkrutzer]

hey @mitchellhenke thank you for your reply :)

The regex works but it looks like the files aren't mapped correctly, because the stacktrace does not contain the path to the app; e.g. if I have an app called app1 in apps/app1, the stacktrace will look like lib/app1/web/controllers/user_controller.ex, and not contain theapps/app1 part.

[mitchellhenke]

@hkrutzer do you typically configure Sentry at the root level?

It seems like configuring Sentry in each child application using the default configuration would work, could you give that a shot?

There's potential to have some configuration to trim the "apps/app1", etc. from the search, but I would need to do some more research into the structure of umbrella apps and dependency configuration.

[chulkilee]

In umbrella app, all configuration is basically shared by all apps. So configuring Sentry in each child app does not make sense.

BTW in my case I added sentry to "common" app, and make all other children app depend on the common app.

[ohnit]

Does anyone have a solution for this that's worked for them yet?

[mitchellhenke]

Sorry for the delay! After some investigation I don't think this is easily feasible with the way that Sentry currently handles source files.

Without being able to configure the relative directory for children applications, the source file context on Sentry's side ends up building a map where the file names are from the top of the umbrella app structure. Example being : "apps/umbrella_phoenix_web/lib/umbrella_phoenix_web/application.ex". Stacktraces from exceptions have filenames relative to their child app like "lib/umbrella_phoenix_web/application.ex" which makes it difficult to match.

Ideally all of the stacktraces would be the full "apps/...." structure to avoid (probably rare) collisions, but it's a pretty murky area to solve that. I'm open to proposals to solve this, but I'm hesitant to do things like trying to match the subpaths to the full paths.

[ohnit]

@mitchellhenke I had two half-baked ideas:

1. Map modules to paths. Modules are mentioned in the stack trace and i believe they need to be unique.
2. Map file paths relative the app_path directories. The murky part here is that there is no guarantee that paths within directories will be unique relative to each other. If the app_path is known, it can be excluded from the paths currently done in load_files/0, then that map could be merged with one created using paths relative from app_paths, like so (forgive the really rough POC):

  root = "."
  path_pattern =  "**/*.ex" # Config.source_code_path_pattern()

  # can get from mix.exs 's :apps_path configuration or Mix.Project.apps_paths()
  app_directory = "apps"
  app_paths = [root, app_directory] |> Path.join() |> Kernel.<>("/*") |> Path.wildcard()

  app_paths
  |> Enum.flat_map(fn app_root_path ->
    Path.join(app_root_path, path_pattern)
    |> Path.wildcard()
    # |> exclude_files(exclude_patterns)
    |> Enum.map(fn path ->
      key = Path.relative_to(path, app_root_path)
      value = path # source_to_lines(File.read!(path))

      {key, value}
    end)
  end)
  |> Map.new()
)

I definitely understand the hesitation. If the file path collisions bothers you, it is possible to exclude any paths that are not unique before building the source map. Some source mapping is better than none, right 😬?

[mitchellhenke]

1. Modules are available from stacktraces, yeah. The tricky part is mapping the module to a file path at compile-time. Does Mix make that available at all? If there's not an internal tool for that, I'm not sure. Multi-module files complicates it.

2. I think this is more promising, but the complexity and potential surprise of it missing sometimes (or even wrong if there is a bug 🙂) worries me.

[ohnit]

I was looking into your questions for option 1, when I came across a way to get the full path for a module in an umbrella app. Get the paths from the umbrella apps, where the key is the atom for the that app.

app_paths =
  if Mix.Project.umbrella? do
    Mix.Project.apps_paths()
  else
    # unsure what you'd want here
    # app name is available via Mix.Project.config()[:app]
    # or only hav the path resolution only for umbrella apps
  end

# returns
[ 
  best_app: "apps/best_app",
  other_app: "apps/other_app"
]

Then when you look up a stack trace line:

Application.get_application(My.Module)

# returns
:best_app

Application.get_application(Enum)

# returns
:elixir

So if app_paths has a match, its path can be appended to the the file path before doing the source code lookup. No need to change logic for the source code mapping!

Btw, during my research, i found file paths can be overwritten at compile time with @file: https://hexdocs.pm/elixir/Module.html#module-file

And there's some stuff out there about getting source via a .beam if compiled with debug info, but I haven't looking into that much: https://stackoverflow.com/questions/55498322/pretty-print-elixir-source-code-from-dbgi-chunk

[mitchellhenke]

Thanks! I had seen @file, but forgotten about that caveat. Probably worth noting that in the docs.

The apps_paths I think is the preferable route.