updates to langwatch sdk

Author: 0xdeafcafe

libraries/langwatch/attributes.go

@@ -1,16 +1,18 @@
 package langwatch
 
+import "go.opentelemetry.io/otel/attribute"
+
 const (
-	AttributeLangWatchInputKey       = "langwatch.input"
-	AttributeLangWatchOutputKey      = "langwatch.output"
-	AttributeLangWatchSpanTypeKey    = "langwatch.span.type"
-	AttributeLangWatchRAGContextsKey = "langwatch.rag_contexts"
-	AttributeLangWatchSDKVersionKey  = "langwatch.sdk.version"
-	AttributeLangWatchSDKNameKey     = "langwatch.sdk.name"
-	AttributeLangWatchSDKLanguageKey = "langwatch.sdk.language"
-	AttributeLangWatchTimestampsKey  = "langwatch.timestamps"
-	AttributeLangWatchParamsKey      = "langwatch.params"
-	AttributeLangWatchMetricsKey     = "langwatch.metrics"
-	AttributeLangWatchCustomerIdKey  = "langwatch.customer.id"
-	AttributeLangWatchThreadIdKey    = "langwatch.thread.id"
+	AttributeLangWatchInput       = attribute.Key("langwatch.input")
+	AttributeLangWatchOutput      = attribute.Key("langwatch.output")
+	AttributeLangWatchSpanType    = attribute.Key("langwatch.span.type")
+	AttributeLangWatchRAGContexts = attribute.Key("langwatch.contexts")
+	AttributeLangWatchSDKVersion  = attribute.Key("langwatch.sdk.version")
+	AttributeLangWatchSDKName     = attribute.Key("langwatch.sdk.name")
+	AttributeLangWatchSDKLanguage = attribute.Key("langwatch.sdk.language")
+	AttributeLangWatchTimestamps  = attribute.Key("langwatch.timestamps")
+	AttributeLangWatchParams      = attribute.Key("langwatch.params")
+	AttributeLangWatchCustomerId  = attribute.Key("langwatch.customer.id")
+	AttributeLangWatchThreadId    = attribute.Key("langwatch.thread.id")
+	AttributeLangWatchStreaming   = attribute.Key("langwatch.gen_ai.streaming")
 )

libraries/langwatch/span.go

@@ -4,13 +4,13 @@ import (
 	"encoding/json"
 	"log"
 
-	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/trace"
 
 	semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
 )
 
 type SpanType string
+type typeWrapperType string
 
 const (
 	SpanTypeSpan       SpanType = "span"
@@ -30,13 +30,10 @@ const (
 	SpanTypeConsumer   SpanType = "consumer"
 	SpanTypeTask       SpanType = "task"
 	SpanTypeUnknown    SpanType = "unknown"
-)
 
-type SpanMetrics struct {
-	PromptTokens     *int     `json:"prompt_tokens"`
-	CompletionTokens *int     `json:"completion_tokens"`
-	Cost             *float64 `json:"cost"`
-}
+	typeWrapperTypeJSON typeWrapperType = "json"
+	typeWrapperTypeText typeWrapperType = "text"
+)
 
 type SpanTimestamps struct {
 	StartedAtUnix    int64  `json:"started_at"`
@@ -50,67 +47,99 @@ type SpanRAGContextChunk struct {
 	Content    any    `json:"content"`
 }
 
-type LangWatchSpan struct {
+type typeWrapper struct {
+	Type  typeWrapperType `json:"type"`
+	Value any             `json:"value"`
+}
+
+type Span struct {
 	trace.Span
 }
 
-func (s *LangWatchSpan) RecordInput(input any) {
-	jsonStr, err := json.Marshal(input)
+func (s *Span) RecordInput(input any) {
+	jsonStr, err := json.Marshal(typeWrapper{
+		Type:  typeWrapperTypeJSON,
+		Value: input,
+	})
 	if err != nil {
 		log.Default().Printf("error marshalling input: %v", err)
 	}
 
-	s.SetAttributes(attribute.String(AttributeLangWatchInputKey, string(jsonStr)))
+	s.SetAttributes(AttributeLangWatchInput.String(string(jsonStr)))
 }
 
-func (s *LangWatchSpan) RecordOutput(output any) {
-	jsonStr, err := json.Marshal(output)
+func (s *Span) RecordInputString(input string) {
+	jsonStr, err := json.Marshal(typeWrapper{
+		Type:  typeWrapperTypeText,
+		Value: input,
+	})
 	if err != nil {
-		log.Default().Printf("error marshalling output: %v", err)
+		log.Default().Printf("error marshalling input: %v", err)
 	}
 
-	s.SetAttributes(attribute.String(AttributeLangWatchOutputKey, string(jsonStr)))
+	s.SetAttributes(AttributeLangWatchInput.String(string(jsonStr)))
 }
 
-func (s *LangWatchSpan) SetType(spanType SpanType) {
-	s.SetAttributes(attribute.String(AttributeLangWatchSpanTypeKey, string(spanType)))
+func (s *Span) RecordOutput(output any) {
+	jsonStr, err := json.Marshal(typeWrapper{
+		Type:  typeWrapperTypeJSON,
+		Value: output,
+	})
+	if err != nil {
+		log.Default().Printf("error marshalling output: %v", err)
+	}
+
+	s.SetAttributes(AttributeLangWatchOutput.String(string(jsonStr)))
 }
 
-func (s *LangWatchSpan) SetRequestModel(model string) {
-	s.SetAttributes(attribute.String(string(semconv.GenAiRequestModelKey), model))
+func (s *Span) RecordOutputString(output string) {
+	jsonStr, err := json.Marshal(typeWrapper{
+		Type:  typeWrapperTypeText,
+		Value: output,
+	})
+	if err != nil {
+		log.Default().Printf("error marshalling output: %v", err)
+	}
+
+	s.SetAttributes(AttributeLangWatchOutput.String(string(jsonStr)))
 }
 
-func (s *LangWatchSpan) SetResponseModel(model string) {
-	s.SetAttributes(attribute.String(string(semconv.GenAiResponseModelKey), model))
+func (s *Span) SetType(spanType SpanType) {
+	s.SetAttributes(AttributeLangWatchSpanType.String(string(spanType)))
 }
 
-func (s *LangWatchSpan) SetMetrics(metrics SpanMetrics) {
-	jsonStr, err := json.Marshal(metrics)
-	if err != nil {
-		log.Default().Printf("error marshalling metrics: %v", err)
-	}
+func (s *Span) SetRequestModel(model string) {
+	s.SetAttributes(semconv.GenAiRequestModelKey.String(model))
+}
 
-	s.SetAttributes(attribute.String(AttributeLangWatchMetricsKey, string(jsonStr)))
+func (s *Span) SetResponseModel(model string) {
+	s.SetAttributes(semconv.GenAiResponseModelKey.String(model))
 }
 
-func (s *LangWatchSpan) SetTimestamps(timestamps SpanTimestamps) {
-	jsonStr, err := json.Marshal(timestamps)
+func (s *Span) SetTimestamps(timestamps SpanTimestamps) {
+	jsonStr, err := json.Marshal(typeWrapper{
+		Type:  typeWrapperTypeJSON,
+		Value: timestamps,
+	})
 	if err != nil {
 		log.Default().Printf("error marshalling timestamps: %v", err)
 	}
 
-	s.SetAttributes(attribute.String(AttributeLangWatchTimestampsKey, string(jsonStr)))
+	s.SetAttributes(AttributeLangWatchTimestamps.String(string(jsonStr)))
 }
 
-func (s *LangWatchSpan) SetRAGContextChunks(contexts []SpanRAGContextChunk) {
-	jsonStr, err := json.Marshal(contexts)
+func (s *Span) SetRAGContextChunks(contexts []SpanRAGContextChunk) {
+	jsonStr, err := json.Marshal(typeWrapper{
+		Type:  typeWrapperTypeJSON,
+		Value: contexts,
+	})
 	if err != nil {
 		log.Default().Printf("error marshalling contexts: %v", err)
 	}
 
-	s.SetAttributes(attribute.String(AttributeLangWatchRAGContextsKey, string(jsonStr)))
+	s.SetAttributes(AttributeLangWatchRAGContexts.String(string(jsonStr)))
 }
 
-func (s *LangWatchSpan) SetRAGContextChunk(context SpanRAGContextChunk) {
+func (s *Span) SetRAGContextChunk(context SpanRAGContextChunk) {
 	s.SetRAGContextChunks([]SpanRAGContextChunk{context})
 }

libraries/langwatch/tracer.go

@@ -17,7 +17,7 @@ func Tracer(name string, options ...trace.TracerOption) *LangWatchTracer {
 	}
 }
 
-func (t *LangWatchTracer) Start(ctx context.Context, name string, opts ...trace.SpanStartOption) (context.Context, *LangWatchSpan) {
+func (t *LangWatchTracer) Start(ctx context.Context, name string, opts ...trace.SpanStartOption) (context.Context, *Span) {
 	ctx, span := t.tracer.Start(ctx, name, opts...)
-	return ctx, &LangWatchSpan{span}
+	return ctx, &Span{span}
 }