// src/instrument.ts -- 이 파일을 main.ts 보다 먼저 import
import { createOtelSDK } from '@meshestra/otel';

const { sdk } = createOtelSDK({
  serviceName: process.env.SERVICE_NAME ?? 'my-service',
  exporters: [
    { type: 'trace',  url: 'http://otel-collector:4318/v1/traces' },
    { type: 'metric', url: 'http://otel-collector:4318/v1/metrics' },
    { type: 'log',    url: 'tcp://logstash:5044', transport: 'tcp' },
  ],
});

sdk.start();

// src/main.ts
import './instrument'; // 반드시 가장 먼저

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

// src/app.module.ts
import { Module } from '@nestjs/common';
import { OtelModule } from '@meshestra/otel';

@Module({
  imports: [
    OtelModule.forRoot({
      serviceName: process.env.SERVICE_NAME ?? 'my-service',
      exporters: [
        { type: 'trace',  url: process.env.OTEL_TRACE_URL! },
        { type: 'metric', url: process.env.OTEL_METRIC_URL! },
        { type: 'log',    url: process.env.LOG_URL!, transport: 'tcp' },
      ],
    }),
  ],
})
export class AppModule {}

import { Inject, Injectable } from '@nestjs/common';
import { OTEL_LOGGER, OtelLogger } from '@meshestra/otel';

@Injectable()
export class OrderService {
  constructor(
    @Inject(OTEL_LOGGER) private readonly logger: OtelLogger,
  ) {}

  async createOrder() {
    this.logger.info('주문 생성 시작');
  }
}

interface OtelConfig {
  /** 서비스 식별자. OTLP resource attribute로 사용됩니다. */
  serviceName: string;

  /** 내보낼 신호(trace / metric / log)별 exporter 설정 목록 */
  exporters: ExporterConfig[];
}

interface ExporterConfig {
  /** 신호 유형 */
  type: 'trace' | 'metric' | 'log';

  /**
   * 엔드포인트 URL
   * - trace / metric: OTLP HTTP URL (예: http://collector:4318/v1/traces)
   * - log: TCP URL (예: tcp://logstash:5044) 또는 HTTP URL
   */
  url: string;

  /** log 타입일 때만 사용. 'tcp'로 지정하면 TCP 소켓 전송을 활성화합니다. */
  transport?: 'http' | 'tcp';
}

OtelModule.forRoot(config: OtelConfig): DynamicModule

@Trace(options?: TraceOptions): MethodDecorator

@Injectable()
export class PaymentService {
  @Trace()
  async processPayment(orderId: string) {
    // 클래스명.메서드명 → 'PaymentService.processPayment'
  }

  @Trace({
    name: 'payment.process',
    attributes: { 'payment.gateway': 'stripe' },
    skipIf: (args) => args[0]?.isSystemEvent === true,
  })
  async processWithOptions(orderId: string) { ... }
}

@Injectable()
export class OrderEventHandler {
  @TraceEventHandler({ name: 'Handle.OrderCreated' })
  async handle(event: OrderCreatedEvent) {
    // event.headers에서 traceparent를 자동으로 추출하여
    // 발행 측의 스팬과 연결된 새 스팬을 시작합니다.
  }
}

// 발행 측 — 현재 컨텍스트를 헤더에 주입
const headers = TraceContextManager.inject({});
await eventBus.publish({ payload: event, headers });

// 소비 측 — 헤더에서 컨텍스트 복원
const parentContext = TraceContextManager.extract(event.headers);

// 복원된 컨텍스트 안에서 실행
TraceContextManager.runWith(parentContext, () => { ... });

const logger = createLogger('auth-service', {
  url: 'tcp://logstash:5044',
  transport: 'tcp',
});

logger.info('서버 시작', { port: 3000 });

// 발행 측
@Injectable()
export class OrderCommandHandler {
  @Trace({ name: 'OrderCommand.handle' })
  async execute(command: CreateOrderCommand) {
    const order = await Order.create(command);
    const headers = TraceContextManager.inject({});
    await this.eventBus.publish({ payload: new OrderCreatedEvent(order.id), headers });
  }
}

// 소비 측
@Injectable()
export class OrderProjection {
  @TraceEventHandler({ name: 'Handle.OrderCreated' })
  async handle(event: OrderCreatedEvent) {
    await this.repository.save(event.payload);
  }
}