meta: Update Changelog for 7.68.0

.npmignore

@@ -6,3 +6,4 @@
 !/cjs/**/*
 !/esm/**/*
 !/types/**/*
+!/types-ts3.8/**/*

CHANGELOG.md

@@ -4,6 +4,15 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
+## 7.68.0
+
+- feat(browser): Add `BroadcastChannel` and `SharedWorker` to TryCatch EventTargets (#8943)
+- feat(core): Add `name` to `Span` (#8949)
+- feat(core): Add `ServerRuntimeClient` (#8930)
+- fix(node-experimental): Ensure `span.finish()` works as expected (#8947)
+- fix(remix): Add new sourcemap-upload script files to prepack assets. (#8948)
+- fix(publish): Publish downleveled TS3.8 types and fix types path (#8954)
+
 ## 7.67.0
 
 ### Important Changes

MIGRATION.md

@@ -1,5 +1,13 @@
 # Deprecations in 7.x
 
+You can use [@sentry/migr8](https://www.npmjs.com/package/@sentry/migr8) to automatically update your SDK usage and fix most deprecations:
+
+```bash
+npx @sentry/migr8@latest
+```
+
+This will let you select which updates to run, and automatically update your code. Make sure to still review all code changes!
+
 ## Deprecate `timestampWithMs` export - #7878
 
 The `timestampWithMs` util is deprecated in favor of using `timestampInSeconds`.

packages/browser/src/integrations/trycatch.ts

@@ -9,6 +9,7 @@ const DEFAULT_EVENT_TARGET = [
   'Node',
   'ApplicationCache',
   'AudioTrackList',
+  'BroadcastChannel',
   'ChannelMergerNode',
   'CryptoOperation',
   'EventSource',
@@ -24,6 +25,7 @@ const DEFAULT_EVENT_TARGET = [
   'Notification',
   'SVGElementInstance',
   'Screen',
+  'SharedWorker',
   'TextTrack',
   'TextTrackCue',
   'TextTrackList',

packages/core/src/index.ts

@@ -1,6 +1,7 @@
 export type { ClientClass } from './sdk';
 export type { AsyncContextStrategy, Carrier, Layer, RunWithAsyncContextOptions } from './hub';
 export type { OfflineStore, OfflineTransportOptions } from './transports/offline';
+export type { ServerRuntimeClientOptions } from './server-runtime-client';
 
 export * from './tracing';
 export {
@@ -38,6 +39,7 @@ export { SessionFlusher } from './sessionflusher';
 export { addGlobalEventProcessor, Scope } from './scope';
 export { getEnvelopeEndpointWithUrlEncodedAuth, getReportDialogEndpoint } from './api';
 export { BaseClient } from './baseclient';
+export { ServerRuntimeClient } from './server-runtime-client';
 export { initAndBind } from './sdk';
 export { createTransport } from './transports/base';
 export { makeOfflineTransport } from './transports/offline';

packages/core/src/server-runtime-client.ts

@@ -0,0 +1,172 @@
+import type {
+  BaseTransportOptions,
+  CheckIn,
+  ClientOptions,
+  DynamicSamplingContext,
+  Event,
+  EventHint,
+  MonitorConfig,
+  SerializedCheckIn,
+  Severity,
+  SeverityLevel,
+  TraceContext,
+} from '@sentry/types';
+import { eventFromMessage, eventFromUnknownInput, logger, uuid4 } from '@sentry/utils';
+
+import { BaseClient } from './baseclient';
+import { createCheckInEnvelope } from './checkin';
+import { getCurrentHub } from './hub';
+import type { Scope } from './scope';
+import { addTracingExtensions, getDynamicSamplingContextFromClient } from './tracing';
+
+export interface ServerRuntimeClientOptions extends ClientOptions<BaseTransportOptions> {
+  platform?: string;
+  runtime?: { name: string; version?: string };
+  serverName?: string;
+}
+
+/**
+ * The Sentry Server Runtime Client SDK.
+ */
+export class ServerRuntimeClient<
+  O extends ClientOptions & ServerRuntimeClientOptions = ServerRuntimeClientOptions,
+> extends BaseClient<O> {
+  /**
+   * Creates a new Edge SDK instance.
+   * @param options Configuration options for this SDK.
+   */
+  public constructor(options: O) {
+    // Server clients always support tracing
+    addTracingExtensions();
+
+    super(options);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public eventFromException(exception: unknown, hint?: EventHint): PromiseLike<Event> {
+    return Promise.resolve(eventFromUnknownInput(getCurrentHub, this._options.stackParser, exception, hint));
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public eventFromMessage(
+    message: string,
+    // eslint-disable-next-line deprecation/deprecation
+    level: Severity | SeverityLevel = 'info',
+    hint?: EventHint,
+  ): PromiseLike<Event> {
+    return Promise.resolve(
+      eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace),
+    );
+  }
+
+  /**
+   * 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.
+   */
+  public captureCheckIn(checkIn: CheckIn, monitorConfig?: MonitorConfig, scope?: Scope): string {
+    const id = checkIn.status !== 'in_progress' && checkIn.checkInId ? checkIn.checkInId : uuid4();
+    if (!this._isEnabled()) {
+      __DEBUG_BUILD__ && logger.warn('SDK not enabled, will not capture checkin.');
+      return id;
+    }
+
+    const options = this.getOptions();
+    const { release, environment, tunnel } = options;
+
+    const serializedCheckIn: SerializedCheckIn = {
+      check_in_id: id,
+      monitor_slug: checkIn.monitorSlug,
+      status: checkIn.status,
+      release,
+      environment,
+    };
+
+    if (checkIn.status !== 'in_progress') {
+      serializedCheckIn.duration = checkIn.duration;
+    }
+
+    if (monitorConfig) {
+      serializedCheckIn.monitor_config = {
+        schedule: monitorConfig.schedule,
+        checkin_margin: monitorConfig.checkinMargin,
+        max_runtime: monitorConfig.maxRuntime,
+        timezone: monitorConfig.timezone,
+      };
+    }
+
+    const [dynamicSamplingContext, traceContext] = this._getTraceInfoFromScope(scope);
+    if (traceContext) {
+      serializedCheckIn.contexts = {
+        trace: traceContext,
+      };
+    }
+
+    const envelope = createCheckInEnvelope(
+      serializedCheckIn,
+      dynamicSamplingContext,
+      this.getSdkMetadata(),
+      tunnel,
+      this.getDsn(),
+    );
+
+    __DEBUG_BUILD__ && logger.info('Sending checkin:', checkIn.monitorSlug, checkIn.status);
+    void this._sendEnvelope(envelope);
+    return id;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  protected _prepareEvent(event: Event, hint: EventHint, scope?: Scope): PromiseLike<Event | null> {
+    if (this._options.platform) {
+      event.platform = event.platform || this._options.platform;
+    }
+
+    if (this._options.runtime) {
+      event.contexts = {
+        ...event.contexts,
+        runtime: (event.contexts || {}).runtime || this._options.runtime,
+      };
+    }
+
+    if (this._options.serverName) {
+      event.server_name = event.server_name || this._options.serverName;
+    }
+
+    return super._prepareEvent(event, hint, scope);
+  }
+
+  /** Extract trace information from scope */
+  private _getTraceInfoFromScope(
+    scope: Scope | undefined,
+  ): [dynamicSamplingContext: Partial<DynamicSamplingContext> | undefined, traceContext: TraceContext | undefined] {
+    if (!scope) {
+      return [undefined, undefined];
+    }
+
+    const span = scope.getSpan();
+    if (span) {
+      const samplingContext = span.transaction ? span.transaction.getDynamicSamplingContext() : undefined;
+      return [samplingContext, span.getTraceContext()];
+    }
+
+    const { traceId, spanId, parentSpanId, dsc } = scope.getPropagationContext();
+    const traceContext: TraceContext = {
+      trace_id: traceId,
+      span_id: spanId,
+      parent_span_id: parentSpanId,
+    };
+    if (dsc) {
+      return [dsc, traceContext];
+    }
+
+    return [getDynamicSamplingContextFromClient(traceId, this, scope), traceContext];
+  }
+}

packages/core/src/tracing/span.ts

@@ -161,6 +161,15 @@ export class Span implements SpanInterface {
     }
   }
 
+  /** An alias for `description` of the Span. */
+  public get name(): string {
+    return this.description || '';
+  }
+  /** Update the name of the span. */
+  public set name(name: string) {
+    this.setName(name);
+  }
+
   /**
    * @inheritDoc
    */