Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
85 changes: 79 additions & 6 deletions internal/recorder/recorder.go
Original file line number Diff line number Diff line change
Expand Up @@ -8,6 +8,9 @@ import (
"context"
"encoding/json"
"fmt"
"regexp"
"strings"
"time"

"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/metric"
Expand All @@ -16,9 +19,20 @@ import (
// Recorder counts events without recording webhook text in attributes.
type Recorder struct {
events, merges, conclusions, dropped metric.Int64Counter
cycleTime metric.Float64Histogram
}

// New creates the counters used to record deliveries.
type pullRequest struct {
Body string `json:"body"`
CreatedAt string `json:"created_at"` //nolint:tagliatelle // GitHub uses this field name.
MergedAt string `json:"merged_at"` //nolint:tagliatelle // GitHub uses this field name.
ClosedAt string `json:"closed_at"` //nolint:tagliatelle // GitHub uses this field name.
Merged bool `json:"merged"`
}

// New creates the instruments used to record deliveries.
//
//nolint:mnd // The histogram has fixed cycle time buckets in seconds.
func New(meter metric.Meter) (*Recorder, error) {
var recorder Recorder

Expand All @@ -39,6 +53,16 @@ func New(meter metric.Meter) (*Recorder, error) {
*counter.target = instrument
}

var err error

recorder.cycleTime, err = meter.Float64Histogram("github.pr.cycle_time", metric.WithUnit("s"),
metric.WithExplicitBucketBoundaries(
60, 300, 900, 1800, 3600, 7200, 14400, 28800, 86400, 172800, 604800, 1209600,
))
if err != nil {
return nil, fmt.Errorf("create github.pr.cycle_time histogram: %w", err)
}

return &recorder, nil
}

Expand All @@ -59,9 +83,7 @@ func (r *Recorder) Record(ctx context.Context, event string, body []byte) error
Name string `json:"name"`
Conclusion string `json:"conclusion"`
} `json:"check_run"` //nolint:tagliatelle // GitHub uses this field name.
PullRequest struct {
Merged bool `json:"merged"`
} `json:"pull_request"` //nolint:tagliatelle // GitHub uses this field name.
PullRequest pullRequest `json:"pull_request"` //nolint:tagliatelle // GitHub uses this field name.
}

err := json.Unmarshal(body, &delivery)
Expand All @@ -80,8 +102,12 @@ func (r *Recorder) Record(ctx context.Context, event string, body []byte) error
r.events.Add(ctx, 1, metric.WithAttributes(repo,
attribute.String("event", event), attribute.String("action", delivery.Action)))

if event == "pull_request" && delivery.Action == "closed" && delivery.PullRequest.Merged {
r.merges.Add(ctx, 1, metric.WithAttributes(repo))
if event == "pull_request" && delivery.Action == "closed" {
if delivery.PullRequest.Merged {
r.merges.Add(ctx, 1, metric.WithAttributes(repo))
}

r.recordCycleTime(ctx, repo, delivery.PullRequest)
}

if event == "check_run" && delivery.Action == "completed" {
Expand All @@ -92,3 +118,50 @@ func (r *Recorder) Record(ctx context.Context, event string, body []byte) error

return nil
}

func (r *Recorder) recordCycleTime(ctx context.Context, repo attribute.KeyValue, request pullRequest) {
endText, state := request.ClosedAt, "closed"
if request.Merged {
endText, state = request.MergedAt, "merged"
}

end, err := time.Parse(time.RFC3339, endText)
if err != nil {
return
}

start, source := cycleStart(request)
if start.IsZero() || end.Before(start) {
return
}

r.cycleTime.Record(ctx, end.Sub(start).Seconds(), metric.WithAttributes(repo,
attribute.String("state", state), attribute.String("start_source", source)))
}

func cycleStart(request pullRequest) (time.Time, string) {
start, err := time.Parse(time.RFC3339, request.CreatedAt)
if err != nil {
return time.Time{}, ""
}

// pr_created is interim: the owner's rule starts at the earliest commit time.
// That needs the REST commits call in a later change, so interim values read low.
source := "pr_created"
startedAt := regexp.MustCompile(`\bstarted_at[:=]\s*(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z)`)

for line := range strings.Lines(request.Body) {
if !strings.HasPrefix(line, "Generated-by:") && !strings.HasPrefix(line, "Assisted-by:") {
continue
}

for _, match := range startedAt.FindAllStringSubmatch(line, -1) {
candidate, parseErr := time.Parse("2006-01-02T15:04:05Z", match[1])
if parseErr == nil && candidate.Before(start) {
start, source = candidate, "started_at"
}
}
}

return start, source
}
215 changes: 195 additions & 20 deletions internal/recorder/recorder_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,10 @@
package recorder_test

import (
"encoding/json"
"fmt"
"reflect"
"strings"
"testing"

"go.opentelemetry.io/otel/sdk/metric/metricdata"
Expand All @@ -14,7 +17,192 @@ import (
"github.com/tbhb-dev/github-metrics/internal/recorder"
)

type cycleTimeTest struct {
name, event, action, createdAt, end, body, source string
merged bool
seconds float64
}

func TestRecordCycleTime(t *testing.T) {
t.Parallel()

const (
created = "2026-11-15T12:00:00Z"
ended = "2026-11-15T13:00:00Z"
earlier = "2026-11-15T11:00:00Z"
trailer = "Generated-by: discard this text; started_at="
)

for _, test := range []cycleTimeTest{
{"created only", pullRequestEvent, closedState, created, ended, "", createdSource, true, 3600},
{"earlier trailer", pullRequestEvent, closedState, created, ended, trailer + earlier, startedAtSource, true, 7200},
{"later trailer", pullRequestEvent, closedState, created, ended, trailer + ended, createdSource, true, 3600},
{closedState, pullRequestEvent, closedState, created, ended, "", createdSource, false, 3600},
{"end before start", pullRequestEvent, closedState, created, earlier, "", "", true, 0},
{
"malformed trailer", pullRequestEvent, closedState, created, ended,
trailer + "2026-99-15T11:00:00Z\n" + trailer + "2026-11-15T11:00:00+00:00", createdSource, true, 3600,
},
{
"two trailers", pullRequestEvent, closedState, created, ended,
trailer + created + "\nAssisted-by: discard this text; started_at: " + earlier, startedAtSource, true, 7200,
},
{"missing merged time", pullRequestEvent, closedState, created, "", "", "", true, 0},
{
"no body text retained", pullRequestEvent, closedState, created, ended,
"discard this text\n" + trailer + earlier, startedAtSource, true, 7200,
},
{
"plain body ignored", pullRequestEvent, closedState, created, ended,
"started_at=" + earlier, createdSource, true, 3600,
},
{"missing created time", pullRequestEvent, closedState, "", ended, trailer + earlier, "", true, 0},
{"bad end time", pullRequestEvent, closedState, created, "invalid", "", "", true, 0},
{"missing closed time", pullRequestEvent, closedState, created, "", "", "", false, 0},
{"open PR", pullRequestEvent, "opened", created, ended, trailer + earlier, "", false, 0},
{"other event", checkRunEvent, closedState, created, ended, trailer + earlier, "", true, 0},
{"equal times", pullRequestEvent, closedState, created, created, "", createdSource, true, 0},
} {
t.Run(test.name, func(t *testing.T) {
t.Parallel()

reader, state := recordCycleFixture(t, test)

checkCycleMetrics(t, reader, state, test.source, test.seconds)
})
}
}

func recordCycleFixture(t *testing.T, test cycleTimeTest) (*sdkmetric.ManualReader, string) {
t.Helper()

consumer, reader := newRecorder(t)

closedAt, state := test.end, closedState
if test.merged {
// Use a different closed_at to prove merged PRs use merged_at.
closedAt, state = "2026-11-15T10:00:00Z", "merged"
}

body, err := json.Marshal(map[string]any{
"repository": map[string]string{"full_name": repositoryName},
"action": test.action,
"pull_request": map[string]any{
"merged": test.merged, "created_at": test.createdAt,
"merged_at": test.end, "closed_at": closedAt, "body": test.body,
},
})
if err != nil {
t.Fatal(err)
}

err = consumer.Record(t.Context(), test.event, body)
if err != nil {
t.Fatal(err)
}

return reader, state
}

func newRecorder(t *testing.T) (*recorder.Recorder, *sdkmetric.ManualReader) {
t.Helper()

reader := sdkmetric.NewManualReader()
provider := sdkmetric.NewMeterProvider(sdkmetric.WithReader(reader))

t.Cleanup(func() {
err := provider.Shutdown(t.Context())
if err != nil {
t.Error(err)
}
})

consumer, err := recorder.New(provider.Meter("test"))
if err != nil {
t.Fatal(err)
}

return consumer, reader
}

func checkCycleMetrics(t *testing.T, reader *sdkmetric.ManualReader, state, source string, seconds float64) {
t.Helper()

var data metricdata.ResourceMetrics

err := reader.Collect(t.Context(), &data)
if err != nil {
t.Fatal(err)
}

if strings.Contains(fmt.Sprint(data), "discard this text") {
t.Fatal("body text retained in metric data")
}

found := false

for _, scope := range data.ScopeMetrics {
for _, measurement := range scope.Metrics {
if measurement.Name == droppedName {
t.Fatal("skipped cycle time counted as a drop")
}

if measurement.Name != "github.pr.cycle_time" {
continue
}

found = true

checkCycleHistogram(t, measurement, state, source, seconds)
}
}

if found != (source != "") {
t.Fatalf("cycle time present = %v, want %v", found, source != "")
}
}

func checkCycleHistogram(t *testing.T, measurement metricdata.Metrics, state, source string, seconds float64) {
t.Helper()

histogram, ok := measurement.Data.(metricdata.Histogram[float64])
if !ok || measurement.Unit != "s" || len(histogram.DataPoints) != 1 {
t.Fatalf("expected one histogram in seconds, got %v", measurement)
}

point := histogram.DataPoints[0]
bounds := []float64{60, 300, 900, 1800, 3600, 7200, 14400, 28800, 86400, 172800, 604800, 1209600}
counts := make([]uint64, len(bounds)+1)
bucket := 0

for bucket < len(bounds) && seconds > bounds[bucket] {
bucket++
}

counts[bucket] = 1

if point.Count != 1 || point.Sum != seconds || !reflect.DeepEqual(point.Bounds, bounds) ||
!reflect.DeepEqual(point.BucketCounts, counts) {
t.Fatalf("unexpected cycle time histogram: %v", point)
}

attrs := make(map[string]string)
for _, attr := range point.Attributes.ToSlice() {
attrs[string(attr.Key)] = attr.Value.AsString()
}

want := map[string]string{repositoryKey: repositoryName, "state": state, "start_source": source}
if !reflect.DeepEqual(attrs, want) {
t.Fatalf("attributes = %v, want %v", attrs, want)
}
}

const (
droppedName = "github.events.dropped"
closedState = "closed"
startedAtSource = "started_at"
createdSource = "pr_created"
repositoryName = "tbhb-dev/github-metrics"
pullRequestEvent = "pull_request"
checkRunEvent = "check_run"
actionKey = "action"
Expand All @@ -33,8 +221,8 @@ func TestRecord(t *testing.T) {
}{
{
map[string]map[string]string{
eventsName: {repositoryKey: "tbhb-dev/github-metrics", eventKey: pullRequestEvent, actionKey: "closed"},
"github.pr.merges": {repositoryKey: "tbhb-dev/github-metrics"},
eventsName: {repositoryKey: repositoryName, eventKey: pullRequestEvent, actionKey: closedState},
"github.pr.merges": {repositoryKey: repositoryName},
},
"merge", pullRequestEvent,
`{"repository":{"full_name":"tbhb-dev/github-metrics"},"action":"closed",` +
Expand All @@ -43,7 +231,7 @@ func TestRecord(t *testing.T) {
},
{
map[string]map[string]string{
eventsName: {repositoryKey: unknownRepository, eventKey: pullRequestEvent, actionKey: "closed"},
eventsName: {repositoryKey: unknownRepository, eventKey: pullRequestEvent, actionKey: closedState},
},
"closed without merge", pullRequestEvent, `{"action":"closed","pull_request":{"merged":false}}`,
},
Expand All @@ -68,33 +256,20 @@ func TestRecord(t *testing.T) {
"other event with empty action", "ping", `{}`,
},
{
map[string]map[string]string{"github.events.dropped": {"reason": "empty_event"}},
map[string]map[string]string{droppedName: {"reason": "empty_event"}},
"legacy entry", "", `{}`,
},
{
map[string]map[string]string{"github.events.dropped": {"reason": "bad_body"}},
map[string]map[string]string{droppedName: {"reason": "bad_body"}},
"bad JSON", pullRequestEvent, `{"action":`,
},
} {
t.Run(test.name, func(t *testing.T) {
t.Parallel()

reader := sdkmetric.NewManualReader()
provider := sdkmetric.NewMeterProvider(sdkmetric.WithReader(reader))

t.Cleanup(func() {
shutdownErr := provider.Shutdown(t.Context())
if shutdownErr != nil {
t.Error(shutdownErr)
}
})

consumer, err := recorder.New(provider.Meter("test"))
if err != nil {
t.Fatal(err)
}
consumer, reader := newRecorder(t)

err = consumer.Record(t.Context(), test.event, []byte(test.body))
err := consumer.Record(t.Context(), test.event, []byte(test.body))
if err != nil {
t.Fatal(err)
}
Expand Down