exports.ts

import { getClient, getCurrentScope, getIsolationScope, withIsolationScope } from './currentScopes';
import { DEBUG_BUILD } from './debug-build';
import { captureLog, sendLog } from './log';
import type { CaptureContext } from './scope';
import { closeSession, makeSession, updateSession } from './session';
import type {
  CheckIn,
  Event,
  EventHint,
  EventProcessor,
  Extra,
  Extras,
  FinishedCheckIn,
  MonitorConfig,
  Primitive,
  Session,
  SessionContext,
  SeverityLevel,
  User,
} from './types-hoist';
import { isThenable } from './utils-hoist/is';
import { logger } from './utils-hoist/logger';
import { uuid4 } from './utils-hoist/misc';
import { timestampInSeconds } from './utils-hoist/time';
import { GLOBAL_OBJ } from './utils-hoist/worldwide';
import { parameterizeStringTemplate } from './utils/parameterize';
import type { ExclusiveEventHintOrCaptureContext } from './utils/prepareEvent';
import { parseEventHintOrCaptureContext } from './utils/prepareEvent';

/**
 * Captures an exception event and sends it to Sentry.
 *
 * @param exception The exception to capture.
 * @param hint Optional additional data to attach to the Sentry event.
 * @returns the id of the captured Sentry event.
 */
export function captureException(exception: unknown, hint?: ExclusiveEventHintOrCaptureContext): string {
  return getCurrentScope().captureException(exception, parseEventHintOrCaptureContext(hint));
}

/**
 * Captures a message event and sends it to Sentry.
 *
 * @param message The message to send to Sentry.
 * @param captureContext Define the level of the message or pass in additional data to attach to the message.
 * @returns the id of the captured message.
 */
export function captureMessage(message: string, captureContext?: CaptureContext | SeverityLevel): string {
  // This is necessary to provide explicit scopes upgrade, without changing the original
  // arity of the `captureMessage(message, level)` method.
  const level = typeof captureContext === 'string' ? captureContext : undefined;
  const context = typeof captureContext !== 'string' ? { captureContext } : undefined;
  return getCurrentScope().captureMessage(message, level, context);
}

/**
 * Captures a manually created event and sends it to Sentry.
 *
 * @param event The event to send to Sentry.
 * @param hint Optional additional data to attach to the Sentry event.
 * @returns the id of the captured event.
 */
export function captureEvent(event: Event, hint?: EventHint): string {
  return getCurrentScope().captureEvent(event, hint);
}

/**
 * Sets context data with the given name.
 * @param name of the context
 * @param context Any kind of data. This data will be normalized.
 */
export function setContext(name: string, context: { [key: string]: unknown } | null): void {
  getIsolationScope().setContext(name, context);
}

/**
 * Set an object that will be merged sent as extra data with the event.
 * @param extras Extras object to merge into current context.
 */
export function setExtras(extras: Extras): void {
  getIsolationScope().setExtras(extras);
}

/**
 * Set key:value that will be sent as extra data with the event.
 * @param key String of extra
 * @param extra Any kind of data. This data will be normalized.
 */
export function setExtra(key: string, extra: Extra): void {
  getIsolationScope().setExtra(key, extra);
}

/**
 * Set an object that will be merged sent as tags data with the event.
 * @param tags Tags context object to merge into current context.
 */
export function setTags(tags: { [key: string]: Primitive }): void {
  getIsolationScope().setTags(tags);
}

/**
 * Set key:value that will be sent as tags data with the event.
 *
 * Can also be used to unset a tag, by passing `undefined`.
 *
 * @param key String key of tag
 * @param value Value of tag
 */
export function setTag(key: string, value: Primitive): void {
  getIsolationScope().setTag(key, value);
}

/**
 * Updates user context information for future events.
 *
 * @param user User context object to be set in the current context. Pass `null` to unset the user.
 */
export function setUser(user: User | null): void {
  getIsolationScope().setUser(user);
}

/**
 * The last error event id of the isolation scope.
 *
 * Warning: This function really returns the last recorded error event id on the current
 * isolation scope. If you call this function after handling a certain error and another error
 * is captured in between, the last one is returned instead of the one you might expect.
 * Also, ids of events that were never sent to Sentry (for example because
 * they were dropped in `beforeSend`) could be returned.
 *
 * @returns The last event id of the isolation scope.
 */
export function lastEventId(): string | undefined {
  return getIsolationScope().lastEventId();
}

/**
 * Create a cron monitor check in and send it to Sentry.
 *
 * @param checkIn An object that describes a check in.
 * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want
 * to create a monitor automatically when sending a check in.
 */
export function captureCheckIn(checkIn: CheckIn, upsertMonitorConfig?: MonitorConfig): string {
  const scope = getCurrentScope();
  const client = getClient();
  if (!client) {
    DEBUG_BUILD && logger.warn('Cannot capture check-in. No client defined.');
  } else if (!client.captureCheckIn) {
    DEBUG_BUILD && logger.warn('Cannot capture check-in. Client does not support sending check-ins.');
  } else {
    return client.captureCheckIn(checkIn, upsertMonitorConfig, scope);
  }

  return uuid4();
}

/**
 * Wraps a callback with a cron monitor check in. The check in will be sent to Sentry when the callback finishes.
 *
 * @param monitorSlug The distinct slug of the monitor.
 * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want
 * to create a monitor automatically when sending a check in.
 */
export function withMonitor<T>(
  monitorSlug: CheckIn['monitorSlug'],
  callback: () => T,
  upsertMonitorConfig?: MonitorConfig,
): T {
  const checkInId = captureCheckIn({ monitorSlug, status: 'in_progress' }, upsertMonitorConfig);
  const now = timestampInSeconds();

  function finishCheckIn(status: FinishedCheckIn['status']): void {
    captureCheckIn({ monitorSlug, status, checkInId, duration: timestampInSeconds() - now });
  }

  return withIsolationScope(() => {
    let maybePromiseResult: T;
    try {
      maybePromiseResult = callback();
    } catch (e) {
      finishCheckIn('error');
      throw e;
    }

    if (isThenable(maybePromiseResult)) {
      Promise.resolve(maybePromiseResult).then(
        () => {
          finishCheckIn('ok');
        },
        e => {
          finishCheckIn('error');
          throw e;
        },
      );
    } else {
      finishCheckIn('ok');
    }

    return maybePromiseResult;
  });
}

/**
 * Call `flush()` on the current client, if there is one. See {@link Client.flush}.
 *
 * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause
 * the client to wait until all events are sent before resolving the promise.
 * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it
 * doesn't (or if there's no client defined).
 */
export async function flush(timeout?: number): Promise<boolean> {
  const client = getClient();
  if (client) {
    return client.flush(timeout);
  }
  DEBUG_BUILD && logger.warn('Cannot flush events. No client defined.');
  return Promise.resolve(false);
}

/**
 * Call `close()` on the current client, if there is one. See {@link Client.close}.
 *
 * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this
 * parameter will cause the client to wait until all events are sent before disabling itself.
 * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it
 * doesn't (or if there's no client defined).
 */
export async function close(timeout?: number): Promise<boolean> {
  const client = getClient();
  if (client) {
    return client.close(timeout);
  }
  DEBUG_BUILD && logger.warn('Cannot flush events and disable SDK. No client defined.');
  return Promise.resolve(false);
}

/**
 * Returns true if Sentry has been properly initialized.
 */
export function isInitialized(): boolean {
  return !!getClient();
}

/** If the SDK is initialized & enabled. */
export function isEnabled(): boolean {
  const client = getClient();
  return client?.getOptions().enabled !== false && !!client?.getTransport();
}

/**
 * Add an event processor.
 * This will be added to the current isolation scope, ensuring any event that is processed in the current execution
 * context will have the processor applied.
 */
export function addEventProcessor(callback: EventProcessor): void {
  getIsolationScope().addEventProcessor(callback);
}

/**
 * Start a session on the current isolation scope.
 *
 * @param context (optional) additional properties to be applied to the returned session object
 *
 * @returns the new active session
 */
export function startSession(context?: SessionContext): Session {
  const isolationScope = getIsolationScope();
  const currentScope = getCurrentScope();

  // Will fetch userAgent if called from browser sdk
  const { userAgent } = GLOBAL_OBJ.navigator || {};

  const session = makeSession({
    user: currentScope.getUser() || isolationScope.getUser(),
    ...(userAgent && { userAgent }),
    ...context,
  });

  // End existing session if there's one
  const currentSession = isolationScope.getSession();
  if (currentSession?.status === 'ok') {
    updateSession(currentSession, { status: 'exited' });
  }

  endSession();

  // Afterwards we set the new session on the scope
  isolationScope.setSession(session);

  return session;
}

/**
 * End the session on the current isolation scope.
 */
export function endSession(): void {
  const isolationScope = getIsolationScope();
  const currentScope = getCurrentScope();

  const session = currentScope.getSession() || isolationScope.getSession();
  if (session) {
    closeSession(session);
  }
  _sendSessionUpdate();

  // the session is over; take it off of the scope
  isolationScope.setSession();
}

/**
 * Sends the current Session on the scope
 */
function _sendSessionUpdate(): void {
  const isolationScope = getIsolationScope();
  const client = getClient();
  const session = isolationScope.getSession();
  if (session && client) {
    client.captureSession(session);
  }
}

/**
 * Sends the current session on the scope to Sentry
 *
 * @param end If set the session will be marked as exited and removed from the scope.
 *            Defaults to `false`.
 */
export function captureSession(end: boolean = false): void {
  // both send the update and pull the session from the scope
  if (end) {
    endSession();
    return;
  }

  // only send the update
  _sendSessionUpdate();
}

/**
 * A namespace for experimental logging functions.
 *
 * @experimental Will be removed in future versions. Use with caution.
 */
export const _experiment_log = {
  /**
   * A utility to record a log with level 'TRACE' and send it to sentry.
   *
   * Logs represent a message and some parameters which provide context for a trace or error.
   *
   * @example
   * ```js
   * const { trace, fmt } = Sentry._experiment_log;
   * trace(fmt`user ${username} just bought ${item}!`);
   * ```
   */
  trace: sendLog('trace'),
  /**
   * A utility to record a log with level 'DEBUG' and send it to sentry.
   *
   * Logs represent a message and some parameters which provide context for a trace or error.
   *
   * @example
   * ```js
   * const { debug, fmt } = Sentry._experiment_log;
   * debug(fmt`user ${username} just bought ${item}!`);
   * ```
   */
  debug: sendLog('debug'),
  /**
   * A utility to record a log with level 'INFO' and send it to sentry.
   *
   * Logs represent a message and some parameters which provide context for a trace or error.
   *
   * @example
   * ```js
   * const { info, fmt } = Sentry._experiment_log;
   * info(fmt`user ${username} just bought ${item}!`);
   * ```
   */
  info: sendLog('info'),
  /**
   * A utility to record a log with level 'INFO' and send it to sentry.
   *
   * Logs represent a message and some parameters which provide context for a trace or error.
   *
   * @example
   * ```js
   * const { log, fmt } = Sentry._experiment_log;
   * log(fmt`user ${username} just bought ${item}!`);
   * ```
   */
  log: sendLog('info', 10),
  /**
   * A utility to record a log with level 'ERROR' and send it to sentry.
   *
   * Logs represent a message and some parameters which provide context for a trace or error.
   *
   * @example
   * ```js
   * const { error, fmt } = Sentry._experiment_log;
   * error(fmt`user ${username} just bought ${item}!`);
   * ```
   */
  error: sendLog('error'),
  /**
   * A utility to record a log with level 'WARN' and send it to sentry.
   *
   * Logs represent a message and some parameters which provide context for a trace or error.
   *
   * @example
   * ```js
   * const { warn, fmt } = Sentry._experiment_log;
   * warn(fmt`user ${username} just bought ${item}!`);
   * ```
   */
  warn: sendLog('warn'),
  /**
   * A utility to record a log with level 'FATAL' and send it to sentry.
   *
   * Logs represent a message and some parameters which provide context for a trace or error.
   *
   * @example
   * ```js
   * const { fatal, fmt } = Sentry._experiment_log;
   * fatal(fmt`user ${username} just bought ${item}!`);
   * ```
   */
  fatal: sendLog('fatal'),

  /**
   * Tagged template function which returns parameterized representation of the message
   *
   * @example
   * ```js
   * Sentry._experiment_log.fmt`This is a log statement with ${x} and ${y} params`
   * ```
   */
  fmt: parameterizeStringTemplate,

  /**
   * A flexible utility to record a log with a custom level and send it to sentry.
   *
   * You can optionally pass in custom attributes and a custom severity number to be attached to the log.
   *
   * @example
   * ```js
   * Sentry._experiment_log.emit({ level: 'info', message: Sentry._experiment_log.fmt`user ${username }just bought ${item}`, attributes: { extra: 123 } })
   * ```
   */
  emit: captureLog,
};