Skip to main content

utargets

This document provides an overview of the commands and options available under buck2 utargets.

buck2 utargets​

Show details about the specified targets.

This command is meant to only handle unconfigured targets, but for historical reasons, with certain flags it can also work with configured targets.

Usage: buck2 utargets [OPTIONS] [TARGET_PATTERNS]...

Arguments:​

  • <TARGET_PATTERNS> Patterns to interpret

Common Options:​

Common options are documented on the Common Options page.

Options:​

  • --json Print targets as JSON

  • --json-lines Print targets as JSON-lines

  • --stats Print statistics of how many entries were processed

  • --resolve-alias Print the fully-qualified build target for the specified aliases

  • --show-target-hash Print a stable hash of each target after the target name

  • --show-unconfigured-target-hash Print a stable unconfigured hash of each target after the target name

  • --target-hash-file-mode <TARGET_HASH_FILE_MODE> Modifies computation of target hashes. If set to PATHS_AND_CONTENTS (the default), the contents of all files referenced from the targets will be used to compute the target hash. If set to PATHS_ONLY, only files' paths contribute to the hash. If set to NONE no files will be used. See also --target-hash-modified-paths

    • Default value: paths_and_contents
    • Possible values:
      • paths_only
      • paths_and_contents
      • none

  • --target-hash-modified-paths <TARGET_HASH_MODIFIED_PATHS> Modifies computation of target hashes. Only effective when --target-hash-file-mode is set to PATHS_ONLY. If a target or its dependencies reference a file from this set, the target's hash will be different than if this option was omitted. Otherwise, the target's hash will be the same as if this option was omitted

  • --target-hash-function <TARGET_HASH_FUNCTION> Selects either the "fast" or the "strong" target hash function to be used for computing target hashes. While we don't specify the exact algorithm, the "strong" algorithm should be a reasonable cryptographic hash (ex. blake3) while the "fast" function will likely be a non-crypto hash. Both functions are guaranteed to be deterministic and to have the same value across different platforms/architectures

    • Default value: fast
    • Possible values:
      • sha1
      • sha256
      • murmur-hash3
      • fast
      • strong

  • --target-hash-recursive <TARGET_HASH_RECURSIVE> When true, emit the hash or target node and all dependencies recursively. When false, hash only the target node

    • Default value: true
    • Possible values:
      • true
      • false

  • -A, --output-all-attributes Output all attributes, equivalent of --output-attribute ''.

    Avoid using this flag in automation because it may be expensive to produce certain attributes, and because it makes harder to track which special attributes are used.

  • -B, --output-basic-attributes Output basic attributes, namely those the user can supply, plus rule type and package name

  • -a, --output-attribute <ATTRIBUTE> Regular expressions to match attributes. Regular expressions are used in "search" mode, so for example empty string matches all attributes including special attributes.

    When using in automation, please specify the regular expression to match the attribute precisely, for example --output-attribute '^headers$' to make it easier to track which special attributes are used.

  • --output-attributes <ATTRIBUTE> Deprecated: Use --output-attribute instead.

    List of space-separated attributes to output, --output-attributes attr1 attr2.

  • --include-defaults Enables printing of default attributes. This would be attributes in a target that aren't explicitly set in the target but instead use the default set in the rule declaration

  • --show-output Print the path to the output for each of the rules relative to the project root

  • --show-full-output Print the absolute path to the output for each of the rules

  • --show-simple-output Print only the path to the output for each of the rules relative to the project root

  • --show-full-simple-output Print only the absolute path to the output for each of the rules

  • --show-json-output Print the output paths relative to the project root, in JSON format

  • --show-full-json-output Print the output absolute paths, in JSON format

  • --keep-going On loading errors, put buck.error in the output stream and continue

  • --streaming Write output as soon as it is available. The order of the output items is non-deterministic and if multiple patterns cover the same target, may have duplicates

  • --no-cache Don't cache the target information on the build graph

  • --imports Show the imports of each package/import. Shows an additional output per package/import (not per target), including implicit dependencies (e.g. the prelude) but only direct dependencies (not the transitive closure)

  • --package-values Show the package values. Produces an additional attribute representing all the package values for the package containing the target

  • --package-values-regex <VALUES> Regular expressions to match package values. Produces an additional attribute representing package values for the package containing the target. Regular expressions are used in "search" mode so, for example, empty string matches all package values

  • -o, --output <PATH> File to put the output in, rather than sending to stdout.

    File will be created if it does not exist, and overwritten if it does.

  • --compression <SCHEME> Compress the output

    • Default value: none
    • Possible values:
      • none
      • gzip
      • zstd

  • -j, --num-threads <THREADS> Number of threads to use during execution (default is # cores)

  • --target-platforms <PLATFORM> Configuration target (one) to use to configure targets

  • -m, --modifier <VALUE> A configuration modifier to configure all targets on the command line. This may be a constraint value target.

  • --disable-starlark-types Disable runtime type checking in Starlark interpreter.

    This option is not stable, and can be used only locally to diagnose evaluation performance problems.

  • --stack Record or show target call stacks.

    Starlark call stacks will be included in duplicate targets error.

    If a command outputs targets (like targets command), starlark call stacks will be printed after the targets.

  • --profile-patterns <PROFILE_PATTERNS> Enables profiling for all evaluations whose evaluation identifier matches one of the provided patterns.

    Some examples identifiers: analysis/cell//buck2/app/buck2_action_impl:buck2_action_impl (cfg:linux-x86_64#27ac5723e0c99706) load/cell//build_defs/json.bzl load/prelude//playground/test.bxl load/cell//build_defs/json.bzl@other_cell load_buildfile/fbcode//third-party-buck/platform010/build/ncurses load_packagefile/fbcode//cli/rust/cli_delegate anon_analysis/anon//:_anon_link_rule (anon: 766183dc9b6f680a) (fbcode//buck2/platform/execution:linux-x86_64#08961b14cfb182aa) bxl/prelude//playground/test.bxl:playground

    You can pass --profile-patterns=.* to enable no-op profiling for everything (additionally pass --profile-patterns-mode=none to use no-op profiling to just get a list of all the identifiers).

    The profile results will be written to individual .profile files in <ROOT_OUTPUT>/<data+time>-<uuid>/ where ROOT_OUTPUT comes from the --profile-patterns-output flag. In that directory there will also be a file listing all the identifiers that were profiled.

    Enabling/disabling profiling of an evaluation will invalidate the results of that evaluation and it will be recomputed. In some cases, this will cause other work to also need to be redone (for example, invalidating the result of loading PACKAGE files causes all consumers to be recomputed). But if you keep profiling options consistent between commands, only the work that is otherwise invalidated will be redone (and only for those would profiling results be created).

    You must also pass --profile-patterns-mode and --profile-patterns-output.

  • --profile-patterns-output <PATH>

  • --profile-patterns-mode <PROFILE_PATTERNS_MODE> Profile mode.

    Memory profiling modes have suffixes either -allocated or -retained.

    -retained means memory kept in frozen starlark heaps after analysis completes. -retained does not work when profiling loading, because no memory is retained after loading and frozen heap is not even created. This is probably what you want when profiling analysis.

    -allocated means allocated memory, including memory which is later garbage collected.

    • Possible values:
      • time-flame
      • heap-allocated
      • heap-retained
      • heap-flame-allocated
      • heap-flame-retained
      • heap-summary-allocated
      • heap-summary-retained
      • statement
      • bytecode
      • bytecode-pairs
      • typecheck
      • coverage
      • none