I'm looking for some debugging possibilities... When I run nix-build, it generates the top level derivation.. When looking through what its dependencies, I find some derivations I want to investigate.

(In this particular case, it's a package that ended up in a nixos vm disk image that I want to track down)

Is it possible to trace back where in my *.nix files the derivation comes from, and the call stack to get there?

I have no trouble finding the inputs for the derivation itself, but not what the inputs comes from.

I'm looking for some debugging possibilities... When I run nix-build, it generates the top level derivation.. When looking through what its dependencies, I find some derivations I want to investigate.

(In this particular case, it's a package that ended up in a nixos vm disk image that I want to track down, but that's just an example)

Is it possible to trace back where in my *.nix files the derivation comes from, and the call stack to get there?

I have no trouble finding the inputs for the derivation itself, but not what the inputs comes from.

Thanks for the reply,

That is for sure also helpful, but not really what I'm searching for. That focuses on what derivations depends on what other derivations. Not really what expressions that leads up to a derivation.

Imagine I have a derivation, created by a function:

integrate_modules.nix:

{ modules, ... }:
let
  internalMods = ...;
  mods = modules ++ [internalMods];
in
derivation {
  ...
  myModules = mods;
}

Then I use it from something modular, that packs modules from different sources:

let
   app_a = import my_app_a.nix {...};
   app_b = import my_app_b.nix {...};
   app_c = import my_app_c.nix {...};
   integration = import ./integrate_modules.nix {
      modules = app_a.modules ++ app_b.modules ++ app_c.modules;
   }
in
  integration.build

Or something similar.

In this the case above, it's the nixos configuration, which has packages, which depends on packages depending on configuration.

In some other case, I may have built the rules myself, but it can quickly start getting messy to see where every parameter comes from.

So in the second example, the derivation will show what parameters the varaible myModules contains, evaluated. But not if it comes from internalMods or app a, b or c.

So I'm looking for some way to debug the nix expressions internally.

The closest I've seen is builtins.trace, but it's quite hard when some of the nix rules comes from external sources (in this case nixpkgs), and therefore quite hard to modify to add them to start with.

So thinking if there is some kind of debugger, where it's possible to set breakpoints and print the stack for example, or something else similar

The question is more about the tooling, since I've ended up with the same issue earlier. But in the particular case above is that I'm trying to build nixos for a minimal embedded setup. And I've found that krb5 is installed, which I find odd. I can track down the dependencies, and see what derivation depends on it. But what I then want to see is, where do that derivation come from, and what are the configuration flags, and thus the call stack of the nix functions (not derivations) that leads up to the derivation.

Closest I've found is to add builtin.trace, but that implies I can change the derivation, which is pretty hard, since lot of the code comes from imported libraries (nixpkgs for example).

In reply to @pengipengi:matrix.org
I think what I'm looking for is nix repl --debugger, but being able to add breakpoints manually from command line. Is that possible?

Aha, I see 🙂 thanks, then I stop searching, and tries to solve the issue with the tools at hand.

No worries 🙂