// Copyright 2016 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package pprof import ( "context" "fmt" "slices" "strings" ) type label struct { key string value string } // LabelSet is a set of labels. type LabelSet struct { list []label } // labelContextKey is the type of contextKeys used for profiler labels. type labelContextKey struct{} func labelValue(ctx context.Context) labelMap { labels, _ := ctx.Value(labelContextKey{}).(*labelMap) if labels == nil { return labelMap{} } return *labels } // labelMap is the representation of the label set held in the context type. // This is an initial implementation, but it will be replaced with something // that admits incremental immutable modification more efficiently. type labelMap struct { LabelSet } // String satisfies Stringer and returns key, value pairs in a consistent // order. func (l *labelMap) String() string { if l == nil { return "" } keyVals := make([]string, 0, len(l.list)) for _, lbl := range l.list { keyVals = append(keyVals, fmt.Sprintf("%q:%q", lbl.key, lbl.value)) } slices.Sort(keyVals) return "{" + strings.Join(keyVals, ", ") + "}" } // WithLabels returns a new [context.Context] with the given labels added. // A label overwrites a prior label with the same key. func WithLabels(ctx context.Context, labels LabelSet) context.Context { parentLabels := labelValue(ctx) return context.WithValue(ctx, labelContextKey{}, &labelMap{mergeLabelSets(parentLabels.LabelSet, labels)}) } func mergeLabelSets(left, right LabelSet) LabelSet { if len(left.list) == 0 { return right } else if len(right.list) == 0 { return left } l, r := 0, 0 result := make([]label, 0, len(right.list)) for l < len(left.list) && r < len(right.list) { switch strings.Compare(left.list[l].key, right.list[r].key) { case -1: // left key < right key result = append(result, left.list[l]) l++ case 1: // right key < left key result = append(result, right.list[r]) r++ case 0: // keys are equal, right value overwrites left value result = append(result, right.list[r]) l++ r++ } } // Append the remaining elements result = append(result, left.list[l:]...) result = append(result, right.list[r:]...) return LabelSet{list: result} } // Labels takes an even number of strings representing key-value pairs // and makes a [LabelSet] containing them. // A label overwrites a prior label with the same key. // Currently only the CPU and goroutine profiles utilize any labels // information. // See https://golang.org/issue/23458 for details. func Labels(args ...string) LabelSet { if len(args)%2 != 0 { panic("uneven number of arguments to pprof.Labels") } list := make([]label, 0, len(args)/2) sortedNoDupes := true for i := 0; i+1 < len(args); i += 2 { list = append(list, label{key: args[i], value: args[i+1]}) sortedNoDupes = sortedNoDupes && (i < 2 || args[i] > args[i-2]) } if !sortedNoDupes { // slow path: keys are unsorted, contain duplicates, or both slices.SortStableFunc(list, func(a, b label) int { return strings.Compare(a.key, b.key) }) deduped := make([]label, 0, len(list)) for i, lbl := range list { if i == 0 || lbl.key != list[i-1].key { deduped = append(deduped, lbl) } else { deduped[len(deduped)-1] = lbl } } list = deduped } return LabelSet{list: list} } // Label returns the value of the label with the given key on ctx, and a boolean indicating // whether that label exists. func Label(ctx context.Context, key string) (string, bool) { ctxLabels := labelValue(ctx) for _, lbl := range ctxLabels.list { if lbl.key == key { return lbl.value, true } } return "", false } // ForLabels invokes f with each label set on the context. // The function f should return true to continue iteration or false to stop iteration early. func ForLabels(ctx context.Context, f func(key, value string) bool) { ctxLabels := labelValue(ctx) for _, lbl := range ctxLabels.list { if !f(lbl.key, lbl.value) { break } } }