Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

[exporter] Remove jaeger dbmodel dependency #36972

Open
wants to merge 6 commits into
base: main
Choose a base branch
from
Open
Show file tree
Hide file tree
Changes from 3 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
2 changes: 1 addition & 1 deletion exporter/logzioexporter/exporter_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -255,7 +255,7 @@ func TestPushTraceData(tester *testing.T) {
res.Attributes().PutStr(conventions.AttributeHostName, testHost)
err := testTracesExporter(tester, td, &cfg)
require.NoError(tester, err)
var newSpan logzioSpan
var newSpan LogzioSpan
decoded, _ := gUnzipData(recordedRequests)
requests := strings.Split(string(decoded), "\n")
assert.NoError(tester, json.Unmarshal([]byte(requests[0]), &newSpan))
Expand Down
126 changes: 126 additions & 0 deletions exporter/logzioexporter/from_domain.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,126 @@
// Copyright (c) 2019 The Jaeger Authors.
// Copyright (c) 2018 Uber Technologies, Inc.
// SPDX-License-Identifier: Apache-2.0

package logzioexporter

import (
"strings"

"github.com/jaegertracing/jaeger/model"
)

// NewFromDomain creates FromDomain used to convert model span to db span
func NewFromDomain(allTagsAsObject bool, tagKeysAsFields []string, tagDotReplacement string) FromDomain {
yurishkuro marked this conversation as resolved.
Show resolved Hide resolved
tags := map[string]bool{}
for _, k := range tagKeysAsFields {
tags[k] = true
}
return FromDomain{allTagsAsFields: allTagsAsObject, tagKeysAsFields: tags, tagDotReplacement: tagDotReplacement}
}

// FromDomain is used to convert model span to db span
type FromDomain struct {
allTagsAsFields bool
tagKeysAsFields map[string]bool
tagDotReplacement string
}

// FromDomainEmbedProcess converts model.Span into json.Span format.
// This format includes a ParentSpanID and an embedded Process.
func (fd FromDomain) FromDomainEmbedProcess(span *model.Span) *LogzioSpan {
return fd.convertSpanEmbedProcess(span)
}

func (fd FromDomain) convertSpanInternal(span *model.Span) LogzioSpan {
tags, tagsMap := fd.convertKeyValuesString(span.Tags)
return LogzioSpan{
TraceID: TraceID(span.TraceID.String()),
SpanID: SpanID(span.SpanID.String()),
Flags: uint32(span.Flags),
OperationName: span.OperationName,
StartTime: model.TimeAsEpochMicroseconds(span.StartTime),
StartTimeMillis: model.TimeAsEpochMicroseconds(span.StartTime) / 1000,
Duration: model.DurationAsMicroseconds(span.Duration),
Tags: tags,
Tag: tagsMap,
Logs: fd.convertLogs(span.Logs),
}
}

func (fd FromDomain) convertSpanEmbedProcess(span *model.Span) *LogzioSpan {
s := fd.convertSpanInternal(span)
s.Process = fd.convertProcess(span.Process)
s.References = fd.convertReferences(span)
return &s
}

func (fd FromDomain) convertReferences(span *model.Span) []Reference {
out := make([]Reference, 0, len(span.References))
for _, ref := range span.References {
out = append(out, Reference{
RefType: fd.convertRefType(ref.RefType),
TraceID: TraceID(ref.TraceID.String()),
SpanID: SpanID(ref.SpanID.String()),
})
}
return out
}

func (FromDomain) convertRefType(refType model.SpanRefType) ReferenceType {
if refType == model.FollowsFrom {
return FollowsFrom
}
return ChildOf
}

func (fd FromDomain) convertKeyValuesString(keyValues model.KeyValues) ([]KeyValue, map[string]any) {
var tagsMap map[string]any
var kvs []KeyValue
for _, kv := range keyValues {
if kv.GetVType() != model.BinaryType && (fd.allTagsAsFields || fd.tagKeysAsFields[kv.Key]) {
if tagsMap == nil {
tagsMap = map[string]any{}
}
tagsMap[strings.ReplaceAll(kv.Key, ".", fd.tagDotReplacement)] = kv.Value()
} else {
kvs = append(kvs, convertKeyValue(kv))
}
}
if kvs == nil {
kvs = make([]KeyValue, 0)
}
return kvs, tagsMap
}

func (FromDomain) convertLogs(logs []model.Log) []Log {
out := make([]Log, len(logs))
for i, log := range logs {
var kvs []KeyValue
for _, kv := range log.Fields {
kvs = append(kvs, convertKeyValue(kv))
}
out[i] = Log{
Timestamp: model.TimeAsEpochMicroseconds(log.Timestamp),
Fields: kvs,
}
}
return out
}

func (fd FromDomain) convertProcess(process *model.Process) Process {
tags, tagsMap := fd.convertKeyValuesString(process.Tags)
return Process{
ServiceName: process.ServiceName,
Tags: tags,
Tag: tagsMap,
}
}

func convertKeyValue(kv model.KeyValue) KeyValue {
return KeyValue{
Key: kv.Key,
Type: ValueType(strings.ToLower(kv.VType.String())),
Value: kv.AsString(),
}
}
139 changes: 139 additions & 0 deletions exporter/logzioexporter/from_domain_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,139 @@
// Copyright (c) 2019 The Jaeger Authors.
// Copyright (c) 2018 Uber Technologies, Inc.
// SPDX-License-Identifier: Apache-2.0

package logzioexporter

import (
"bytes"
"encoding/hex"
"encoding/json"
"fmt"
"os"
"testing"

"github.com/gogo/protobuf/jsonpb"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"

"github.com/jaegertracing/jaeger/model"
)

func TestFromDomainEmbedProcess(t *testing.T) {
domainStr, jsonStr := loadFixtures(t)

var span model.Span
require.NoError(t, jsonpb.Unmarshal(bytes.NewReader(domainStr), &span))
converter := NewFromDomain(false, nil, ":")
embeddedSpan := converter.FromDomainEmbedProcess(&span)

var expectedSpan LogzioSpan
require.NoError(t, json.Unmarshal(jsonStr, &expectedSpan))

testJSONEncoding(t, jsonStr, embeddedSpan.transformToDbModelSpan())
}

// Loads and returns domain model and JSON model fixtures with given number i.
func loadFixtures(t *testing.T) ([]byte, []byte) {
in := fmt.Sprintf("./testdata/span.json")
inStr, err := os.ReadFile(in)
require.NoError(t, err)
out := fmt.Sprintf("./testdata/es.json")
outStr, err := os.ReadFile(out)
require.NoError(t, err)
return inStr, outStr
}

func testJSONEncoding(t *testing.T, expectedStr []byte, object any) {
buf := &bytes.Buffer{}
enc := json.NewEncoder(buf)
enc.SetIndent("", " ")

outFile := fmt.Sprintf("./testdata/es.json")
require.NoError(t, enc.Encode(object))

if !assert.Equal(t, string(expectedStr), buf.String()) {
err := os.WriteFile(outFile+"-actual.json", buf.Bytes(), 0o644)
require.NoError(t, err)
}
}

func TestEmptyTags(t *testing.T) {
tags := make([]model.KeyValue, 0)
span := model.Span{Tags: tags, Process: &model.Process{Tags: tags}}
converter := NewFromDomain(false, nil, ":")
dbSpan := converter.FromDomainEmbedProcess(&span)
assert.Empty(t, dbSpan.Tags)
assert.Empty(t, dbSpan.Tag)
}

func TestTagMap(t *testing.T) {
tags := []model.KeyValue{
model.String("foo", "foo"),
model.Bool("a", true),
model.Int64("b.b", 1),
}
span := model.Span{Tags: tags, Process: &model.Process{Tags: tags}}
converter := NewFromDomain(false, []string{"a", "b.b", "b*"}, ":")
dbSpan := converter.FromDomainEmbedProcess(&span)

assert.Len(t, dbSpan.Tags, 1)
assert.Equal(t, "foo", dbSpan.Tags[0].Key)
assert.Len(t, dbSpan.Process.Tags, 1)
assert.Equal(t, "foo", dbSpan.Process.Tags[0].Key)

tagsMap := map[string]any{}
tagsMap["a"] = true
tagsMap["b:b"] = int64(1)
assert.Equal(t, tagsMap, dbSpan.Tag)
assert.Equal(t, tagsMap, dbSpan.Process.Tag)
}

func TestConvertKeyValueValue(t *testing.T) {
longString := `Bender Bending Rodrigues Bender Bending Rodrigues Bender Bending Rodrigues Bender Bending Rodrigues
Bender Bending Rodrigues Bender Bending Rodrigues Bender Bending Rodrigues Bender Bending Rodrigues Bender Bending Rodrigues
Bender Bending Rodrigues Bender Bending Rodrigues Bender Bending Rodrigues Bender Bending Rodrigues Bender Bending Rodrigues
Bender Bending Rodrigues Bender Bending Rodrigues Bender Bending Rodrigues Bender Bending Rodrigues Bender Bending Rodrigues
Bender Bending Rodrigues Bender Bending Rodrigues Bender Bending Rodrigues Bender Bending Rodrigues Bender Bending Rodrigues `
key := "key"
tests := []struct {
kv model.KeyValue
expected KeyValue
}{
{
kv: model.Bool(key, true),
expected: KeyValue{Key: key, Value: "true", Type: "bool"},
},
{
kv: model.Bool(key, false),
expected: KeyValue{Key: key, Value: "false", Type: "bool"},
},
{
kv: model.Int64(key, int64(1499)),
expected: KeyValue{Key: key, Value: "1499", Type: "int64"},
},
{
kv: model.Float64(key, float64(15.66)),
expected: KeyValue{Key: key, Value: "15.66", Type: "float64"},
},
{
kv: model.String(key, longString),
expected: KeyValue{Key: key, Value: longString, Type: "string"},
},
{
kv: model.Binary(key, []byte(longString)),
expected: KeyValue{Key: key, Value: hex.EncodeToString([]byte(longString)), Type: "binary"},
},
{
kv: model.KeyValue{VType: 1500, Key: key},
expected: KeyValue{Key: key, Value: "unknown type 1500", Type: "1500"},
},
}

for _, test := range tests {
t.Run(fmt.Sprintf("%s:%s", test.expected.Type, test.expected.Key), func(t *testing.T) {
actual := convertKeyValue(test.kv)
assert.Equal(t, test.expected, actual)
})
}
}
2 changes: 1 addition & 1 deletion exporter/logzioexporter/go.mod
Original file line number Diff line number Diff line change
Expand Up @@ -3,6 +3,7 @@ module github.com/open-telemetry/opentelemetry-collector-contrib/exporter/logzio
go 1.22.0

require (
github.com/gogo/protobuf v1.3.2
github.com/hashicorp/go-hclog v1.6.3
github.com/jaegertracing/jaeger v1.62.0
github.com/open-telemetry/opentelemetry-collector-contrib/pkg/translator/jaeger v0.116.0
Expand Down Expand Up @@ -36,7 +37,6 @@ require (
github.com/go-logr/logr v1.4.2 // indirect
github.com/go-logr/stdr v1.2.2 // indirect
github.com/go-viper/mapstructure/v2 v2.2.1 // indirect
github.com/gogo/protobuf v1.3.2 // indirect
github.com/golang/snappy v0.0.4 // indirect
github.com/google/uuid v1.6.0 // indirect
github.com/hashicorp/go-version v1.7.0 // indirect
Expand Down
Loading
Loading