actiongraph

KO | EN

gitlite — search

#javascript #hacktoberfest #ai #go #linux #nodejs #windows #awesome #kubernetes #pytorch #mcp #ios #openai #open-source

(★ 136)

Go build actiongraph debug visualiser.

파일 탐색기

최종 버전 다운로드 (.zip)

- - go.yml
- k9s-perfetto.png
- k9s-s3.dot
- k9s-s3.svg
- k9s-trace.json
- k9s.json
go.mod
go.sum
graph.go
LICENSE
main.go
README.md
top.go
tree.go
types.go

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# 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](https://raw.githubusercontent.com/icio/actiongraph/main/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](https://raw.githubusercontent.com/icio/actiongraph/main/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

actiongraph

파일 탐색기

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

actiongraph

파일 탐색기

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README