fix: avoid Blob.stream for native gzip (#3464)

* fix: avoid Blob.stream for native gzip

* test: parameterize gzip support checks

* fix: abort gzip writer on write failure

Author: dustinbyrne

.changeset/wise-owls-refuse.md

@@ -0,0 +1,6 @@
+---
+'@posthog/core': patch
+'posthog-js': patch
+---
+
+Avoid using `Blob.stream()` for native async gzip compression to prevent Safari `NotReadableError` stream failures.

packages/core/src/__tests__/gzip.spec.ts

@@ -34,11 +34,39 @@ describe('gzip', () => {
       expect(globalThis.CompressionStream).toBeDefined()
       expect(isGzipSupported()).toBe(true)
     })
-    it('should return false if CompressStream not available', () => {
-      const CompressionStream = globalThis.CompressionStream
-      delete (globalThis as any).CompressionStream
-      expect(isGzipSupported()).toBe(false)
-      ;(globalThis as any).CompressionStream = CompressionStream
+    it.each([
+      [
+        'CompressionStream',
+        () => {
+          const CompressionStream = globalThis.CompressionStream
+          delete (globalThis as any).CompressionStream
+          return () => ((globalThis as any).CompressionStream = CompressionStream)
+        },
+      ],
+      [
+        'TextEncoder',
+        () => {
+          const TextEncoder = globalThis.TextEncoder
+          delete (globalThis as any).TextEncoder
+          return () => ((globalThis as any).TextEncoder = TextEncoder)
+        },
+      ],
+      [
+        'Response.blob',
+        () => {
+          const blob = globalThis.Response.prototype.blob
+          delete (globalThis.Response.prototype as any).blob
+          return () => ((globalThis.Response.prototype as any).blob = blob)
+        },
+      ],
+    ])('should return false if %s not available', (_name, removeDependency) => {
+      const restoreDependency = removeDependency()
+
+      try {
+        expect(isGzipSupported()).toBe(false)
+      } finally {
+        restoreDependency()
+      }
     })
   })
   describe('isNativeAsyncGzipReadError', () => {
@@ -60,6 +88,44 @@ describe('gzip', () => {
       ;(globalThis as any).CompressionStream = CompressionStream
     })
 
+    it('does not read input using Blob.stream', async () => {
+      const blobStream = Blob.prototype.stream
+      Blob.prototype.stream = jest.fn(() => {
+        throw new Error('Blob.stream should not be used')
+      })
+
+      try {
+        const compressed = await gzipCompress(API_TEST_INPUT, false, { rethrow: true })
+        expect(compressed).not.toBe(null)
+      } finally {
+        Blob.prototype.stream = blobStream
+      }
+    })
+
+    it('aborts the compression writer when writing input fails', async () => {
+      const CompressionStream = globalThis.CompressionStream
+      const writeError = new Error('write failed')
+      const abort = jest.fn(() => Promise.resolve())
+
+      ;(globalThis as any).CompressionStream = jest.fn(() => ({
+        writable: {
+          getWriter: () => ({
+            write: () => Promise.reject(writeError),
+            close: jest.fn(),
+            abort,
+          }),
+        },
+        readable: new ReadableStream(),
+      }))
+
+      try {
+        await expect(gzipCompress(API_TEST_INPUT, false, { rethrow: true })).rejects.toBe(writeError)
+        expect(abort).toHaveBeenCalledWith(writeError)
+      } finally {
+        ;(globalThis as any).CompressionStream = CompressionStream
+      }
+    })
+
     it('compressed random data should match node', async () => {
       const compressed = await gzipCompress(RANDOM_TEST_INPUT)
       expect(compressed).not.toBe(null)

packages/core/src/gzip.ts

@@ -3,7 +3,12 @@
  * This API (as of 2025-05-07) is not available on React Native.
  */
 export function isGzipSupported(): boolean {
-  return 'CompressionStream' in globalThis
+  return (
+    'CompressionStream' in globalThis &&
+    'TextEncoder' in globalThis &&
+    'Response' in globalThis &&
+    typeof Response.prototype.blob === 'function'
+  )
 }
 
 export const isNativeAsyncGzipReadError = (error: unknown): boolean => {
@@ -31,15 +36,24 @@ export type GzipCompressOptions = {
  */
 export async function gzipCompress(input: string, isDebug = true, options?: GzipCompressOptions): Promise<Blob | null> {
   try {
-    // Turn the string into a stream using a Blob, and then compress it
-    const dataStream = new Blob([input], {
-      type: 'text/plain',
-    }).stream()
+    const compressedStream = new CompressionStream('gzip')
+    const writer = compressedStream.writable.getWriter()
 
-    const compressedStream = dataStream.pipeThrough(new CompressionStream('gzip'))
+    const writePromise = writer
+      .write(new TextEncoder().encode(input))
+      .then(() => writer.close())
+      .catch(async (err) => {
+        try {
+          await writer.abort(err)
+        } catch {
+          // Ignore abort failures and rethrow the original compression error below.
+        }
+        throw err
+      })
+    const responsePromise = new Response(compressedStream.readable).blob()
 
-    // Using a Response to easily extract the readablestream value. Decoding into a string for fetch
-    return await new Response(compressedStream).blob()
+    const [compressed] = await Promise.all([responsePromise, writePromise])
+    return compressed
   } catch (error) {
     if (options?.rethrow) {
       throw error