사용자 이벤트 추적

IMQA.userEvent.start(name?: string, attributes?: Attributes): string

const eventId = IMQA.userEvent.start('checkout-process', {
  'cart.items': 3,
  'user.type': 'premium'
});

IMQA.userEvent.end(id: string, attributes?: Attributes): void

IMQA.userEvent.end(eventId, {
  'checkout.result': 'success',
  'order.id': 'ORD-12345'
});

IMQA.userEvent.getActive(): UserEventInstance | undefined

const activeEvent = IMQA.userEvent.getActive();
if (activeEvent) {
  console.log('Active event:', activeEvent);
}

IMQA.userEvent.cancel(id: string): void

IMQA.userEvent.cancel(eventId);

IMQA.userEvent.with<T>(id: string, fn: () => T): T

const eventId = IMQA.userEvent.start('data-processing');

// 특정 이벤트 컨텍스트에서 비동기 작업 실행
const result = await IMQA.userEvent.with(eventId, async () => {
  // 이 안에서 발생하는 모든 fetch, console 등이 eventId와 연결됩니다
  const data = await fetchData();
  const processed = await processData(data);
  return processed;
});

IMQA.userEvent.end(eventId);

IMQA.userEvent.withActive<T>(fn: () => T): T

const eventId = IMQA.userEvent.start('batch-operation');

// 현재 활성 이벤트 컨텍스트에서 작업 실행
IMQA.userEvent.withActive(() => {
  performTask1();
  performTask2();
  performTask3();
});

IMQA.userEvent.end(eventId);

IMQA.userEvent.switchTo(id: string): void

const mainEventId = IMQA.userEvent.start('main-workflow');
const subEventId = IMQA.userEvent.start('sub-task');

// 서브 태스크 실행
performSubTask();

// 메인 워크플로우로 다시 전환
IMQA.userEvent.switchTo(mainEventId);
performMainTask();

IMQA.userEvent.end(subEventId);
IMQA.userEvent.end(mainEventId);

IMQA.userEvent.getActiveContext(): Context

const context = IMQA.userEvent.getActiveContext();
console.log('Active context:', context);

IMQA.userEvent.hasActiveUserEvent(): boolean

if (IMQA.userEvent.hasActiveUserEvent()) {
  console.log('User event is active');
  const activeEvent = IMQA.userEvent.getActive();
  console.log('Active event:', activeEvent);
}

IMQA.userEvent.getContext(id: string): Context | undefined

const eventId = IMQA.userEvent.start('my-event');
const context = IMQA.userEvent.getContext(eventId);

function handleButtonClick() {
  // 이벤트 시작
  const eventId = IMQA.userEvent.start('button-click', {
    'button.name': 'submit',
    'page.url': window.location.href,
  });

  // 비즈니스 로직 실행
  performBusinessLogic()
    .then(result => {
      // 성공 시 이벤트 완료
      IMQA.userEvent.end(eventId, {
        'action.result': 'success',
        'items.count': result.count,
      });
    })
    .catch(error => {
      // 에러 시 이벤트 완료
      IMQA.userEvent.end(eventId, {
        'action.result': 'error',
        'error.message': error.message,
      });
    });
}

function handleFormSubmit() {
  const eventId = IMQA.userEvent.start('form-submission', {
    'form.type': 'contact',
    'form.fields': 'name,email,message',
  });

  try {
    validateForm();
    submitForm();

    IMQA.userEvent.end(eventId, {
      'submission.result': 'success',
    });
  } catch (error) {
    IMQA.userEvent.end(eventId, {
      'submission.result': 'error',
      'error.type': error.constructor.name,
    });
    throw error;
  }
}

function handleFileUpload(file) {
  const eventId = IMQA.userEvent.start('file-upload', {
    'file.name': file.name,
    'file.size': file.size,
    'file.type': file.type,
  });

  // 사용자가 취소한 경우
  cancelButton.onclick = () => {
    IMQA.userEvent.cancel(eventId);
    uploadRequest.abort();
  };

  // 정상 처리
  uploadFile(file)
    .then(response => {
      IMQA.userEvent.end(eventId, {
        'upload.result': 'success',
        'upload.url': response.url,
      });
    })
    .catch(error => {
      IMQA.userEvent.end(eventId, {
        'upload.result': 'error',
        'error.message': error.message,
      });
    });
}

class CheckoutProcess {
  constructor() {
    this.eventId = null;
  }

  startCheckout() {
    this.eventId = IMQA.userEvent.start('checkout-workflow', {
      'cart.total': this.getCartTotal(),
      'cart.items.count': this.getCartItemCount(),
    });
  }

  processPayment() {
    if (!this.eventId) return;
    
    // 이벤트가 활성화되어 있으면 여기서 발생하는 모든 fetch, console 등이 자동으로 그룹화됨
    return paymentAPI.charge(this.paymentInfo)
      .then(result => {
        this.completeCheckout(result);
      })
      .catch(error => {
        this.failCheckout(error);
      });
  }

  completeCheckout(result) {
    if (!this.eventId) return;
    
    IMQA.userEvent.end(this.eventId, {
      'checkout.result': 'success',
      'order.id': result.orderId,
      'payment.method': result.paymentMethod,
      'total.amount': result.amount,
    });
    
    this.eventId = null;
  }

  failCheckout(error) {
    if (!this.eventId) return;
    
    IMQA.userEvent.end(this.eventId, {
      'checkout.result': 'error',
      'error.code': error.code,
      'error.message': error.message,
    });
    
    this.eventId = null;
  }

  cancelCheckout() {
    if (!this.eventId) return;
    
    IMQA.userEvent.cancel(this.eventId);
    this.eventId = null;
  }
}

// 메인 워크플로우와 서브 태스크를 동시에 추적
function complexWorkflow() {
  const mainEventId = IMQA.userEvent.start('main-workflow', {
    'workflow.type': 'data-processing'
  });

  // 메인 워크플로우 컨텍스트에서 초기 작업 수행
  loadInitialData();

  // 서브 태스크 시작 (메인 이벤트의 자식으로 추적됨)
  const subTaskId = IMQA.userEvent.start('sub-task-validation', {
    'task.type': 'validation'
  });

  // 서브 태스크 실행
  validateData();
  IMQA.userEvent.end(subTaskId, { 'validation.result': 'passed' });

  // 메인 워크플로우로 다시 전환
  IMQA.userEvent.switchTo(mainEventId);

  // 메인 워크플로우 계속 진행
  processData();
  saveResults();

  IMQA.userEvent.end(mainEventId, { 'workflow.result': 'success' });
}

// with 메서드를 사용한 명시적 컨텍스트 관리
async function processDataWithContext() {
  const eventId = IMQA.userEvent.start('data-processing');

  try {
    // 특정 이벤트 컨텍스트에서 비동기 작업 실행
    const result = await IMQA.userEvent.with(eventId, async () => {
      // 이 블록 내의 모든 계측이 eventId와 연결됩니다
      const rawData = await fetchRawData();
      const cleaned = await cleanData(rawData);
      const transformed = await transformData(cleaned);
      return transformed;
    });

    IMQA.userEvent.end(eventId, {
      'processing.result': 'success',
      'records.processed': result.length
    });
  } catch (error) {
    IMQA.userEvent.end(eventId, {
      'processing.result': 'error',
      'error.message': error.message
    });
  }
}

// withActive를 사용한 현재 활성 이벤트 활용
function batchOperation() {
  const eventId = IMQA.userEvent.start('batch-operation');

  const tasks = [task1, task2, task3, task4];

  // 현재 활성 이벤트 컨텍스트에서 각 작업 실행
  tasks.forEach(task => {
    IMQA.userEvent.withActive(() => {
      task.execute();
    });
  });

  IMQA.userEvent.end(eventId);
}

function handleSearch(query) {
  const eventId = IMQA.userEvent.start('search-operation', {
    'search.query': query,
    'search.type': 'full-text',
  });

  searchAPI.search(query)
    .then(results => {
      IMQA.userEvent.end(eventId, {
        'search.result.count': results.length,
        'search.duration': results.metadata.duration,
        'search.result': 'success',
      });
    })
    .catch(error => {
      IMQA.userEvent.end(eventId, {
        'search.result': 'error',
        'error.type': error.name,
      });
    });
}

// 좋은 예
IMQA.userEvent.start('checkout-payment-processing');
IMQA.userEvent.start('product-search');
IMQA.userEvent.start('user-profile-update');

// 나쁜 예
IMQA.userEvent.start('event1');
IMQA.userEvent.start('click');
IMQA.userEvent.start('process');

// 좋은 예 - 분석에 유용한 컨텍스트 제공
IMQA.userEvent.start('product-purchase', {
  'product.id': 'PROD-123',
  'product.category': 'electronics',
  'product.price': 299.99,
  'user.tier': 'premium'
});

// 나쁜 예 - 민감한 정보나 불필요한 데이터
IMQA.userEvent.start('product-purchase', {
  'credit.card.number': '1234-5678-9012-3456', // 절대 금지
  'user.password': 'secret123' // 절대 금지
});

function trackUserAction() {
  let eventId;
  
  try {
    eventId = IMQA.userEvent.start('user-action');
    // 비즈니스 로직
    performAction();
    IMQA.userEvent.end(eventId, { result: 'success' });
  } catch (error) {
    if (eventId) {
      IMQA.userEvent.end(eventId, {
        result: 'error',
        'error.message': error.message
      });
    }
    throw error;
  }
}

// 이벤트 ID를 적절히 관리하고 완료되지 않은 이벤트 방지
class UserEventManager {
  constructor() {
    this.activeEvents = new Map();
  }

  start(name, attributes) {
    const id = IMQA.userEvent.start(name, attributes);
    this.activeEvents.set(id, { name, startTime: Date.now() });
    return id;
  }

  end(id, attributes) {
    if (this.activeEvents.has(id)) {
      IMQA.userEvent.end(id, attributes);
      this.activeEvents.delete(id);
    }
  }

  cleanup() {
    // 오래된 이벤트 정리 (예: 5분 이상)
    const now = Date.now();
    for (const [id, event] of this.activeEvents) {
      if (now - event.startTime > 5 * 60 * 1000) {
        IMQA.userEvent.cancel(id);
        this.activeEvents.delete(id);
      }
    }
  }
}

// 이벤트 시작 (localStorage에 자동 저장됨)
const eventId = IMQA.userEvent.start('long-running-task');

// 페이지 새로고침 발생...

// 페이지 로드 후 자동으로 이벤트 복원
// IMQA 초기화 시 저장된 이벤트들이 자동으로 복원됩니다

const eventId = IMQA.userEvent.start('api-workflow');

// 이 시점부터 발생하는 모든 계측이 eventId와 연결됩니다:
// - fetch 요청
// - XMLHttpRequest
// - console 로그
// - 예외 발생
// - 사용자 상호작용
// - 커스텀 로그

await fetch('/api/data');  // eventId 컨텍스트로 추적됨
console.log('Processing'); // eventId 컨텍스트로 추적됨

IMQA.userEvent.end(eventId);

const parentEventId = IMQA.userEvent.start('parent-operation');

// 자식 이벤트 (parent의 컨텍스트 하위에 생성됨)
const childEventId = IMQA.userEvent.start('child-task');
performChildTask();
IMQA.userEvent.end(childEventId);

// 부모 이벤트로 자동 전환되어 계속 추적
performParentTask();
IMQA.userEvent.end(parentEventId);

// 이벤트 시작 시
// [UserEvent] Started event abc123 with context. All instrumentations will now use this context.

// 이벤트 종료 시
// [UserEvent] Ended event abc123, no more active events. Context reset to ROOT.

// 컨텍스트 전환 시
// [UserEvent] Switched context to event xyz789

// 이벤트 복원 시
// Restored current active event ID: abc123