https://github.com/icio/actiongraph

Go build actiongraph debug visualiser.
https://github.com/icio/actiongraph

Last synced: 12 months ago
JSON representation

Go build actiongraph debug visualiser.

Host: GitHub
URL: https://github.com/icio/actiongraph
Owner: icio
License: mit
Created: 2023-05-09T16:08:13.000Z (about 3 years ago)
Default Branch: main
Last Pushed: 2024-02-22T10:34:12.000Z (over 2 years ago)
Last Synced: 2025-04-23T22:25:27.947Z (about 1 year ago)
Language: Go
Homepage:
Size: 1.18 MB
Stars: 107
Watchers: 11
Forks: 3
Open Issues: 0
Metadata Files:
- Readme: README.md
- License: LICENSE

Awesome Lists containing this project

README

# actiongraph

> 👋 We wrote this to figure out why our CI had slowed down a bit and found
> something was accidentally compiling in much more Kubernetes than an offline
> CLI needed. If you enjoy writing performant Go too, please do considering
> joining us in the fight against fraud: [ravelin.com/careers].

`actiongraph` is a CLI for investigating where `go build` is spending its time
compiling. It consumes the file written using the compile.json output by `go
build -debug-actiongraph=compile.json`, which includes information about compile
steps and dependencies between packages.

`actiongraph` can help you identify which packages take a lot of compilation
time with `top`, summarise where that time is spent with `tree`, and identify
where the dependencies come from with `graph --why`.

Alongside the `-debug-actiongraph` flag is the `-debug-trace` flag which this
program does not use, but is a similarly instructive tool which can help you
identify parallelism and build order. For completeness, it is also shown below.

> ℹ Both the `-debug-actiongraph` and `-debug-trace` flags are not supported and
> deliberately not documented by the Go team:
> https://github.com/golang/go/commit/8fce59eab5cb2facfafca89e047b4b43ba44785f.

## Installation

go install github.com/icio/actiongraph@latest

## Usage overview

# Optionally clear your go build cache, if you're wanting to understanding why
# a build in CI is taking a while (depending on its cache reuse):
go clean -cache

# Compile your program using the undocumented -debug-actiongraph flag:
go build -debug-actiongraph=compile.json ./my-prog

# Show the slowest individual packages:
actiongraph top -f compile.json

# Show aggregate time spent compiling nested packages:
actiongraph tree -f compile.json

# Show aggregate time spent compiling github packages:
actiongraph tree -f compile.json -L 2 github.com

# Render dependency diagrams of packages, focusing on why PKG was compiled in:
actiongraph graph --why PKG -f compile.json > compile-pkg.dot
dot -Tsvg -Grankdir=LR < compile-pkg.dot > compile-pkg.svg

## Worked example

In this example, we're going to look inside one of @icio's favourite CLIs,
https://k9scli.io/.

First, let's check that we're all set up:

go version
actiongraph -h

then create our demo space:

mkdir demo
cd demo

We want to investigate a fresh build, so let's clear the build cache:

go clean -cache

Now we compile. We're going to specify body `-debug-actiongraph` and `-debug-trace` here so we can compare the results. (And we're going to send the compiled binary into a temporary directory.)

GOBIN=$(mktemp -d) go install -debug-actiongraph=k9s.json -debug-trace=k9s-trace.json github.com/derailed/k9s@v0.27.4

We should have a new file called `k9s.json` describing the actiongraph. Let's take a look at the first few entries `jq '.[:5] | .[]' -c < k9s.json`:

So let's find the compile steps that took the longest:

$ actiongraph -f k9s.json top
9.016s 2.75% build k8s.io/api/core/v1
6.026s 4.59% link github.com/derailed/k9s
5.071s 6.13% build github.com/aws/aws-sdk-go/service/s3
3.620s 7.23% build github.com/aws/aws-sdk-go/aws/endpoints
3.474s 8.29% build net/http
3.215s 9.27% build net
2.869s 10.15% build github.com/google/gnostic/openapiv2
2.846s 11.02% build github.com/google/gnostic/openapiv3
2.581s 11.80% build k8s.io/apimachinery/pkg/apis/meta/v1
2.476s 12.56% build google.golang.org/protobuf/internal/impl
2.186s 13.22% build github.com/gogo/protobuf/proto
1.974s 13.83% build k8s.io/api/extensions/v1beta1
1.919s 14.41% build github.com/derailed/tview
1.898s 14.99% build k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1
1.840s 15.55% build github.com/klauspost/compress/zstd
1.796s 16.10% build github.com/derailed/k9s/internal/view
1.671s 16.61% build k8s.io/kubectl/pkg/describe
1.658s 17.11% build github.com/prometheus/procfs
1.624s 17.61% build k8s.io/api/apps/v1
1.596s 18.09% build runtime

By default, `actiongraph top` will show the 20 slowest steps. This may be
overridden using the `-n0` flag. For example, to get the fastest steps we could
check:

$ actiongraph -f k9s.json top -n0 | tail -5
0.006s 100.00% build google.golang.org/protobuf/internal/flags
0.000s 100.00% link-install github.com/derailed/k9s
0.000s 100.00% nop
0.000s 100.00% built-in package unsafe
0.000s 100.00% go install

Here we can see that the second column is showing the cumulative percentage of
time spent up to that package.

We can summarise the time spent within package domain/directories using the
`tree` subcommand:

$ actiongraph -f k9s.json tree -L 1
322.013s (root)
154.673s k8s.io
83.357s github.com
40.294s std
12.338s sigs.k8s.io
10.886s golang.org
7.178s google.golang.org
5.413s helm.sh
2.428s gopkg.in
2.344s go.starlark.net
1.702s go.opentelemetry.io
1.400s oras.land

We can see that we spent 322 seconds compiling k9s, though some of that compilation would have happened in parallel, and so the

We've rolled up all standard libraries under `std`:

$ actiongraph -f k9s.json tree encoding
322.013s (root)
40.294s std
1.942s 0.017s std/encoding
0.572s 0.572s std/encoding/json
0.564s 0.564s std/encoding/xml
0.207s 0.207s std/encoding/asn1
0.192s 0.192s std/encoding/binary
0.096s 0.096s std/encoding/csv
0.080s 0.080s std/encoding/hex
0.074s 0.074s std/encoding/base64
0.073s 0.073s std/encoding/pem
0.067s 0.067s std/encoding/base32

Let's look at which github repos are taking the longest to compile:

$ actiongraph -f k9s.json tree github.com -L 2 | head -15
322.013s (root)
83.357s github.com
17.307s github.com/aws
17.307s github.com/aws/aws-sdk-go
16.360s github.com/derailed
7.674s 0.017s github.com/derailed/k9s
4.517s github.com/derailed/popeye
2.250s github.com/derailed/tcell
1.919s 1.919s github.com/derailed/tview
8.206s github.com/google
6.524s github.com/google/gnostic
1.014s github.com/google/go-cmp
0.277s 0.277s github.com/google/btree
0.163s 0.115s github.com/google/gofuzz
0.150s 0.150s github.com/google/uuid

We saw from `top` that package github.com/aws/aws-sdk-go/service/s3 was one of the slowest to compile. To understand why, we're going to use the `graph` subcommand which can filter down the dependency list to highlight all import paths leading from our build target to the package indicated by `--why PKG`:

actiongraph -f k9s.json graph --why github.com/aws/aws-sdk-go/service/s3 > k9s-s3.dot

and then render it using [Graphviz](https://graphviz.org/)'s `dot`:

dot -Tsvg < k9s-s3.dot > k9s-s3.svg

which looks something like this:

![actiongraph graph --why github.com/aws/aws-sdk-go/service/s3 -f demo/k9s-s3.json](demo/k9s-s3.svg)

Lastly we can open our k9s-trace.json in https://ui.perfetto.dev/ or Google
Chrome/Chromium's chrome://tracing. This shows us how successfully the scheduler
utilises the multiple cores on our machine when compiling each package:

![k9s-trace.json in perfetto](demo/k9s-perfetto.png)

At the time of writing, `-debug-trace` is under development in
https://github.com/golang/go/issues/38714.

[ravelin.com/careers]: https://www.ravelin.com/careers?utm_medium=referral&utm_source=github&utm_campaign=actiongraph

ecosyste.ms

Data

Tools

Indexes

Applications

Experiments

Awesome

https://github.com/icio/actiongraph

Awesome Lists containing this project

README