sdk/log: Implement Record (#5073)

sdk/log/record_test.go

@@ -0,0 +1,206 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package log
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/log"
+	"go.opentelemetry.io/otel/sdk/instrumentation"
+	"go.opentelemetry.io/otel/sdk/resource"
+	"go.opentelemetry.io/otel/trace"
+)
+
+func TestRecordTimestamp(t *testing.T) {
+	now := time.Now()
+	r := new(Record)
+	r.SetTimestamp(now)
+	assert.Equal(t, now, r.Timestamp())
+}
+
+func TestRecordObservedTimestamp(t *testing.T) {
+	now := time.Now()
+	r := new(Record)
+	r.SetObservedTimestamp(now)
+	assert.Equal(t, now, r.ObservedTimestamp())
+}
+
+func TestRecordSeverity(t *testing.T) {
+	s := log.SeverityInfo
+	r := new(Record)
+	r.SetSeverity(s)
+	assert.Equal(t, s, r.Severity())
+}
+
+func TestRecordSeverityText(t *testing.T) {
+	text := "text"
+	r := new(Record)
+	r.SetSeverityText(text)
+	assert.Equal(t, text, r.SeverityText())
+}
+
+func TestRecordBody(t *testing.T) {
+	v := log.BoolValue(true)
+	r := new(Record)
+	r.SetBody(v)
+	assert.True(t, v.Equal(r.Body()))
+}
+
+func TestRecordAttributes(t *testing.T) {
+	attrs := []log.KeyValue{
+		log.Bool("0", true),
+		log.Int64("1", 2),
+		log.Float64("2", 3.0),
+		log.String("3", "forth"),
+		log.Slice("4", log.Int64Value(1)),
+		log.Map("5", log.Int("key", 2)),
+		log.Bytes("6", []byte("six")),
+	}
+	r := new(Record)
+	r.SetAttributes(attrs...)
+	r.SetAttributes(attrs[:2]...) // Overwrite existing.
+	r.AddAttributes(attrs[2:]...)
+
+	assert.Equal(t, len(attrs), r.AttributesLen(), "attribute length")
+
+	for n := range attrs {
+		var i int
+		r.WalkAttributes(func(log.KeyValue) bool {
+			i++
+			return i <= n
+		})
+		assert.Equalf(t, n+1, i, "WalkAttributes did not stop at %d", n+1)
+	}
+
+	var i int
+	r.WalkAttributes(func(kv log.KeyValue) bool {
+		assert.Truef(t, kv.Equal(attrs[i]), "%d: %v != %v", i, kv, attrs[i])
+		i++
+		return true
+	})
+}
+
+func TestRecordTraceID(t *testing.T) {
+	id := trace.TraceID([16]byte{1})
+	r := new(Record)
+	r.SetTraceID(id)
+	assert.Equal(t, id, r.TraceID())
+}
+
+func TestRecordSpanID(t *testing.T) {
+	id := trace.SpanID([8]byte{1})
+	r := new(Record)
+	r.SetSpanID(id)
+	assert.Equal(t, id, r.SpanID())
+}
+
+func TestRecordTraceFlags(t *testing.T) {
+	flag := trace.FlagsSampled
+	r := new(Record)
+	r.SetTraceFlags(flag)
+	assert.Equal(t, flag, r.TraceFlags())
+}
+
+func TestRecordResource(t *testing.T) {
+	r := new(Record)
+	assert.NotPanics(t, func() { r.Resource() })
+
+	res := resource.NewSchemaless(attribute.Bool("key", true))
+	r.resource = res
+	got := r.Resource()
+	assert.True(t, res.Equal(&got))
+}
+
+func TestRecordInstrumentationScope(t *testing.T) {
+	r := new(Record)
+	assert.NotPanics(t, func() { r.InstrumentationScope() })
+
+	scope := instrumentation.Scope{Name: "testing"}
+	r.scope = &scope
+	assert.Equal(t, scope, r.InstrumentationScope())
+}
+
+func TestRecordAttributeValueLengthLimit(t *testing.T) {
+	limit := 12
+	r := new(Record)
+	r.attributeValueLengthLimit = limit
+	assert.Equal(t, limit, r.AttributeValueLengthLimit())
+}
+
+func TestRecordAttributeCountLimit(t *testing.T) {
+	limit := 21
+	r := new(Record)
+	r.attributeCountLimit = limit
+	assert.Equal(t, limit, r.AttributeCountLimit())
+}
+
+func TestRecordClone(t *testing.T) {
+	now0 := time.Now()
+	sev0 := log.SeverityInfo
+	text0 := "text"
+	val0 := log.BoolValue(true)
+	attr0 := log.Bool("0", true)
+	traceID0 := trace.TraceID([16]byte{1})
+	spanID0 := trace.SpanID([8]byte{1})
+	flag0 := trace.FlagsSampled
+
+	r0 := new(Record)
+	r0.SetTimestamp(now0)
+	r0.SetObservedTimestamp(now0)
+	r0.SetSeverity(sev0)
+	r0.SetSeverityText(text0)
+	r0.SetBody(val0)
+	r0.SetAttributes(attr0)
+	r0.SetTraceID(traceID0)
+	r0.SetSpanID(spanID0)
+	r0.SetTraceFlags(flag0)
+
+	now1 := now0.Add(time.Second)
+	sev1 := log.SeverityDebug
+	text1 := "string"
+	val1 := log.IntValue(1)
+	attr1 := log.Int64("1", 2)
+	traceID1 := trace.TraceID([16]byte{2})
+	spanID1 := trace.SpanID([8]byte{2})
+	flag1 := trace.TraceFlags(2)
+
+	r1 := r0.Clone()
+	r1.SetTimestamp(now1)
+	r1.SetObservedTimestamp(now1)
+	r1.SetSeverity(sev1)
+	r1.SetSeverityText(text1)
+	r1.SetBody(val1)
+	r1.SetAttributes(attr1)
+	r1.SetTraceID(traceID1)
+	r1.SetSpanID(spanID1)
+	r1.SetTraceFlags(flag1)
+
+	assert.Equal(t, now0, r0.Timestamp())
+	assert.Equal(t, now0, r0.ObservedTimestamp())
+	assert.Equal(t, sev0, r0.Severity())
+	assert.Equal(t, text0, r0.SeverityText())
+	assert.True(t, val0.Equal(r0.Body()))
+	assert.Equal(t, traceID0, r0.TraceID())
+	assert.Equal(t, spanID0, r0.SpanID())
+	assert.Equal(t, flag0, r0.TraceFlags())
+	r0.WalkAttributes(func(kv log.KeyValue) bool {
+		return assert.Truef(t, kv.Equal(attr0), "%v != %v", kv, attr0)
+	})
+
+	assert.Equal(t, now1, r1.Timestamp())
+	assert.Equal(t, now1, r1.ObservedTimestamp())
+	assert.Equal(t, sev1, r1.Severity())
+	assert.Equal(t, text1, r1.SeverityText())
+	assert.True(t, val1.Equal(r1.Body()))
+	assert.Equal(t, traceID1, r1.TraceID())
+	assert.Equal(t, spanID1, r1.SpanID())
+	assert.Equal(t, flag1, r1.TraceFlags())
+	r1.WalkAttributes(func(kv log.KeyValue) bool {
+		return assert.Truef(t, kv.Equal(attr1), "%v != %v", kv, attr1)
+	})
+}