1
0
mirror of https://github.com/open-telemetry/opentelemetry-go.git synced 2024-12-28 21:09:17 +02:00
opentelemetry-go/bridge/opencensus/internal/span_test.go
Tyler Yahn 1f527a52ab
Update trace API config creation functions ()
* Update trace API config creation funcs

Follow our style guide and return the config struct instead of pointers.

* Update changelog with changes

Co-authored-by: Anthony Mirabella <a9@aneurysm9.com>
2021-09-01 15:44:13 -04:00

269 lines
7.4 KiB
Go

// Copyright The OpenTelemetry Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package internal_test
import (
"testing"
octrace "go.opencensus.io/trace"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/bridge/opencensus/internal"
"go.opentelemetry.io/otel/bridge/opencensus/internal/oc2otel"
"go.opentelemetry.io/otel/bridge/opencensus/internal/otel2oc"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/trace"
)
type span struct {
trace.Span
recording bool
ended bool
sc trace.SpanContext
name string
sCode codes.Code
sMsg string
attrs []attribute.KeyValue
eName string
eOpts []trace.EventOption
}
func (s *span) IsRecording() bool { return s.recording }
func (s *span) End(...trace.SpanEndOption) { s.ended = true }
func (s *span) SpanContext() trace.SpanContext { return s.sc }
func (s *span) SetName(n string) { s.name = n }
func (s *span) SetStatus(c codes.Code, d string) { s.sCode, s.sMsg = c, d }
func (s *span) SetAttributes(a ...attribute.KeyValue) { s.attrs = a }
func (s *span) AddEvent(n string, o ...trace.EventOption) { s.eName, s.eOpts = n, o }
func TestSpanIsRecordingEvents(t *testing.T) {
s := &span{recording: true}
ocS := internal.NewSpan(s)
if !ocS.IsRecordingEvents() {
t.Errorf("span.IsRecordingEvents() = false, want true")
}
s.recording = false
if ocS.IsRecordingEvents() {
t.Errorf("span.IsRecordingEvents() = true, want false")
}
}
func TestSpanEnd(t *testing.T) {
s := new(span)
ocS := internal.NewSpan(s)
if s.ended {
t.Fatal("new span already ended")
}
ocS.End()
if !s.ended {
t.Error("span.End() did not end OpenTelemetry span")
}
}
func TestSpanSpanContext(t *testing.T) {
sc := trace.NewSpanContext(trace.SpanContextConfig{
TraceID: [16]byte{1},
SpanID: [8]byte{1},
})
// Do not test the conversion, only that the method is called.
converted := otel2oc.SpanContext(sc)
s := &span{sc: sc}
ocS := internal.NewSpan(s)
if ocS.SpanContext() != converted {
t.Error("span.SpanContext did not use OpenTelemetry SpanContext")
}
}
func TestSpanSetName(t *testing.T) {
// OpenCensus does not set a name if not recording.
s := &span{recording: true}
ocS := internal.NewSpan(s)
name := "test name"
ocS.SetName(name)
if s.name != name {
t.Error("span.SetName did not set OpenTelemetry span name")
}
}
func TestSpanSetStatus(t *testing.T) {
// OpenCensus does not set a status if not recording.
s := &span{recording: true}
ocS := internal.NewSpan(s)
c, d := codes.Error, "error"
status := octrace.Status{Code: int32(c), Message: d}
ocS.SetStatus(status)
if s.sCode != c {
t.Error("span.SetStatus failed to set OpenTelemetry status code")
}
if s.sMsg != d {
t.Error("span.SetStatus failed to set OpenTelemetry status description")
}
}
func TestSpanAddAttributes(t *testing.T) {
attrs := []octrace.Attribute{
octrace.BoolAttribute("a", true),
}
// Do not test the conversion, only that the method is called.
converted := oc2otel.Attributes(attrs)
// OpenCensus does not set attributes if not recording.
s := &span{recording: true}
ocS := internal.NewSpan(s)
ocS.AddAttributes(attrs...)
if len(s.attrs) != len(converted) || s.attrs[0] != converted[0] {
t.Error("span.AddAttributes failed to set OpenTelemetry attributes")
}
}
func TestSpanAnnotate(t *testing.T) {
name := "annotation"
attrs := []octrace.Attribute{
octrace.BoolAttribute("a", true),
}
// Do not test the conversion, only that the method is called.
want := oc2otel.Attributes(attrs)
// OpenCensus does not set events if not recording.
s := &span{recording: true}
ocS := internal.NewSpan(s)
ocS.Annotate(attrs, name)
if s.eName != name {
t.Error("span.Annotate did not set event name")
}
config := trace.NewEventConfig(s.eOpts...)
got := config.Attributes()
if len(want) != len(got) || want[0] != got[0] {
t.Error("span.Annotate did not set event options")
}
}
func TestSpanAnnotatef(t *testing.T) {
format := "annotation %s"
attrs := []octrace.Attribute{
octrace.BoolAttribute("a", true),
}
// Do not test the conversion, only that the method is called.
want := oc2otel.Attributes(attrs)
// OpenCensus does not set events if not recording.
s := &span{recording: true}
ocS := internal.NewSpan(s)
ocS.Annotatef(attrs, format, "a")
if s.eName != "annotation a" {
t.Error("span.Annotatef did not set event name")
}
config := trace.NewEventConfig(s.eOpts...)
got := config.Attributes()
if len(want) != len(got) || want[0] != got[0] {
t.Error("span.Annotatef did not set event options")
}
}
func TestSpanAddMessageSendEvent(t *testing.T) {
var u, c int64 = 1, 2
// OpenCensus does not set events if not recording.
s := &span{recording: true}
ocS := internal.NewSpan(s)
ocS.AddMessageSendEvent(0, u, c)
if s.eName != internal.MessageSendEvent {
t.Error("span.AddMessageSendEvent did not set event name")
}
config := trace.NewEventConfig(s.eOpts...)
got := config.Attributes()
if len(got) != 2 {
t.Fatalf("span.AddMessageSendEvent set %d attributes, want 2", len(got))
}
want := attribute.KeyValue{Key: internal.UncompressedKey, Value: attribute.Int64Value(u)}
if got[0] != want {
t.Errorf("span.AddMessageSendEvent wrong uncompressed attribute: %v", got[0])
}
want = attribute.KeyValue{Key: internal.CompressedKey, Value: attribute.Int64Value(c)}
if got[1] != want {
t.Errorf("span.AddMessageSendEvent wrong compressed attribute: %v", got[1])
}
}
func TestSpanAddMessageReceiveEvent(t *testing.T) {
var u, c int64 = 3, 4
// OpenCensus does not set events if not recording.
s := &span{recording: true}
ocS := internal.NewSpan(s)
ocS.AddMessageReceiveEvent(0, u, c)
if s.eName != internal.MessageReceiveEvent {
t.Error("span.AddMessageReceiveEvent did not set event name")
}
config := trace.NewEventConfig(s.eOpts...)
got := config.Attributes()
if len(got) != 2 {
t.Fatalf("span.AddMessageReceiveEvent set %d attributes, want 2", len(got))
}
want := attribute.KeyValue{Key: internal.UncompressedKey, Value: attribute.Int64Value(u)}
if got[0] != want {
t.Errorf("span.AddMessageReceiveEvent wrong uncompressed attribute: %v", got[0])
}
want = attribute.KeyValue{Key: internal.CompressedKey, Value: attribute.Int64Value(c)}
if got[1] != want {
t.Errorf("span.AddMessageReceiveEvent wrong compressed attribute: %v", got[1])
}
}
func TestSpanAddLinkFails(t *testing.T) {
h, restore := withHandler()
defer restore()
// OpenCensus does not try to set links if not recording.
s := &span{recording: true}
ocS := internal.NewSpan(s)
ocS.AddLink(octrace.Link{})
if h.err == nil {
t.Error("span.AddLink failed to raise an error")
}
}
func TestSpanString(t *testing.T) {
sc := trace.NewSpanContext(trace.SpanContextConfig{
TraceID: [16]byte{1},
SpanID: [8]byte{1},
})
s := &span{sc: sc}
ocS := internal.NewSpan(s)
if expected := "span 0100000000000000"; ocS.String() != expected {
t.Errorf("span.String = %q, not %q", ocS.String(), expected)
}
}