@bynder/compact-view 5.2.1 → 5.2.2

package/scope.js

@@ -0,0 +1,412 @@
+import { getGlobalEventProcessors as x, notifyEventProcessors as S } from "./eventProcessors.js";
+import { updateSession as v } from "./session.js";
+import { applyScopeDataToEvent as b } from "./applyScopeDataToEvent.js";
+import { isPlainObject as y } from "./is.js";
+import { dateTimestampInSeconds as L } from "./time.js";
+import { uuid4 as r } from "./misc.js";
+import { logger as a } from "./logger2.js";
+const P = 100;
+let h;
+class o {
+  /** Flag if notifying is happening. */
+  /** Callback for client to receive scope changes. */
+  /** Callback list that will be called after {@link applyToEvent}. */
+  /** Array of breadcrumbs. */
+  /** User */
+  /** Tags */
+  /** Extra */
+  /** Contexts */
+  /** Attachments */
+  /** Propagation Context for distributed tracing */
+  /**
+   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get
+   * sent to Sentry
+   */
+  /** Fingerprint */
+  /** Severity */
+  // eslint-disable-next-line deprecation/deprecation
+  /**
+   * Transaction Name
+   */
+  /** Span */
+  /** Session */
+  /** Request Mode Session Status */
+  /** The client on this scope */
+  // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.
+  constructor() {
+    this._notifyingListeners = !1, this._scopeListeners = [], this._eventProcessors = [], this._breadcrumbs = [], this._attachments = [], this._user = {}, this._tags = {}, this._extra = {}, this._contexts = {}, this._sdkProcessingMetadata = {}, this._propagationContext = c();
+  }
+  /**
+   * Inherit values from the parent scope.
+   * @deprecated Use `scope.clone()` and `new Scope()` instead.
+   */
+  static clone(t) {
+    return t ? t.clone() : new o();
+  }
+  /**
+   * Clone this scope instance.
+   */
+  clone() {
+    const t = new o();
+    return t._breadcrumbs = [...this._breadcrumbs], t._tags = { ...this._tags }, t._extra = { ...this._extra }, t._contexts = { ...this._contexts }, t._user = this._user, t._level = this._level, t._span = this._span, t._session = this._session, t._transactionName = this._transactionName, t._fingerprint = this._fingerprint, t._eventProcessors = [...this._eventProcessors], t._requestSession = this._requestSession, t._attachments = [...this._attachments], t._sdkProcessingMetadata = { ...this._sdkProcessingMetadata }, t._propagationContext = { ...this._propagationContext }, t._client = this._client, t;
+  }
+  /** Update the client on the scope. */
+  setClient(t) {
+    this._client = t;
+  }
+  /**
+   * Get the client assigned to this scope.
+   *
+   * It is generally recommended to use the global function `Sentry.getClient()` instead, unless you know what you are doing.
+   */
+  getClient() {
+    return this._client;
+  }
+  /**
+   * Add internal on change listener. Used for sub SDKs that need to store the scope.
+   * @hidden
+   */
+  addScopeListener(t) {
+    this._scopeListeners.push(t);
+  }
+  /**
+   * @inheritDoc
+   */
+  addEventProcessor(t) {
+    return this._eventProcessors.push(t), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setUser(t) {
+    return this._user = t || {
+      email: void 0,
+      id: void 0,
+      ip_address: void 0,
+      segment: void 0,
+      username: void 0
+    }, this._session && v(this._session, { user: t }), this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getUser() {
+    return this._user;
+  }
+  /**
+   * @inheritDoc
+   */
+  getRequestSession() {
+    return this._requestSession;
+  }
+  /**
+   * @inheritDoc
+   */
+  setRequestSession(t) {
+    return this._requestSession = t, this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setTags(t) {
+    return this._tags = {
+      ...this._tags,
+      ...t
+    }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setTag(t, s) {
+    return this._tags = { ...this._tags, [t]: s }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setExtras(t) {
+    return this._extra = {
+      ...this._extra,
+      ...t
+    }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setExtra(t, s) {
+    return this._extra = { ...this._extra, [t]: s }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setFingerprint(t) {
+    return this._fingerprint = t, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setLevel(t) {
+    return this._level = t, this._notifyScopeListeners(), this;
+  }
+  /**
+   * Sets the transaction name on the scope for future events.
+   */
+  setTransactionName(t) {
+    return this._transactionName = t, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setContext(t, s) {
+    return s === null ? delete this._contexts[t] : this._contexts[t] = s, this._notifyScopeListeners(), this;
+  }
+  /**
+   * Sets the Span on the scope.
+   * @param span Span
+   * @deprecated Instead of setting a span on a scope, use `startSpan()`/`startSpanManual()` instead.
+   */
+  setSpan(t) {
+    return this._span = t, this._notifyScopeListeners(), this;
+  }
+  /**
+   * Returns the `Span` if there is one.
+   * @deprecated Use `getActiveSpan()` instead.
+   */
+  getSpan() {
+    return this._span;
+  }
+  /**
+   * Returns the `Transaction` attached to the scope (if there is one).
+   * @deprecated You should not rely on the transaction, but just use `startSpan()` APIs instead.
+   */
+  getTransaction() {
+    const t = this._span;
+    return t && t.transaction;
+  }
+  /**
+   * @inheritDoc
+   */
+  setSession(t) {
+    return t ? this._session = t : delete this._session, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getSession() {
+    return this._session;
+  }
+  /**
+   * @inheritDoc
+   */
+  update(t) {
+    if (!t)
+      return this;
+    const s = typeof t == "function" ? t(this) : t;
+    if (s instanceof o) {
+      const e = s.getScopeData();
+      this._tags = { ...this._tags, ...e.tags }, this._extra = { ...this._extra, ...e.extra }, this._contexts = { ...this._contexts, ...e.contexts }, e.user && Object.keys(e.user).length && (this._user = e.user), e.level && (this._level = e.level), e.fingerprint.length && (this._fingerprint = e.fingerprint), s.getRequestSession() && (this._requestSession = s.getRequestSession()), e.propagationContext && (this._propagationContext = e.propagationContext);
+    } else if (y(s)) {
+      const e = t;
+      this._tags = { ...this._tags, ...e.tags }, this._extra = { ...this._extra, ...e.extra }, this._contexts = { ...this._contexts, ...e.contexts }, e.user && (this._user = e.user), e.level && (this._level = e.level), e.fingerprint && (this._fingerprint = e.fingerprint), e.requestSession && (this._requestSession = e.requestSession), e.propagationContext && (this._propagationContext = e.propagationContext);
+    }
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  clear() {
+    return this._breadcrumbs = [], this._tags = {}, this._extra = {}, this._user = {}, this._contexts = {}, this._level = void 0, this._transactionName = void 0, this._fingerprint = void 0, this._requestSession = void 0, this._span = void 0, this._session = void 0, this._notifyScopeListeners(), this._attachments = [], this._propagationContext = c(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  addBreadcrumb(t, s) {
+    const e = typeof s == "number" ? s : P;
+    if (e <= 0)
+      return this;
+    const i = {
+      timestamp: L(),
+      ...t
+    }, n = this._breadcrumbs;
+    return n.push(i), this._breadcrumbs = n.length > e ? n.slice(-e) : n, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getLastBreadcrumb() {
+    return this._breadcrumbs[this._breadcrumbs.length - 1];
+  }
+  /**
+   * @inheritDoc
+   */
+  clearBreadcrumbs() {
+    return this._breadcrumbs = [], this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  addAttachment(t) {
+    return this._attachments.push(t), this;
+  }
+  /**
+   * @inheritDoc
+   * @deprecated Use `getScopeData()` instead.
+   */
+  getAttachments() {
+    return this.getScopeData().attachments;
+  }
+  /**
+   * @inheritDoc
+   */
+  clearAttachments() {
+    return this._attachments = [], this;
+  }
+  /** @inheritDoc */
+  getScopeData() {
+    const {
+      _breadcrumbs: t,
+      _attachments: s,
+      _contexts: e,
+      _tags: i,
+      _extra: n,
+      _user: _,
+      _level: u,
+      _fingerprint: p,
+      _eventProcessors: g,
+      _propagationContext: d,
+      _sdkProcessingMetadata: f,
+      _transactionName: l,
+      _span: m
+    } = this;
+    return {
+      breadcrumbs: t,
+      attachments: s,
+      contexts: e,
+      tags: i,
+      extra: n,
+      user: _,
+      level: u,
+      fingerprint: p || [],
+      eventProcessors: g,
+      propagationContext: d,
+      sdkProcessingMetadata: f,
+      transactionName: l,
+      span: m
+    };
+  }
+  /**
+   * Applies data from the scope to the event and runs all event processors on it.
+   *
+   * @param event Event
+   * @param hint Object containing additional information about the original exception, for use by the event processors.
+   * @hidden
+   * @deprecated Use `applyScopeDataToEvent()` directly
+   */
+  applyToEvent(t, s = {}, e = []) {
+    b(t, this.getScopeData());
+    const i = [
+      ...e,
+      // eslint-disable-next-line deprecation/deprecation
+      ...x(),
+      ...this._eventProcessors
+    ];
+    return S(i, t, s);
+  }
+  /**
+   * Add data which will be accessible during event processing but won't get sent to Sentry
+   */
+  setSDKProcessingMetadata(t) {
+    return this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...t }, this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setPropagationContext(t) {
+    return this._propagationContext = t, this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getPropagationContext() {
+    return this._propagationContext;
+  }
+  /**
+   * Capture an exception for this scope.
+   *
+   * @param exception The exception to capture.
+   * @param hint Optinal additional data to attach to the Sentry event.
+   * @returns the id of the captured Sentry event.
+   */
+  captureException(t, s) {
+    const e = s && s.event_id ? s.event_id : r();
+    if (!this._client)
+      return a.warn("No client configured on scope - will not capture exception!"), e;
+    const i = new Error("Sentry syntheticException");
+    return this._client.captureException(
+      t,
+      {
+        originalException: t,
+        syntheticException: i,
+        ...s,
+        event_id: e
+      },
+      this
+    ), e;
+  }
+  /**
+   * Capture a message for this scope.
+   *
+   * @param message The message to capture.
+   * @param level An optional severity level to report the message with.
+   * @param hint Optional additional data to attach to the Sentry event.
+   * @returns the id of the captured message.
+   */
+  captureMessage(t, s, e) {
+    const i = e && e.event_id ? e.event_id : r();
+    if (!this._client)
+      return a.warn("No client configured on scope - will not capture message!"), i;
+    const n = new Error(t);
+    return this._client.captureMessage(
+      t,
+      s,
+      {
+        originalException: t,
+        syntheticException: n,
+        ...e,
+        event_id: i
+      },
+      this
+    ), i;
+  }
+  /**
+   * Captures a manually created event for this scope and sends it to Sentry.
+   *
+   * @param exception The event to capture.
+   * @param hint Optional additional data to attach to the Sentry event.
+   * @returns the id of the captured event.
+   */
+  captureEvent(t, s) {
+    const e = s && s.event_id ? s.event_id : r();
+    return this._client ? (this._client.captureEvent(t, { ...s, event_id: e }, this), e) : (a.warn("No client configured on scope - will not capture event!"), e);
+  }
+  /**
+   * This will be called on every set call.
+   */
+  _notifyScopeListeners() {
+    this._notifyingListeners || (this._notifyingListeners = !0, this._scopeListeners.forEach((t) => {
+      t(this);
+    }), this._notifyingListeners = !1);
+  }
+}
+function T() {
+  return h || (h = new o()), h;
+}
+function c() {
+  return {
+    traceId: r(),
+    spanId: r().substring(16)
+  };
+}
+export {
+  o as Scope,
+  T as getGlobalScope
+};