Weave로 OpenTelemetry 트레이스 보내기

import { trace, context } from "@opentelemetry/api";
import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
import {
  BatchSpanProcessor,
  ConsoleSpanExporter,
} from "@opentelemetry/sdk-trace-base";
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
import { Resource } from "@opentelemetry/resources";

// 설정
const ENTITY = "<your-team-name>";
const PROJECT = "<your-project-name>";
const WANDB_API_KEY = process.env.WANDB_API_KEY;

if (!WANDB_API_KEY) {
  console.error("Error: WANDB_API_KEY environment variable is not set");
  console.error("Run: export WANDB_API_KEY=your_api_key_here");
  process.exit(1);
}

// OTel 설정
const WEAVE_OTLP_ENDPOINT = "https://trace.wandb.ai/otel/v1/traces";

const exporter = new OTLPTraceExporter({
  url: WEAVE_OTLP_ENDPOINT,
  headers: { "wandb-api-key": WANDB_API_KEY },
});

// span 프로세서로 트레이서 프로바이더 초기화
const provider = new NodeTracerProvider({
  resource: new Resource({
    "wandb.entity": ENTITY,
    "wandb.project": PROJECT,
  }),
  spanProcessors: [
    new BatchSpanProcessor(exporter),
    new BatchSpanProcessor(new ConsoleSpanExporter()),
  ],
});

// 트레이서 프로바이더 등록
provider.register();

// 전역 트레이서 프로바이더에서 트레이서 생성
const tracer = trace.getTracer("threads-examples");

function example_1_basic_thread_and_turn() {
  console.log("\n=== Example 1: Basic Thread and Turn ===");

  // 스레드 컨텍스트 생성
  const threadId = "thread_example_1";

  // 이 span은 턴을 나타냄(스레드의 직계 자식)
  tracer.startActiveSpan("process_user_message", (turnSpan) => {
    // 스레드 속성 설정
    turnSpan.setAttribute("wandb.thread_id", threadId);
    turnSpan.setAttribute("wandb.is_turn", true);

    // 예시 속성 추가
    turnSpan.setAttribute("input.value", "Hello, help me with setup");

    let response: string;
    
    // 중첩 span으로 작업 시뮬레이션
    tracer.startActiveSpan("generate_response", (nestedSpan) => {
      // 턴 내부의 중첩 Call이므로 is_turn은 false로 설정하거나 설정하지 않아야 함
      nestedSpan.setAttribute("wandb.thread_id", threadId);
      // 중첩 Call에서는 wandb.is_turn을 설정하지 않거나 false로 설정

      response = "I'll help you get started with the setup process.";
      nestedSpan.setAttribute("output.value", response);
      nestedSpan.end();
    });
    
    turnSpan.setAttribute("output.value", response!);
    console.log(`Turn completed in thread: ${threadId}`);
    turnSpan.end();
  });
}

function main() {
  example_1_basic_thread_and_turn();
}

main();

function example_2_multiple_turns() {
  console.log("\n=== Example 2: Multiple Turns in Thread ===");

  const threadId = "thread_conversation_123";

  // 턴 1
  tracer.startActiveSpan("process_message_turn1", (turn1Span) => {
    turn1Span.setAttribute("wandb.thread_id", threadId);
    turn1Span.setAttribute("wandb.is_turn", true);
    turn1Span.setAttribute(
      "input.value",
      "What programming languages do you recommend?"
    );

    // 중첩된 오퍼레이션
    tracer.startActiveSpan("analyze_query", (analyzeSpan) => {
      analyzeSpan.setAttribute("wandb.thread_id", threadId);
      // 중첩된 span에는 is_turn 속성을 지정하지 않거나 false로 설정
      analyzeSpan.end();
    });

    const response1 =
      "I recommend Python for beginners and JavaScript for web development.";
    turn1Span.setAttribute("output.value", response1);
    console.log(`Turn 1 completed in thread: ${threadId}`);
    turn1Span.end();
  });

  // 턴 2
  tracer.startActiveSpan("process_message_turn2", (turn2Span) => {
    turn2Span.setAttribute("wandb.thread_id", threadId);
    turn2Span.setAttribute("wandb.is_turn", true);
    turn2Span.setAttribute("input.value", "Can you explain Python vs JavaScript?");

    // 중첩된 오퍼레이션
    tracer.startActiveSpan("comparison_analysis", (compareSpan) => {
      compareSpan.setAttribute("wandb.thread_id", threadId);
      compareSpan.setAttribute("wandb.is_turn", false); // 중첩된 span이므로 명시적으로 false로 설정
      compareSpan.end();
    });

    const response2 =
      "Python excels at data science while JavaScript dominates web development.";
    turn2Span.setAttribute("output.value", response2);
    console.log(`Turn 2 completed in thread: ${threadId}`);
    turn2Span.end();
  });
}

function main() {
  example_2_multiple_turns();
}

main();

function example_3_complex_nested_structure() {
  console.log("\n=== Example 3: Complex Nested Structure ===");

  const threadId = "thread_complex_456";

  // 여러 단계로 중첩된 턴
  tracer.startActiveSpan("handle_complex_request", (turnSpan) => {
    turnSpan.setAttribute("wandb.thread_id", threadId);
    turnSpan.setAttribute("wandb.is_turn", true);
    turnSpan.setAttribute(
      "input.value",
      "Analyze this code and suggest improvements"
    );

    // 1단계 중첩 오퍼레이션
    tracer.startActiveSpan("code_analysis", (analysisSpan) => {
      analysisSpan.setAttribute("wandb.thread_id", threadId);
      // 중첩 오퍼레이션에는 is_turn을 설정하지 않음

      // 2단계 중첩 오퍼레이션
      tracer.startActiveSpan("syntax_check", (syntaxSpan) => {
        syntaxSpan.setAttribute("wandb.thread_id", threadId);
        syntaxSpan.setAttribute("result", "No syntax errors found");
        syntaxSpan.end();
      });

      // 또 다른 2단계 중첩 오퍼레이션
      tracer.startActiveSpan("performance_check", (perfSpan) => {
        perfSpan.setAttribute("wandb.thread_id", threadId);
        perfSpan.setAttribute("result", "Found 2 optimization opportunities");
        perfSpan.end();
      });

      analysisSpan.end();
    });

    // 또 다른 1단계 중첩 오퍼레이션
    tracer.startActiveSpan("generate_suggestions", (suggestSpan) => {
      suggestSpan.setAttribute("wandb.thread_id", threadId);
      const suggestions = ["Use list comprehension", "Consider caching results"];
      suggestSpan.setAttribute("suggestions", JSON.stringify(suggestions));
      suggestSpan.end();
    });

    turnSpan.setAttribute(
      "output.value",
      "Analysis complete with 2 improvement suggestions"
    );
    console.log(`Complex turn completed in thread: ${threadId}`);
    turnSpan.end();
  });
}

function main() {
  example_3_complex_nested_structure();
}

main();

function example_4_non_turn_operations() {
  console.log("\n=== Example 4: Non-Turn Thread Operations ===");

  const threadId = "thread_background_789";

  // 스레드에 속하지만 턴은 아닌 백그라운드 오퍼레이션
  tracer.startActiveSpan("background_indexing", (bgSpan) => {
    bgSpan.setAttribute("wandb.thread_id", threadId);
    // wandb.is_turn이 설정되지 않았거나 false이면 턴이 아님
    bgSpan.setAttribute("wandb.is_turn", false);
    bgSpan.setAttribute("operation", "Indexing conversation history");
    console.log(`Background operation in thread: ${threadId}`);
    bgSpan.end();
  });

  // 같은 스레드의 실제 턴
  tracer.startActiveSpan("user_query", (turnSpan) => {
    turnSpan.setAttribute("wandb.thread_id", threadId);
    turnSpan.setAttribute("wandb.is_turn", true);
    turnSpan.setAttribute("input.value", "Search my previous conversations");
    turnSpan.setAttribute("output.value", "Found 5 relevant conversations");
    console.log(`Turn completed in thread: ${threadId}`);
    turnSpan.end();
  });
}

function main() {
  example_4_non_turn_operations();
}

main();