add platform-specific base64 methods and attach them to the carrier

Author: lobsterkatie

packages/browser/src/helpers.ts

@@ -213,3 +213,40 @@ export function injectReportDialog(options: ReportDialogOptions = {}): void {
 
   (document.head || document.body).appendChild(script);
 }
+
+/**
+ * Convert a base64-encoded string back to plaintext. Does not include error handling.
+ *
+ * (This is here (and in the node package) rather than in @sentry/utils to prevent webpack from bundling the entire
+ * Buffer module when creating SDK users' vendor bundles for the browser. Used in @sentry/utils.string.)
+ *
+ * @param base64String The base64-encoded string
+ * @returns A plaintext version of the string, in JS's native encoding (UTF-16)
+ */
+export function unsafeFromBase64(base64String: string): string {
+  // `atob` returns a string rather than bytes, so we then need to encode using the native encoding (UTF-16)
+  const bytesAsString = atob(base64String);
+  const bytes = [...bytesAsString].map(char => char.charCodeAt(0));
+
+  // decode using UTF-8 (cast the `bytes` arry to a Uint8Array just because that's the format `decode()` expects)
+  return new TextDecoder().decode(Uint8Array.from(bytes));
+}
+
+/**
+ * Convert a string to base64 encoding. Does not include error handling.
+ *
+ * (This is here (and in the node package) rather than in @sentry/utils to prevent webpack from bundling the entire
+ * Buffer module when creating SDK users' vendor bundles for the browser. Used in @sentry/utils.string.)
+ *
+ * @param plaintext The original string, in JS's native encoding (UTF-16)
+ * @returns A base64-encoded version of the string
+ */
+export function unsafeToBase64(plaintext: string): string {
+  // encode using UTF-8
+  const bytes = new TextEncoder().encode(plaintext);
+
+  // decode using UTF-16 (JS's native encoding) since `btoa` requires string input
+  const bytesAsString = String.fromCharCode(...bytes);
+
+  return btoa(bytesAsString);
+}

packages/browser/src/index.ts

@@ -1,8 +1,9 @@
 export * from './exports';
 
 import { Integrations as CoreIntegrations } from '@sentry/core';
-import { getGlobalObject } from '@sentry/utils';
+import { addBase64MethodsToCarrier, getGlobalObject } from '@sentry/utils';
 
+import { unsafeFromBase64, unsafeToBase64 } from './helpers';
 import * as BrowserIntegrations from './integrations';
 import * as Transports from './transports';
 
@@ -21,3 +22,8 @@ const INTEGRATIONS = {
 };
 
 export { INTEGRATIONS as Integrations, Transports };
+
+// We need to patch these string utils on the global __SENTRY__ object to make them work for both browser and node in
+// cross-platform packages like @sentry/utils. If we don't do this, browser bundlers will mistakenly include node's
+// Buffer module.
+addBase64MethodsToCarrier({ unsafeFromBase64, unsafeToBase64 });

packages/node/src/index.ts

@@ -44,11 +44,12 @@ export { defaultIntegrations, init, lastEventId, flush, close } from './sdk';
 export { SDK_NAME } from './version';
 
 import { Integrations as CoreIntegrations } from '@sentry/core';
-import { getMainCarrier } from '@sentry/utils';
+import { addBase64MethodsToCarrier, getMainCarrier } from '@sentry/utils';
 import * as domain from 'domain';
 
 import * as Handlers from './handlers';
 import * as NodeIntegrations from './integrations';
+import { unsafeFromBase64, unsafeToBase64 } from './string';
 import * as Transports from './transports';
 
 const INTEGRATIONS = {
@@ -58,10 +59,12 @@ const INTEGRATIONS = {
 
 export { INTEGRATIONS as Integrations, Transports, Handlers };
 
-// We need to patch domain on the global __SENTRY__ object to make it work for node in cross-platform packages like
-// @sentry/hub. If we don't do this, browser bundlers will have troubles resolving `require('domain')`.
+// We need to patch domain and our string utils on the global __SENTRY__ object to make them work for node in
+// cross-platform packages like @sentry/hub. If we don't do this, browser bundlers will have troubles resolving
+// `require('domain')` and will mistakenly include node's Buffer module.
 const carrier = getMainCarrier();
 if (carrier.__SENTRY__) {
   carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};
   carrier.__SENTRY__.extensions.domain = carrier.__SENTRY__.extensions.domain || domain;
 }
+addBase64MethodsToCarrier({ unsafeFromBase64, unsafeToBase64 });

packages/node/src/string.ts

@@ -0,0 +1,32 @@
+/**
+ * Convert a base64-encoded string back to plaintext. Does not include error handling.
+ *
+ * (This is here (and in the browser package) rather than in @sentry/utils to prevent webpack from bundling the entire
+ * Buffer module when creating SDK users' vendor bundles for the browser. Used in @sentry/utils.string.)
+ *
+ * @param base64String The base64-encoded string
+ * @returns A plaintext version of the string, in Node's native encoding (UTF-8)
+ */
+export function unsafeFromBase64(base64String: string): string {
+  // unlike the browser, Node can go straight from base64 to bytes
+  const bytes = Buffer.from(base64String, 'base64');
+
+  // decode using UTF-8
+  return bytes.toString('utf-8');
+}
+/**
+ * Convert a string to base64 encoding. Does not include error handling.
+ *
+ * (This is here (and in the browser package) rather than in @sentry/utils to prevent webpack from bundling the entire
+ * Buffer module when creating SDK users' vendor bundles for the browser. Used in @sentry/utils.string.)
+ *
+ * @param plaintext The original string, in Node's native encoding (UTF-8)
+ * @returns A base64-encoded version of the string
+ */
+export function unsafeToBase64(plaintext: string): string {
+  // encode using UTF-8
+  const bytes = Buffer.from(plaintext, 'utf-8');
+
+  // unlike the browser, Node can go straight from bytes to base64
+  return bytes.toString('base64');
+}

packages/utils/src/compat.ts

@@ -52,3 +52,20 @@ export function getMainCarrier(): Carrier {
   };
   return carrier;
 }
+
+/**
+ * Add base64 conversion methods to Sentry's internal extensions. This is necessary to do separately for each platform
+ * so that bundlers don't include Node's `Buffer` package in SDK users' browser bundles.
+ */
+export function addBase64MethodsToCarrier(methods: {
+  unsafeToBase64: (plaintext: string) => string;
+  unsafeFromBase64: (plaintext: string) => string;
+}): void {
+  const { unsafeToBase64, unsafeFromBase64 } = methods;
+  const carrier = getMainCarrier();
+  if (carrier.__SENTRY__) {
+    carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};
+    carrier.__SENTRY__.extensions.unsafeFromBase64 = carrier.__SENTRY__.extensions.unsafeFromBase64 || unsafeFromBase64;
+    carrier.__SENTRY__.extensions.unsafeToBase64 = carrier.__SENTRY__.extensions.unsafeToBase64 || unsafeToBase64;
+  }
+}