The only tool you need to know what is happening and how to fix it.
Go alertingexception-trackerissue-trackinglogsmetricsmonitoringobservability-platformopen-telemetryotelsession-replaytelemetrytraces
package otelcontrollers
import (
"context"
"encoding/hex"
"encoding/json"
"strconv"
"strings"
"github.com/google/uuid"
"github.com/tracewayapp/traceway/backend/app/models"
"github.com/tracewayapp/traceway/backend/app/repositories/telemetry/shared"
collogspb "go.opentelemetry.io/proto/otlp/collector/logs/v1"
commonpb "go.opentelemetry.io/proto/otlp/common/v1"
logspb "go.opentelemetry.io/proto/otlp/logs/v1"
)
func convertLogs(existingProject *models.Project, ctx context.Context, projectId uuid.UUID, req *collogspb.ExportLogsServiceRequest) []models.LogRecord {
var records []models.LogRecord
for _, rl := range req.ResourceLogs {
resAttrs := extractAttributes(rl.GetResource().GetAttributes())
serviceName := getStringAttribute(rl.GetResource().GetAttributes(), "service.name")
language := getStringAttribute(rl.GetResource().GetAttributes(), "telemetry.sdk.language")
resourceSchemaUrl := rl.GetSchemaUrl()
for _, sl := range rl.ScopeLogs {
scope := sl.GetScope()
scopeName := scope.GetName()
scopeVersion := scope.GetVersion()
scopeAttrs := extractAttributes(scope.GetAttributes())
scopeSchemaUrl := sl.GetSchemaUrl()
for _, lr := range sl.LogRecords {
record := toLogRecord(projectId, lr, serviceName, resourceSchemaUrl, resAttrs, scopeSchemaUrl, scopeName, scopeVersion, scopeAttrs)
if stackTrace := record.LogAttributes["exception.stacktrace"]; stackTrace != "" {
record.LogAttributes["exception.stacktrace"] = otelSymbolicateJs(existingProject, projectId, ctx, stackTrace, language, scopeName)
}
records = append(records, record)
}
}
}
return records
}
func toLogRecord(
projectId uuid.UUID,
lr *logspb.LogRecord,
serviceName string,
resourceSchemaUrl string,
resourceAttrs map[string]string,
scopeSchemaUrl string,
scopeName string,
scopeVersion string,
scopeAttrs map[string]string,
) models.LogRecord {
ts := lr.TimeUnixNano
if ts == 0 {
ts = lr.ObservedTimeUnixNano
}
severityNumber := uint8(lr.SeverityNumber)
severityText := strings.ToUpper(lr.SeverityText)
if severityText == "" {
severityText = severityTextFromNumber(severityNumber)
}
var traceIDHex, spanIDHex string
if validOtelID(lr.TraceId, 16) {
traceIDHex = hex.EncodeToString(lr.TraceId)
}
if validOtelID(lr.SpanId, 8) {
spanIDHex = hex.EncodeToString(lr.SpanId)
}
return models.LogRecord{
Id: uuid.New(),
ProjectId: projectId,
Timestamp: shared.OtelNanosToTime(ts),
TraceId: traceIDHex,
SpanId: spanIDHex,
TraceFlags: uint8(lr.Flags),
SeverityText: severityText,
SeverityNumber: severityNumber,
ServiceName: serviceName,
Body: anyValueToString(lr.Body),
ResourceSchemaUrl: resourceSchemaUrl,
ResourceAttributes: resourceAttrs,
ScopeSchemaUrl: scopeSchemaUrl,
ScopeName: scopeName,
ScopeVersion: scopeVersion,
ScopeAttributes: scopeAttrs,
LogAttributes: extractAttributes(lr.Attributes),
}
}
func severityTextFromNumber(n uint8) string {
switch {
case n == 0:
return ""
case n <= 4:
return "TRACE"
case n <= 8:
return "DEBUG"
case n <= 12:
return "INFO"
case n <= 16:
return "WARN"
case n <= 20:
return "ERROR"
default:
return "FATAL"
}
}
func anyValueToString(v *commonpb.AnyValue) string {
if v == nil || v.Value == nil {
return ""
}
switch val := v.Value.(type) {
case *commonpb.AnyValue_StringValue:
return val.StringValue
case *commonpb.AnyValue_IntValue:
return strconv.FormatInt(val.IntValue, 10)
case *commonpb.AnyValue_DoubleValue:
return strconv.FormatFloat(val.DoubleValue, 'g', -1, 64)
case *commonpb.AnyValue_BoolValue:
return strconv.FormatBool(val.BoolValue)
case *commonpb.AnyValue_BytesValue:
return string(val.BytesValue)
case *commonpb.AnyValue_ArrayValue:
items := make([]interface{}, 0, len(val.ArrayValue.Values))
for _, item := range val.ArrayValue.Values {
items = append(items, anyValueToJSON(item))
}
if b, err := json.Marshal(items); err == nil {
return string(b)
}
return ""
case *commonpb.AnyValue_KvlistValue:
m := make(map[string]interface{}, len(val.KvlistValue.Values))
for _, kv := range val.KvlistValue.Values {
m[kv.Key] = anyValueToJSON(kv.Value)
}
if b, err := json.Marshal(m); err == nil {
return string(b)
}
return ""
}
return ""
}
func anyValueToJSON(v *commonpb.AnyValue) interface{} {
if v == nil || v.Value == nil {
return nil
}
switch val := v.Value.(type) {
case *commonpb.AnyValue_StringValue:
return val.StringValue
case *commonpb.AnyValue_IntValue:
return val.IntValue
case *commonpb.AnyValue_DoubleValue:
return val.DoubleValue
case *commonpb.AnyValue_BoolValue:
return val.BoolValue
case *commonpb.AnyValue_BytesValue:
return val.BytesValue
case *commonpb.AnyValue_ArrayValue:
out := make([]interface{}, 0, len(val.ArrayValue.Values))
for _, item := range val.ArrayValue.Values {
out = append(out, anyValueToJSON(item))
}
return out
case *commonpb.AnyValue_KvlistValue:
out := make(map[string]interface{}, len(val.KvlistValue.Values))
for _, kv := range val.KvlistValue.Values {
out[kv.Key] = anyValueToJSON(kv.Value)
}
return out
}
return nil
}