kapitan 0.35.2.dev29__tar.gz → 0.35.2.dev30__tar.gz

{kapitan-0.35.2.dev29 → kapitan-0.35.2.dev30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kapitan
-Version: 0.35.2.dev29
+Version: 0.35.2.dev30
 Summary: Generic templated configuration management for Kubernetes, Terraform and other things
 Project-URL: Homepage, https://kapitan.dev
 Project-URL: Repository, https://github.com/kapicorp/kapitan
@@ -57,6 +57,8 @@ Provides-Extra: oci
 Requires-Dist: oras>=0.2.0; extra == 'oci'
 Provides-Extra: omegaconf
 Requires-Dist: omegaconf<3,>=2.4.0.dev3; extra == 'omegaconf'
+Provides-Extra: profile
+Requires-Dist: pyinstrument<6,>=4.6; extra == 'profile'
 Provides-Extra: rapidyaml
 Requires-Dist: rapidyaml<1,>=0.12; extra == 'rapidyaml'
 Provides-Extra: reclass-rs

kapitan-0.35.2.dev30/docs/pages/profiling.md

@@ -0,0 +1,172 @@
+# Profiling Kapitan runs
+
+Kapitan ships with optional CPU and memory profiling that you can enable from
+any subcommand (`compile`, `inventory`, `eval`, …). Reports are written to a
+configurable output directory, one file per run (and per worker PID, if you
+opt in).
+
+## Quick start
+
+CPU profiling uses [`pyinstrument`](https://github.com/joerick/pyinstrument)
+(optional dependency). Memory profiling uses the standard library
+`tracemalloc` module and needs no extra install.
+
+```bash
+# install the optional CPU profiler
+pip install 'kapitan[profile]'
+
+# CPU profile a compile run, write an interactive HTML report
+kapitan --profile compile
+
+# CPU + memory profile, with workers, custom output dir
+kapitan --profile --profile-workers --memory-profile \
+        --profile-output-dir ./profiles \
+        compile
+
+# Text report straight to a file (and stderr summary)
+kapitan --profile --profile-format text compile
+```
+
+By default reports land in `./kapitan-profiles/`:
+
+```
+kapitan-profiles/
+├── kapitan-compile-20260508-101502-pid12345.html        # parent CPU
+├── kapitan-worker-20260508-101503-pid12346.html         # worker CPU (--profile-workers)
+├── kapitan-worker-20260508-101503-pid12347.html
+└── kapitan-compile-20260508-101502-pid12345.memory.txt  # memory (--memory-profile)
+```
+
+## CLI flags
+
+| Flag | Default | Description |
+|---|---|---|
+| `--profile` | off | Enable pyinstrument CPU profiling for the parent process. |
+| `--profile-workers` | off | Also profile each `multiprocessing` worker; one report per PID. Requires `--profile`. |
+| `--profile-serial` | off | Run target compilation serially in the parent (no Pool). Produces a single unified flame graph with full depth. See *Why am I only seeing `IMapUnorderedIterator.next`?* below. |
+| `--profile-format` | `html` | One of `html`, `text`, `json`, `speedscope`. |
+| `--profile-interval` | `0.001` | pyinstrument sampling interval (seconds). Lower = more detail, more overhead. |
+| `--profile-output-dir` | `kapitan-profiles` | Directory to write reports into (created if missing). |
+| `--memory-profile` | off | Enable `tracemalloc` snapshot diff; writes a top-N allocation report. |
+| `--memory-profile-top` | `30` | Number of top allocators to include. |
+
+The flags are global (registered on the top-level parser), so they go
+*before* the subcommand:
+
+```bash
+kapitan --profile compile -t my-target     # ✅
+kapitan compile --profile -t my-target     # ❌ (argparse error)
+```
+
+## Choosing an output format
+
+- **html** (default) — interactive flame-graph-style report, open in any
+  browser. Best for exploration.
+- **speedscope** — drop the file into <https://www.speedscope.app/>.
+- **json** — machine-readable for custom dashboards / CI diffing.
+- **text** — printed to stderr *and* written to disk; great for CI logs and
+  quick `grep`.
+
+## Why am I only seeing `IMapUnorderedIterator.next`?
+
+`pyinstrument` is a sampling profiler — it can only observe the **current
+Python process**. `kapitan compile` farms target compilation out to a
+`multiprocessing.Pool`, so the parent process spends almost all its time
+blocked in `IMapUnorderedIterator.next` waiting for child results. The
+interesting work (kadet, jinja, jsonnet, kustomize, helm…) happens in
+separate child processes whose stacks the parent's profiler physically
+cannot see.
+
+You have two ways to see deeper:
+
+### Option A — `--profile-workers` (production-shaped)
+
+Keeps the multiprocessing pool. Each worker self-profiles and writes its
+own report. Best for understanding real-world behaviour and per-target
+variance.
+
+```bash
+kapitan --profile --profile-workers compile
+```
+
+Load the resulting `kapitan-worker-*.speedscope.json` files into
+<https://www.speedscope.app/> (it accepts multiple profiles in tabs).
+
+### Option B — `--profile-serial` (single unified flame graph)
+
+Bypasses the Pool entirely and runs every target's compilation inline in
+the parent process. The single pyinstrument report then contains the
+**full call tree** including all input-type internals.
+
+```bash
+kapitan --profile --profile-serial compile
+```
+
+Use this when you're answering "where is time being spent?" — it's the
+clearest possible view. Trade-off: wall-clock is slower (no parallelism)
+and peak memory is higher (everything runs in one process). Don't use it
+for production benchmarking.
+
+> Tip: combine `--profile-serial` with `--profile-format speedscope` and
+> the resulting JSON loads into speedscope.app as a single deep flame graph.
+
+## Profiling multiprocessing workers
+
+`kapitan compile` parallelises target compilation with a `multiprocessing.Pool`.
+The parent profile shows dispatch/IO/serial work, but **the actual compile
+work happens in workers**. Use `--profile-workers` to profile them too:
+
+```bash
+kapitan --profile --profile-workers compile
+```
+
+Each worker writes its own `kapitan-worker-<ts>-pid<PID>.<ext>` file. To get a
+unified view, you can convert the speedscope JSONs and load them as separate
+profiles in <https://www.speedscope.app/> (it supports multi-profile views).
+
+Worker profiling is wired via inherited environment variables, so it works
+with all `--mp-method` choices (`spawn`, `fork`, `forkserver`).
+
+## Memory profiling notes
+
+`pyinstrument` is a **CPU sampling profiler — it does not measure memory**.
+The `--memory-profile` flag uses Python's standard `tracemalloc` to take
+snapshots before and after the run and report the top allocation deltas.
+The text report includes:
+
+- current allocated bytes at end of run
+- peak allocated bytes during the run
+- the top *N* allocation sites with full traceback
+
+For deeper memory analysis (allocation timelines, native allocations, leak
+detection across long-running processes) consider running Kapitan under
+[`memray`](https://bloomberg.github.io/memray/) externally:
+
+```bash
+memray run -o kapitan.bin -m kapitan compile
+memray flamegraph kapitan.bin
+```
+
+## Overhead
+
+- pyinstrument at the default `0.001 s` interval typically adds **<5 %**
+  wall-clock overhead.
+- `tracemalloc` overhead is much higher (10–50 %) because every allocation is
+  intercepted. Only enable `--memory-profile` when you need it.
+
+## CI usage
+
+Profiles are deterministic per-PID-and-timestamp filenames, so it's safe to
+upload `kapitan-profiles/` as a CI artifact. Example GitHub Actions step:
+
+```yaml
+- name: Compile with profile
+  run: kapitan --profile --profile-format speedscope compile
+
+- name: Upload profile
+  if: always()
+  uses: actions/upload-artifact@v4
+  with:
+    name: kapitan-profile
+    path: kapitan-profiles/
+```

{kapitan-0.35.2.dev29 → kapitan-0.35.2.dev30}/kapitan/cli.py

@@ -22,6 +22,7 @@ from kapitan.initialiser import initialise_skeleton
 from kapitan.inputs.jsonnet import select_jsonnet_runtime
 from kapitan.inventory import AVAILABLE_BACKENDS, InventoryBackends
 from kapitan.lint import start_lint
+from kapitan.profiling import add_profiling_arguments, cpu_profile, memory_profile
 from kapitan.refs.base import RefController, Revealer
 from kapitan.refs.cmd_parser import handle_refs_command
 from kapitan.resources import generate_inventory, resource_callbacks, search_imports
@@ -106,6 +107,7 @@ def build_parser():
         help="set multiprocessing start method",
         choices=["spawn", "fork", "forkserver"],
     )
+    add_profiling_arguments(parser)
     subparser = parser.add_subparsers(help="commands", dest="subparser_name")
 
     inventory_backend_parser = argparse.ArgumentParser(add_help=False)
@@ -708,7 +710,13 @@ def main(*argv):
         logging_level = logging.INFO
     setup_logging(level=logging_level, force=True)
 
-    # call chosen command
-    args.func(args)
+    if getattr(args, "profile_workers", False) and not getattr(args, "profile", False):
+        logger.warning("--profile-workers has no effect without --profile")
+
+    # call chosen command, optionally wrapped in CPU/memory profilers.
+    # Order matters: memory_profile is the outer context so the tracemalloc
+    # snapshot covers pyinstrument's own teardown/render time too.
+    with memory_profile(args), cpu_profile(args):
+        args.func(args)
 
     return 0

kapitan-0.35.2.dev30/kapitan/profiling.py

@@ -0,0 +1,300 @@
+# SPDX-FileCopyrightText: 2026 The Kapitan Authors <kapitan-admins@googlegroups.com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+CPU and memory profiling helpers for Kapitan.
+
+CPU profiling is provided by `pyinstrument` (optional dependency: install with
+`pip install kapitan[profile]`). Memory profiling uses the `tracemalloc`
+module from the Python standard library, so it has no extra dependencies.
+
+This module is import-safe even when `pyinstrument` is not installed: the
+import is deferred until profiling is actually requested.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+import os
+import sys
+import tracemalloc
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Iterator
+
+
+logger = logging.getLogger(__name__)
+
+# Env vars used to propagate profiling settings to multiprocessing workers.
+# Pool workers (spawn/fork/forkserver) inherit the parent's environment, so
+# this is the simplest reliable channel.
+ENV_WORKER_DIR = "KAPITAN_PROFILE_WORKERS_DIR"
+ENV_WORKER_FORMAT = "KAPITAN_PROFILE_WORKERS_FORMAT"
+ENV_WORKER_INTERVAL = "KAPITAN_PROFILE_WORKERS_INTERVAL"
+
+_VALID_FORMATS = ("html", "text", "json", "speedscope")
+
+
+def _timestamp() -> str:
+    return datetime.now(tz=timezone.utc).strftime("%Y%m%d-%H%M%S")
+
+
+def _ensure_dir(path: str | os.PathLike) -> Path:
+    p = Path(path)
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def _import_pyinstrument():
+    """Import pyinstrument lazily and emit a helpful error if missing."""
+    try:
+        import pyinstrument
+    except ImportError as e:  # pragma: no cover - depends on optional install
+        raise SystemExit(
+            "Profiling requested but `pyinstrument` is not installed.\n"
+            "Install the optional dependency with:\n"
+            "    pip install 'kapitan[profile]'\n"
+            f"(original error: {e})"
+        ) from e
+    else:
+        return pyinstrument
+
+
+def _render_pyinstrument(profiler, fmt: str) -> tuple[str, str]:
+    """Return (rendered_output, file_extension) for a finished Profiler."""
+    fmt = fmt.lower()
+    if fmt not in _VALID_FORMATS:
+        raise ValueError(
+            f"Invalid profile format {fmt!r}; choose one of {_VALID_FORMATS}"
+        )
+    if fmt == "html":
+        return profiler.output_html(), "html"
+    if fmt == "json":
+        return profiler.output(
+            renderer=__import__(
+                "pyinstrument.renderers", fromlist=["JSONRenderer"]
+            ).JSONRenderer()
+        ), "json"
+    if fmt == "speedscope":
+        return profiler.output(
+            renderer=__import__(
+                "pyinstrument.renderers", fromlist=["SpeedscopeRenderer"]
+            ).SpeedscopeRenderer()
+        ), "speedscope.json"
+    # text
+    return profiler.output_text(unicode=True, color=False), "txt"
+
+
+@contextlib.contextmanager
+def cpu_profile(args) -> Iterator[None]:
+    """
+    Context manager that runs `pyinstrument` around the wrapped block when
+    `args.profile` is truthy. Writes a report to
+    `<profile_output_dir>/kapitan-<subcmd>-<ts>-pid<pid>.<ext>`.
+
+    Also sets env vars so that multiprocessing workers self-profile when
+    `args.profile_workers` is set.
+    """
+    if not getattr(args, "profile", False):
+        yield
+        return
+
+    pyinstrument = _import_pyinstrument()
+
+    interval = float(getattr(args, "profile_interval", 0.001) or 0.001)
+    fmt = getattr(args, "profile_format", "html") or "html"
+    out_dir = _ensure_dir(getattr(args, "profile_output_dir", "kapitan-profiles"))
+
+    if getattr(args, "profile_workers", False):
+        os.environ[ENV_WORKER_DIR] = str(out_dir)
+        os.environ[ENV_WORKER_FORMAT] = fmt
+        os.environ[ENV_WORKER_INTERVAL] = str(interval)
+        logger.info("Worker CPU profiling enabled; per-PID reports → %s", out_dir)
+
+    profiler = pyinstrument.Profiler(interval=interval, async_mode="enabled")
+    profiler.start()
+    logger.info(
+        "CPU profiling enabled (pyinstrument, interval=%.4fs, format=%s)",
+        interval,
+        fmt,
+    )
+    try:
+        yield
+    finally:
+        profiler.stop()
+        subcmd = getattr(args, "subparser_name", None) or "kapitan"
+        try:
+            rendered, ext = _render_pyinstrument(profiler, fmt)
+        except Exception as e:  # pragma: no cover - defensive
+            logger.error("Failed to render profile: %s", e)
+            return
+        out_path = out_dir / f"kapitan-{subcmd}-{_timestamp()}-pid{os.getpid()}.{ext}"
+        out_path.write_text(rendered)
+        logger.info("CPU profile written: %s", out_path)
+        # When in text mode, also echo a short summary to stderr so users see it.
+        if fmt == "text":
+            print("\n=== Kapitan CPU profile (pyinstrument) ===", file=sys.stderr)
+            print(rendered, file=sys.stderr)
+
+
+@contextlib.contextmanager
+def memory_profile(args) -> Iterator[None]:
+    """
+    Context manager that uses `tracemalloc` to take before/after snapshots
+    around the wrapped block when `args.memory_profile` is truthy, and
+    writes the top-N allocation diff to a text report.
+    """
+    if not getattr(args, "memory_profile", False):
+        yield
+        return
+
+    top_n = int(getattr(args, "memory_profile_top", 30) or 30)
+    out_dir = _ensure_dir(getattr(args, "profile_output_dir", "kapitan-profiles"))
+
+    # Start tracking. nframes=10 keeps stack depth informative without
+    # blowing up overhead too much.
+    tracemalloc.start(10)
+    logger.info("Memory profiling enabled (tracemalloc, top=%d)", top_n)
+    snapshot_before = tracemalloc.take_snapshot()
+    try:
+        yield
+    finally:
+        snapshot_after = tracemalloc.take_snapshot()
+        current, peak = tracemalloc.get_traced_memory()
+        tracemalloc.stop()
+
+        stats = snapshot_after.compare_to(snapshot_before, "lineno")[:top_n]
+        subcmd = getattr(args, "subparser_name", None) or "kapitan"
+        out_path = (
+            out_dir / f"kapitan-{subcmd}-{_timestamp()}-pid{os.getpid()}.memory.txt"
+        )
+
+        lines = [
+            "Kapitan memory profile (tracemalloc)",
+            f"  current allocations at end of run: {current / (1024 * 1024):.2f} MiB",
+            f"  peak allocations during run:       {peak / (1024 * 1024):.2f} MiB",
+            f"  top {top_n} allocation deltas:",
+            "",
+        ]
+        for i, stat in enumerate(stats, 1):
+            lines.append(f"#{i}: {stat}")
+            for tb_line in stat.traceback.format():
+                lines.append(f"    {tb_line}")
+            lines.append("")
+
+        report = "\n".join(lines)
+        out_path.write_text(report)
+        logger.info("Memory profile written: %s", out_path)
+
+
+@contextlib.contextmanager
+def worker_profile() -> Iterator[None]:
+    """
+    Context manager used inside multiprocessing workers. Activates only when
+    the parent has set `KAPITAN_PROFILE_WORKERS_DIR` (i.e. user passed
+    `--profile-workers`). Each worker dumps its own per-PID report.
+    """
+    out_dir = os.environ.get(ENV_WORKER_DIR)
+    if not out_dir:
+        yield
+        return
+
+    try:
+        pyinstrument = _import_pyinstrument()
+    except SystemExit:
+        # In a worker, never abort the run because of profiling setup failures.
+        logger.warning("Worker profiling requested but pyinstrument not available")
+        yield
+        return
+
+    fmt = os.environ.get(ENV_WORKER_FORMAT, "html")
+    try:
+        interval = float(os.environ.get(ENV_WORKER_INTERVAL, "0.001"))
+    except ValueError:
+        interval = 0.001
+
+    profiler = pyinstrument.Profiler(interval=interval, async_mode="enabled")
+    profiler.start()
+    try:
+        yield
+    finally:
+        profiler.stop()
+        try:
+            rendered, ext = _render_pyinstrument(profiler, fmt)
+        except Exception as e:  # pragma: no cover - defensive
+            logger.error("Worker %d failed to render profile: %s", os.getpid(), e)
+            return
+        out_path = Path(out_dir) / (
+            f"kapitan-worker-{_timestamp()}-pid{os.getpid()}.{ext}"
+        )
+        try:
+            out_path.write_text(rendered)
+            logger.debug("Worker CPU profile written: %s", out_path)
+        except OSError as e:  # pragma: no cover - defensive
+            logger.error("Failed to write worker profile %s: %s", out_path, e)
+
+
+def add_profiling_arguments(parser) -> None:
+    """Register profiling-related CLI flags on the top-level parser."""
+    group = parser.add_argument_group(
+        "profiling",
+        "Optional CPU (pyinstrument) and memory (tracemalloc) profiling. "
+        "Install pyinstrument with: pip install 'kapitan[profile]'",
+    )
+    group.add_argument(
+        "--profile",
+        action="store_true",
+        default=False,
+        help="enable CPU profiling via pyinstrument for the parent process",
+    )
+    group.add_argument(
+        "--profile-workers",
+        action="store_true",
+        default=False,
+        help=(
+            "also CPU-profile multiprocessing workers; one report per worker PID. Requires --profile."
+        ),
+    )
+    group.add_argument(
+        "--profile-serial",
+        action="store_true",
+        default=False,
+        help=(
+            "run target compilation serially in the parent process (no "
+            "multiprocessing.Pool). Produces a single unified pyinstrument "
+            "report with full call-stack depth. Slower wall-clock but the "
+            "only way to see *all* stacks (including kadet/jinja/jsonnet "
+            "internals) in one flame graph. Implies/pairs well with --profile."
+        ),
+    )
+    group.add_argument(
+        "--profile-format",
+        choices=list(_VALID_FORMATS),
+        default="html",
+        help="pyinstrument output format (default: html)",
+    )
+    group.add_argument(
+        "--profile-interval",
+        type=float,
+        default=0.001,
+        help="pyinstrument sampling interval in seconds (default: 0.001)",
+    )
+    group.add_argument(
+        "--profile-output-dir",
+        default="kapitan-profiles",
+        help="directory for profile reports (default: ./kapitan-profiles)",
+    )
+    group.add_argument(
+        "--memory-profile",
+        action="store_true",
+        default=False,
+        help="enable memory profiling via tracemalloc; writes a top-N text report",
+    )
+    group.add_argument(
+        "--memory-profile-top",
+        type=int,
+        default=30,
+        help="number of top allocators to include in the memory report (default: 30)",
+    )

{kapitan-0.35.2.dev29 → kapitan-0.35.2.dev30}/kapitan/targets.py

@@ -21,6 +21,7 @@ from kapitan import cached
 from kapitan.dependency_manager.base import fetch_dependencies
 from kapitan.errors import CompileError, InventoryError, KapitanError
 from kapitan.inputs import get_compiler
+from kapitan.profiling import worker_profile
 from kapitan.resources import get_inventory
 
 
@@ -139,7 +140,19 @@ def compile_targets(inventory_path, search_paths, ref_controller, args):
 
             # compile_target() returns None on success
             # so p is only not None when raising an exception
-            [p.get() for p in pool.imap_unordered(worker, target_objs) if p]
+            if getattr(args, "profile_serial", False):
+                # Serial in-process mode: bypass the Pool so a single
+                # pyinstrument profile in the parent contains the full
+                # call tree (kadet/jinja/jsonnet internals included).
+                # Wall-clock is slower but visibility is complete.
+                logger.info(
+                    "--profile-serial: compiling %d targets serially in the parent process",
+                    len(target_objs),
+                )
+                for target_obj in target_objs:
+                    worker(target_obj)
+            else:
+                [p.get() for p in pool.imap_unordered(worker, target_objs) if p]
 
             os.makedirs(compile_path, exist_ok=True)
 
@@ -275,6 +288,22 @@ def compile_target(
     target_config, search_paths, compile_path, ref_controller, args, globals_cached=None
 ):
     """Compiles target_obj and writes to compile_path"""
+    # worker_profile() is a no-op unless the parent set the
+    # KAPITAN_PROFILE_WORKERS_DIR env var (i.e. user passed --profile-workers).
+    with worker_profile():
+        return _compile_target_impl(
+            target_config,
+            search_paths,
+            compile_path,
+            ref_controller,
+            args,
+            globals_cached,
+        )
+
+
+def _compile_target_impl(
+    target_config, search_paths, compile_path, ref_controller, args, globals_cached=None
+):
     start = time.time()
     compile_configs = target_config.compile
     target_name = target_config.vars.target

{kapitan-0.35.2.dev29 → kapitan-0.35.2.dev30}/mkdocs.yml

@@ -100,16 +100,17 @@ nav:
       - Kapitan vs Helm vs Kustomize: pages/kapitan_vs_helm_kustomize.md
       - Examples: pages/kapitan_examples.md
       - Glossary: pages/glossary.md
+      - Profiling: pages/profiling.md
       - Inventory:
-        - Introduction: pages/inventory/introduction.md
-        - Targets: pages/inventory/targets.md
-        - Classes: pages/inventory/classes.md
-        - Parameters Interpolation: pages/inventory/parameters_interpolation.md
-        - Advanced: pages/inventory/advanced.md
-        - Backends:
-          - Introduction: pages/inventory/backends.md
-          - reclass-rs: pages/inventory/reclass-rs.md
-          - omegaconf: pages/inventory/omegaconf.md
+          - Introduction: pages/inventory/introduction.md
+          - Targets: pages/inventory/targets.md
+          - Classes: pages/inventory/classes.md
+          - Parameters Interpolation: pages/inventory/parameters_interpolation.md
+          - Advanced: pages/inventory/advanced.md
+          - Backends:
+              - Introduction: pages/inventory/backends.md
+              - reclass-rs: pages/inventory/reclass-rs.md
+              - omegaconf: pages/inventory/omegaconf.md
       - Input Types:
           - Introduction: pages/input_types/introduction.md
           - Kadet: pages/input_types/kadet.md
@@ -123,11 +124,11 @@ nav:
           - Remove: pages/input_types/remove.md
       - References: references.md
       - Advanced Kapitan:
-        - Remote repositories: pages/remote_repositories.md
-        - External dependencies: pages/external_dependencies.md
-        - Publishing generators: pages/publishing_generators.md
-        - ArgoCD integration: pages/argocd.md
-        - FluxCD integration: pages/fluxcd.md
+          - Remote repositories: pages/remote_repositories.md
+          - External dependencies: pages/external_dependencies.md
+          - Publishing generators: pages/publishing_generators.md
+          - ArgoCD integration: pages/argocd.md
+          - FluxCD integration: pages/fluxcd.md
       - CLI reference:
           - compile: pages/commands/kapitan_compile.md
           - inventory: pages/commands/kapitan_inventory.md
@@ -136,7 +137,7 @@ nav:
           - validate: pages/commands/kapitan_validate.md
           - kapitan dotfile: pages/commands/kapitan_dotfile.md
   - Blog:
-    - pages/blog/index.md
+      - pages/blog/index.md
   - Support:
       - Ask for support: support.md
       - Troubleshooting: pages/troubleshooting.md
@@ -145,8 +146,8 @@ nav:
       - Sponsor Us: pages/contribute/sponsor.md
       - Talk about Kapitan: pages/contribute/talk.md
       - Active contributions:
-        - Documentation: pages/contribute/documentation.md
-        - Kapitan Code: pages/contribute/code.md
+          - Documentation: pages/contribute/documentation.md
+          - Kapitan Code: pages/contribute/code.md
   - Generators: https://generators.kapitan.dev
   - Tesoro: https://github.com/kapicorp/tesoro
   - Kapitan Reference: https://github.com/kapicorp/kapitan-reference

{kapitan-0.35.2.dev29 → kapitan-0.35.2.dev30}/pyproject.toml

@@ -86,6 +86,8 @@ oci = ["oras>=0.2.0"]
 # Enables the rapidyaml (ryml) C++ YAML emitter via --yaml-use-rapidyaml.
 # Several times faster than PyYAML on large manifests; safe to omit.
 rapidyaml = ["rapidyaml>=0.12,<1"]
+# CPU profiling. Memory profiling uses stdlib tracemalloc and needs no extras.
+profile = ["pyinstrument>=4.6,<6"]
 
 [project.urls]
 Homepage = "https://kapitan.dev"