Add label checks

- verify label key and value pairs
- limit number of labels to 64

labels.go

@@ -16,39 +16,125 @@ package gslog
 
 import (
 	"context"
+	"log/slog"
+	"unicode"
 )
 
 // LabelPair represents a key-value string pair.
 type LabelPair struct {
-	valid bool
-	key   string
-	val   string
+	valid  bool
+	ignore bool
+	key    string
+	val    string
+}
+
+// IsIgnored indicates if there's something wrong with the label pair and that it
+// will not be passed in the logging record.
+func (lp LabelPair) IsIgnored() bool {
+	return lp.ignore
+}
+
+func (lp LabelPair) LogValue() slog.Value {
+	return slog.GroupValue(
+		slog.String("key", lp.key),
+		slog.String("value", lp.val))
 }
 
 // Label returns a new LabelPair from a key and a value.
+// The key and value are not checked.  Log records with invalid label pairs are
+// not logged by Google Logging; use CheckedLabel if the pair need to be verified.
 func Label(key, value string) LabelPair {
-	return LabelPair{valid: true, key: key, val: value}
+	return LabelPair{valid: true, ignore: false, key: key, val: value}
+}
+
+// CheckedLabel returns a new LabelPair from a key and a value.
+// Invalid labels are ignored and not placed in the log record.
+//
+// The labels applied to a resource must meet the following requirements:
+//
+//   - Each resource can have up to 64 labels.
+//   - Each label must be a key-value pair.
+//   - Keys have a minimum length of 1 character and a maximum length of 63
+//     characters, and cannot be empty. Values can be empty, and have a maximum
+//     length of 63 characters.
+//   - Keys and values can contain only lowercase letters, numeric characters,
+//     underscores, and dashes. All characters must use UTF-8 encoding, and
+//     international characters are allowed. Keys must start with a lowercase
+//     letter or international character.
+func CheckedLabel(key, value string) LabelPair {
+	pair := LabelPair{valid: true, ignore: false, key: key, val: value}
+	if len(key) == 0 {
+		slog.Error("Label key is empty")
+		pair.ignore = true
+	}
+	if len(key) > 63 {
+		slog.Error("Label key greater than 63", "ignored", pair)
+		pair.ignore = true
+	}
+	if len(value) > 63 {
+		slog.Error("Label value greater than 63", "ignored", pair)
+		pair.ignore = true
+	}
+	if !validLabel(key) {
+		slog.Error("Label key is not valid", "ignored", pair)
+		pair.ignore = true
+	}
+	if !validLabel(value) {
+		slog.Error("Label value is not valid", "ignored", pair)
+		pair.ignore = true
+	}
+
+	return pair
+}
+
+func validLabel(str string) bool {
+	// checked by other code
+	if len(str) == 0 {
+		return true
+	}
+
+	runes := []rune(str)
+	if !unicode.IsLower(runes[0]) {
+		return false
+	}
+	for _, c := range runes[1:] {
+		if !unicode.IsLower(c) &&
+			!unicode.IsDigit(c) &&
+			c != '_' &&
+			c != '-' {
+			return false
+		}
+	}
+	return true
 }
 
 type labelsKey struct{}
 
-type labeler func(ctx context.Context, labels map[string]string)
+// labelClosure is a function closure that will insert labels into the map.
+type labelClosure func(ctx context.Context, labels map[string]string)
 
 func doNothing(context.Context, map[string]string) {}
 
 // WithLabels returns a new Context with labels to be used in the GCP log
 // entries produced using that context.
 func WithLabels(ctx context.Context, labelPairs ...LabelPair) context.Context {
-	parent := labelsFrom(ctx)
+	parentLabelClosure := labelsFrom(ctx)
 
 	return context.WithValue(ctx, labelsKey{},
-		labeler(func(ctx context.Context, labels map[string]string) {
-			parent(ctx, labels)
+		labelClosure(func(ctx context.Context, labels map[string]string) {
+			parentLabelClosure(ctx, labels)
 
 			for _, labelPair := range labelPairs {
+				if labelPair.ignore {
+					continue
+				}
 				if !labelPair.valid {
 					panic("invalid label passed to WithLabels()")
 				}
+				if len(labels) >= 64 {
+					slog.Error("Too many labels", "ignored", labelPair)
+					continue
+				}
 
 				labels[labelPair.key] = labelPair.val
 			}
@@ -67,8 +153,9 @@ func ExtractLabels(ctx context.Context) map[string]string {
 	return labels
 }
 
-func labelsFrom(ctx context.Context) labeler {
-	v, ok := ctx.Value(labelsKey{}).(labeler)
+// labelsFrom extracts the latest labelClosure from the context.
+func labelsFrom(ctx context.Context) labelClosure {
+	v, ok := ctx.Value(labelsKey{}).(labelClosure)
 	if !ok {
 		return doNothing
 	}

labels_test.go

@@ -25,6 +25,12 @@ import (
 	"m4o.io/gslog"
 )
 
+const (
+	isInvalid    = true
+	isValid      = false
+	tooLongValue = "a1234567890123456789012345678901234567890123456789012345678901234567890"
+)
+
 var _ = Describe("gslog labels", func() {
 	var ctx context.Context
 	BeforeEach(func() {
@@ -45,7 +51,12 @@ var _ = Describe("gslog labels", func() {
 
 	When("context is initialized with several labels", func() {
 		BeforeEach(func() {
-			ctx = gslog.WithLabels(ctx, gslog.Label("how", "now"), gslog.Label("brown", "cow"))
+			ctx = gslog.WithLabels(ctx,
+				gslog.Label("how", "now"),
+				gslog.Label("brown", "cow"),
+				gslog.CheckedLabel("", "invalid"),
+				gslog.CheckedLabel("Invalid", "Label"),
+			)
 		})
 
 		It("they can be extracted from the context", func() {
@@ -70,6 +81,69 @@ var _ = Describe("gslog labels", func() {
 			})
 		})
 	})
+
+	When("context is initialized with too many labels", func() {
+		BeforeEach(func() {
+			ctx = gslog.WithLabels(ctx,
+				gslog.Label("how", "now"),
+				gslog.Label("brown", "cow"),
+			)
+			for i := 0; i < 64; i++ {
+				key := fmt.Sprintf("key_%06d", i)
+				value := fmt.Sprintf("val_%06d", i)
+				ctx = gslog.WithLabels(ctx,
+					gslog.Label(key, value),
+				)
+			}
+		})
+
+		It("only 64 labels can be obtained from the context", func() {
+			labels := gslog.ExtractLabels(ctx)
+
+			Ω(labels).Should(HaveLen(64))
+			Ω(labels).Should(HaveKeyWithValue("how", "now"))
+			Ω(labels).Should(HaveKeyWithValue("brown", "cow"))
+		})
+	})
+
+	DescribeTable("Passed various label pairs",
+		func(key, value string, isIgnored bool) {
+			checked := gslog.CheckedLabel(key, value)
+			Expect(checked.IsIgnored()).To(Equal(isIgnored))
+
+			notChecked := gslog.Label(key, value)
+			Expect(notChecked.IsIgnored()).To(BeFalse())
+		},
+		Entry("When a label has a key and value", "foo", "bar", isValid),
+		Entry("When a label has a key and value with numbers, etc.", "foo-123_456", "bar-123_456", isValid),
+		Entry("When a label has a one character key and value", "a", "b", isValid),
+		Entry("When a label has a key that starts with a lower case unicode and value", "über", "car", isValid),
+		Entry("When a label has a key and a value that starts with a lower case unicode", "car", "über", isValid),
+		Entry("When a label has a key and an empty value", "foo", "", isValid),
+
+		Entry("When a label has an empty key and value", "", "ouch", isInvalid),
+
+		Entry("When a label has key with an invalid value and value", "f*", "bar", isInvalid),
+		Entry("When a label has key and value with an invalid value", "foo", "b*", isInvalid),
+
+		Entry("When a label has mixed case key and value", "Foo", "bar", isInvalid),
+		Entry("When a label has key and mixed case value", "foo", "Bar", isInvalid),
+		Entry("When a label has mixed case for both key and value", "Foo", "Bar", isInvalid),
+
+		Entry("When a label has too long string key and value", tooLongValue, "bar", isInvalid),
+		Entry("When a label has key and a too long string value", "foo", tooLongValue, isInvalid),
+		Entry("When a label has too long value for both key and value", "foo", tooLongValue, isInvalid),
+
+		Entry("When a label has key that does not start with lower case and value", "Foo", "bar", isInvalid),
+		Entry("When a label has key that does not start with lower case and value", "3oo", "bar", isInvalid),
+		Entry("When a label has key that does not start with lower case and value", "_foo", "bar", isInvalid),
+		Entry("When a label has key that does not start with lower case and value", "-foo", "bar", isInvalid),
+
+		Entry("When a label has key and value that does not start with lower case", "foo", "Bar", isInvalid),
+		Entry("When a label has key and value that does not start with lower case", "foo", "8ar", isInvalid),
+		Entry("When a label has key and value that does not start with lower case", "foo", "_bar", isInvalid),
+		Entry("When a label has key and value that does not start with lower case", "foo", "-bar", isInvalid),
+	)
 })
 
 const (