@openobserve/browser-core 0.3.4 → 0.4.0-beta.1

package/src/tools/utils/timeUtils.ts

@@ -1,117 +0,0 @@
-import { isNumber, round } from './numberUtils'
-
-export const ONE_SECOND = 1000
-export const ONE_MINUTE = 60 * ONE_SECOND
-export const ONE_HOUR = 60 * ONE_MINUTE
-export const ONE_DAY = 24 * ONE_HOUR
-export const ONE_YEAR = 365 * ONE_DAY
-
-export type Duration = number & { d: 'Duration in ms' }
-export type ServerDuration = number & { s: 'Duration in ns' }
-export type TimeStamp = number & { t: 'Epoch time' }
-export type RelativeTime = number & { r: 'Time relative to navigation start' } & { d: 'Duration in ms' }
-export interface ClocksState {
-  relative: RelativeTime
-  timeStamp: TimeStamp
-}
-
-export function relativeToClocks(relative: RelativeTime) {
-  return { relative, timeStamp: getCorrectedTimeStamp(relative) }
-}
-
-export function timeStampToClocks(timeStamp: TimeStamp) {
-  return { relative: getRelativeTime(timeStamp), timeStamp }
-}
-
-function getCorrectedTimeStamp(relativeTime: RelativeTime) {
-  const correctedOrigin = (dateNow() - performance.now()) as TimeStamp
-  // apply correction only for positive drift
-  if (correctedOrigin > getNavigationStart()) {
-    return Math.round(addDuration(correctedOrigin, relativeTime)) as TimeStamp
-  }
-  return getTimeStamp(relativeTime)
-}
-
-export function currentDrift() {
-  return Math.round(dateNow() - addDuration(getNavigationStart(), performance.now() as Duration))
-}
-
-export function toServerDuration(duration: Duration): ServerDuration
-export function toServerDuration(duration: Duration | undefined): ServerDuration | undefined
-export function toServerDuration(duration: Duration | undefined) {
-  if (!isNumber(duration)) {
-    return duration
-  }
-  return round(duration * 1e6, 0) as ServerDuration
-}
-
-export function dateNow() {
-  // Do not use `Date.now` because sometimes websites are wrongly "polyfilling" it. For example, we
-  // had some users using a very old version of `datejs`, which patched `Date.now` to return a Date
-  // instance instead of a timestamp[1]. Those users are unlikely to fix this, so let's handle this
-  // case ourselves.
-  // [1]: https://github.com/datejs/Datejs/blob/97f5c7c58c5bc5accdab8aa7602b6ac56462d778/src/core-debug.js#L14-L16
-  return new Date().getTime()
-}
-
-export function timeStampNow() {
-  return dateNow() as TimeStamp
-}
-
-export function relativeNow() {
-  return performance.now() as RelativeTime
-}
-
-export function clocksNow() {
-  return { relative: relativeNow(), timeStamp: timeStampNow() }
-}
-
-export function clocksOrigin() {
-  return { relative: 0 as RelativeTime, timeStamp: getNavigationStart() }
-}
-
-export function elapsed(start: TimeStamp, end: TimeStamp): Duration
-export function elapsed(start: RelativeTime, end: RelativeTime): Duration
-export function elapsed(start: number, end: number) {
-  return (end - start) as Duration
-}
-
-export function addDuration(a: TimeStamp, b: Duration): TimeStamp
-export function addDuration(a: RelativeTime, b: Duration): RelativeTime
-export function addDuration(a: Duration, b: Duration): Duration
-export function addDuration(a: number, b: number) {
-  return a + b
-}
-
-// Get the time since the navigation was started.
-export function getRelativeTime(timestamp: TimeStamp) {
-  return (timestamp - getNavigationStart()) as RelativeTime
-}
-
-export function getTimeStamp(relativeTime: RelativeTime) {
-  return Math.round(addDuration(getNavigationStart(), relativeTime)) as TimeStamp
-}
-
-export function looksLikeRelativeTime(time: RelativeTime | TimeStamp): time is RelativeTime {
-  return time < ONE_YEAR
-}
-
-/**
- * Navigation start slightly change on some rare cases
- */
-let navigationStart: TimeStamp | undefined
-
-/**
- * Notes: this does not use `performance.timeOrigin` because:
- * - It doesn't seem to reflect the actual time on which the navigation has started: it may be much farther in the past,
- * at least in Firefox 71. (see: https://bugzilla.mozilla.org/show_bug.cgi?id=1429926)
- * - It is not supported in Safari <15
- */
-function getNavigationStart() {
-  if (navigationStart === undefined) {
-    // ServiceWorkers do not support navigationStart (it's deprecated), so we fallback to timeOrigin
-    navigationStart = (performance.timing?.navigationStart ?? performance.timeOrigin) as TimeStamp
-  }
-
-  return navigationStart
-}

package/src/tools/utils/typeUtils.spec.ts

@@ -1,25 +0,0 @@
-import { getType } from './typeUtils'
-
-describe('typeUtils', () => {
-  describe('getType', () => {
-    it('should return "null" for null value', () => {
-      expect(getType(null)).toEqual('null')
-      expect(getType(undefined)).not.toEqual('null')
-    })
-
-    it('should return "array" for array value', () => {
-      expect(getType([])).toEqual('array')
-      expect(getType([1, 2, 3])).toEqual('array')
-      expect(getType([1, 2, [3, 4, 5]])).toEqual('array')
-    })
-
-    it('should return result of typeof operator for other types', () => {
-      expect(getType({})).toEqual('object')
-      expect(getType(() => null)).toEqual('function')
-      expect(getType('test')).toEqual('string')
-      expect(getType(1)).toEqual('number')
-      expect(getType(false)).toEqual('boolean')
-      expect(getType(new Date())).toEqual('object')
-    })
-  })
-})

package/src/tools/utils/typeUtils.ts

@@ -1,12 +0,0 @@
-/**
- * Similar to `typeof`, but distinguish plain objects from `null` and arrays
- */
-export function getType(value: unknown) {
-  if (value === null) {
-    return 'null'
-  }
-  if (Array.isArray(value)) {
-    return 'array'
-  }
-  return typeof value
-}

package/src/tools/utils/urlPolyfill.spec.ts

@@ -1,55 +0,0 @@
-import { buildUrl, getPathName, isValidUrl, normalizeUrl, getPristineWindow } from './urlPolyfill'
-
-describe('normalize url', () => {
-  it('should resolve absolute paths', () => {
-    expect(normalizeUrl('/my/path')).toEqual(`${location.origin}/my/path`)
-  })
-
-  it('should resolve relative paths', () => {
-    history.pushState({}, '', '/foo/')
-    expect(normalizeUrl('./my/path')).toEqual(`${location.origin}/foo/my/path`)
-  })
-
-  it('should add protocol to relative url', () => {
-    expect(normalizeUrl('//foo.com:9876/my/path')).toEqual('http://foo.com:9876/my/path')
-  })
-
-  it('should keep full url unchanged', () => {
-    expect(normalizeUrl('https://foo.com/my/path')).toEqual('https://foo.com/my/path')
-  })
-
-  it('should keep non http url unchanged', () => {
-    expect(normalizeUrl('ftp://foo.com/my/path')).toEqual('ftp://foo.com/my/path')
-  })
-
-  it('should keep file url unchanged', () => {
-    // On firefox, URL host is empty for file URI: 'https://bugzilla.mozilla.org/show_bug.cgi?id=1578787'
-    // In some cases, Mobile Safari also have this issue.
-    // As we should follow the browser behavior, having one or the other doesn't matter too much, so
-    // let's check for both.
-    expect(['file:///my/path', 'file://foo.com/my/path']).toContain(normalizeUrl('file://foo.com/my/path'))
-  })
-})
-
-describe('isValidUrl', () => {
-  it('should ensure url is valid', () => {
-    expect(isValidUrl('https://cloud.openobserve.ai/')).toBe(true)
-    expect(isValidUrl('https://api.openobserve.ai/')).toBe(true)
-    expect(isValidUrl('file://cloud.openobserve.ai')).toBe(true)
-    expect(isValidUrl('/plop')).toBe(false)
-    expect(isValidUrl('')).toBe(false)
-  })
-
-  it('should return the same result if the URL has been wrongfully overridden between calls', () => {
-    expect(isValidUrl('https://cloud.openobserve.ai/')).toBe(true)
-    spyOn(window, 'URL').and.throwError('wrong URL override')
-    expect(isValidUrl('https://cloud.openobserve.ai')).toBe(true)
-  })
-})
-
-describe('getPathName', () => {
-  it('should retrieve url path name', () => {
-    expect(getPathName('http://cloud.openobserve.ai')).toBe('/')
-    expect(getPathName('http://cloud.openobserve.ai/foo/bar?a=b#hello')).toBe('/foo/bar')
-  })
-})

package/src/tools/valueHistory.spec.ts

@@ -1,180 +0,0 @@
-import type { Clock } from '../../test'
-import { mockClock } from '../../test'
-import type { Duration, RelativeTime } from './utils/timeUtils'
-import { addDuration, ONE_MINUTE } from './utils/timeUtils'
-import { CLEAR_OLD_VALUES_INTERVAL, type ValueHistory, createValueHistory } from './valueHistory'
-
-const EXPIRE_DELAY = 10 * ONE_MINUTE
-const MAX_ENTRIES = 5
-
-describe('valueHistory', () => {
-  let valueHistory: ValueHistory<string>
-  let clock: Clock
-
-  beforeEach(() => {
-    clock = mockClock()
-    valueHistory = createValueHistory({ expireDelay: EXPIRE_DELAY, maxEntries: MAX_ENTRIES })
-  })
-
-  afterEach(() => {
-    valueHistory.stop()
-  })
-
-  describe('find', () => {
-    it('should return undefined when there is no active entry and no startTime', () => {
-      expect(valueHistory.find()).toBeUndefined()
-    })
-
-    it('should return the value of the first active entry when there is no startTime', () => {
-      valueHistory.add('foo', 0 as RelativeTime)
-
-      expect(valueHistory.find()).toEqual('foo')
-    })
-
-    it('should return undefined if the most recent entry is closed and no startTime', () => {
-      valueHistory.add('foo', 0 as RelativeTime).close(5 as RelativeTime)
-
-      expect(valueHistory.find()).toBeUndefined()
-    })
-
-    it('should return the value of entries matching startTime', () => {
-      valueHistory.add('foo', 0 as RelativeTime).close(5 as RelativeTime)
-      valueHistory.add('bar', 5 as RelativeTime).close(10 as RelativeTime)
-      valueHistory.add('qux', 10 as RelativeTime)
-
-      expect(valueHistory.find(2 as RelativeTime)).toEqual('foo')
-      expect(valueHistory.find(7 as RelativeTime)).toEqual('bar')
-      expect(valueHistory.find(10 as RelativeTime)).toEqual('qux')
-    })
-
-    it('should return undefined when no entries matches startTime', () => {
-      valueHistory.add('foo', 0 as RelativeTime).close(10 as RelativeTime)
-      valueHistory.add('bar', 20 as RelativeTime)
-
-      expect(valueHistory.find(15 as RelativeTime)).toBeUndefined()
-    })
-
-    describe('with `option.returnInactive` true', () => {
-      it('should return the value of the closest entry regardless of the being closed', () => {
-        valueHistory.add('foo', 0 as RelativeTime).close(10 as RelativeTime)
-        valueHistory.add('bar', 20 as RelativeTime)
-        expect(valueHistory.find(15 as RelativeTime, { returnInactive: true })).toEqual('foo')
-      })
-    })
-  })
-
-  describe('findAll', () => {
-    it('should return an empty array when there is no active entry and no startTime', () => {
-      expect(valueHistory.findAll()).toEqual([])
-    })
-
-    it('should return all active entry value when there is no startTime', () => {
-      valueHistory.add('foo', 0 as RelativeTime)
-      valueHistory.add('bar', 5 as RelativeTime).close(10 as RelativeTime)
-      valueHistory.add('qux', 10 as RelativeTime)
-
-      expect(valueHistory.findAll()).toEqual(['qux', 'foo'])
-    })
-
-    it('should return the entries of entries matching startTime', () => {
-      valueHistory.add('foo', 0 as RelativeTime).close(6 as RelativeTime)
-      valueHistory.add('bar', 5 as RelativeTime).close(8 as RelativeTime)
-      valueHistory.add('qux', 10 as RelativeTime)
-
-      expect(valueHistory.findAll(2 as RelativeTime)).toEqual(['foo'])
-      expect(valueHistory.findAll(5 as RelativeTime)).toEqual(['bar', 'foo'])
-      expect(valueHistory.findAll(7 as RelativeTime)).toEqual(['bar'])
-      expect(valueHistory.findAll(9 as RelativeTime)).toEqual([])
-      expect(valueHistory.findAll(10 as RelativeTime)).toEqual(['qux'])
-    })
-
-    it('should return an empty array when no entry is matching startTime', () => {
-      valueHistory.add('foo', 0 as RelativeTime).close(10 as RelativeTime)
-      valueHistory.add('bar', 20 as RelativeTime)
-
-      expect(valueHistory.findAll(15 as RelativeTime)).toEqual([])
-    })
-
-    it('should return all context overlapping with the duration', () => {
-      valueHistory.add('foo', 0 as RelativeTime)
-      valueHistory.add('bar', 5 as RelativeTime).close(10 as RelativeTime)
-      valueHistory.add('baz', 10 as RelativeTime).close(15 as RelativeTime)
-      valueHistory.add('qux', 15 as RelativeTime)
-
-      expect(valueHistory.findAll(0 as RelativeTime, 20 as Duration)).toEqual(['qux', 'baz', 'bar', 'foo'])
-      expect(valueHistory.findAll(6 as RelativeTime, 5 as Duration)).toEqual(['baz', 'bar', 'foo'])
-      expect(valueHistory.findAll(11 as RelativeTime, 5 as Duration)).toEqual(['qux', 'baz', 'foo'])
-    })
-  })
-
-  describe('removing entries', () => {
-    it('should not return removed entries', () => {
-      valueHistory.add('foo', 0 as RelativeTime).remove()
-      expect(valueHistory.find()).toBeUndefined()
-    })
-
-    it('removing an entry twice should not impact other entries', () => {
-      valueHistory.add('bar', 5 as RelativeTime)
-      const entry = valueHistory.add('foo', 0 as RelativeTime)
-      entry.remove()
-      entry.remove()
-      expect(valueHistory.find()).toEqual('bar')
-    })
-  })
-
-  it('should reset values', () => {
-    valueHistory.add('foo', 0 as RelativeTime).close(10 as RelativeTime)
-    valueHistory.add('bar', 10 as RelativeTime)
-
-    valueHistory.reset()
-
-    expect(valueHistory.find()).toBeUndefined()
-    expect(valueHistory.find(0 as RelativeTime)).toBeUndefined()
-  })
-
-  describe('clearing old values', () => {
-    it('should clear old values after expiration', () => {
-      const originalTime = performance.now() as RelativeTime
-      valueHistory.add('foo', originalTime).close(addDuration(originalTime, 10 as Duration))
-      clock.tick(10)
-
-      expect(valueHistory.find(originalTime)).toBeDefined()
-
-      clock.tick(EXPIRE_DELAY + CLEAR_OLD_VALUES_INTERVAL)
-
-      expect(valueHistory.find(originalTime)).toBeUndefined()
-    })
-
-    it('should clear multiple histories at the same time to avoid race condition', () => {
-      const delay = 5
-      const originalTime = performance.now() as RelativeTime
-
-      const valueHistory1 = createValueHistory({ expireDelay: EXPIRE_DELAY })
-      clock.tick(delay)
-      const valueHistory2 = createValueHistory({ expireDelay: EXPIRE_DELAY })
-
-      valueHistory1.add('foo', originalTime).close(addDuration(originalTime, 10 as Duration))
-      valueHistory2.add('bar', originalTime).close(addDuration(originalTime, 10 as Duration))
-
-      expect(valueHistory1.find(originalTime)).toBeDefined()
-      expect(valueHistory2.find(originalTime)).toBeDefined()
-
-      clock.tick(EXPIRE_DELAY + CLEAR_OLD_VALUES_INTERVAL - delay)
-
-      expect(valueHistory1.find(originalTime)).toBeUndefined()
-      expect(valueHistory2.find(originalTime)).toBeUndefined()
-
-      valueHistory1.stop()
-      valueHistory2.stop()
-    })
-  })
-
-  it('should limit the number of entries', () => {
-    for (let i = 0; i < MAX_ENTRIES + 1; i++) {
-      valueHistory.add(`${i}`, 0 as RelativeTime)
-    }
-    const values = valueHistory.findAll()
-    expect(values.length).toEqual(5)
-    expect(values).toEqual(['5', '4', '3', '2', '1'])
-  })
-})

package/src/transport/batch.spec.ts

@@ -1,261 +0,0 @@
-import { Observable } from '..'
-import type { MockFlushController } from '../../test'
-import { createMockFlushController } from '../../test'
-import { display } from '../tools/display'
-import type { Encoder } from '../tools/encoder'
-import { createIdentityEncoder } from '../tools/encoder'
-import { createBatch, MESSAGE_BYTES_LIMIT, type Batch } from './batch'
-import type { HttpRequest, HttpRequestEvent } from './httpRequest'
-
-describe('batch', () => {
-  const BIG_MESSAGE_OVER_BYTES_LIMIT = { message: 'x'.repeat(MESSAGE_BYTES_LIMIT + 1) }
-  const SMALL_MESSAGE = { message: 'hello' }
-  const SMALL_MESSAGE_BYTES_COUNT = 19
-  const SEPARATOR_BYTES_COUNT = 1
-
-  let batch: Batch
-  let transport: {
-    observable: Observable<HttpRequestEvent>
-    send: jasmine.Spy<HttpRequest['send']>
-    sendOnExit: jasmine.Spy<HttpRequest['sendOnExit']>
-  }
-
-  let flushController: MockFlushController
-  let encoder: Encoder<string>
-
-  beforeEach(() => {
-    transport = {
-      observable: new Observable<HttpRequestEvent>(),
-      send: jasmine.createSpy(),
-      sendOnExit: jasmine.createSpy(),
-    } satisfies HttpRequest
-    flushController = createMockFlushController()
-    encoder = createIdentityEncoder()
-    batch = createBatch({ encoder, request: transport, flushController })
-  })
-
-  it('should send a message', () => {
-    batch.add(SMALL_MESSAGE)
-
-    flushController.notifyFlush()
-
-    expect(transport.send.calls.mostRecent().args[0]).toEqual({
-      data: '{"message":"hello"}',
-      bytesCount: SMALL_MESSAGE_BYTES_COUNT,
-      encoding: undefined,
-    })
-  })
-
-  describe('adding a message', () => {
-    it('should add message to the flush controller', () => {
-      batch.add(SMALL_MESSAGE)
-
-      expect(flushController.notifyBeforeAddMessage).toHaveBeenCalledOnceWith(SMALL_MESSAGE_BYTES_COUNT)
-      expect(flushController.notifyAfterAddMessage).toHaveBeenCalledOnceWith(0)
-    })
-
-    it('should consider separators when adding message', () => {
-      batch.add(SMALL_MESSAGE)
-      batch.add(SMALL_MESSAGE)
-      batch.add(SMALL_MESSAGE)
-
-      expect(flushController.bytesCount).toEqual(
-        SMALL_MESSAGE_BYTES_COUNT +
-          SEPARATOR_BYTES_COUNT +
-          SMALL_MESSAGE_BYTES_COUNT +
-          SEPARATOR_BYTES_COUNT +
-          SMALL_MESSAGE_BYTES_COUNT
-      )
-    })
-
-    it('should remove the estimated message bytes count when replacing a message', () => {
-      batch.add(SMALL_MESSAGE)
-      batch.upsert(SMALL_MESSAGE, 'a')
-
-      flushController.notifyBeforeAddMessage.calls.reset()
-
-      batch.upsert(SMALL_MESSAGE, 'a')
-
-      expect(flushController.notifyAfterRemoveMessage).toHaveBeenCalledOnceWith(SMALL_MESSAGE_BYTES_COUNT)
-      expect(flushController.notifyBeforeAddMessage).toHaveBeenCalledOnceWith(SMALL_MESSAGE_BYTES_COUNT)
-      expect(flushController.bytesCount).toEqual(
-        // Note: contrary to added messages (see test above), we don't take separators into account
-        // when upserting messages, because it's irrelevant: upserted messages size are not yet
-        // encoded so the bytes count is only an estimation
-        SMALL_MESSAGE_BYTES_COUNT + SMALL_MESSAGE_BYTES_COUNT
-      )
-    })
-
-    it('should not send a message with a bytes size above the limit', () => {
-      const warnSpy = spyOn(display, 'warn')
-      batch.add(BIG_MESSAGE_OVER_BYTES_LIMIT)
-
-      expect(warnSpy).toHaveBeenCalled()
-      expect(flushController.notifyBeforeAddMessage).not.toHaveBeenCalled()
-    })
-
-    it('should adjust the message size after the message has been added', () => {
-      const message = { message: '😤' } // JS string length = 2, but 4 bytes once encoded to UTF-8
-      batch.add(message)
-      expect(flushController.notifyBeforeAddMessage).toHaveBeenCalledOnceWith(16)
-      expect(flushController.notifyAfterAddMessage).toHaveBeenCalledOnceWith(2) // 2 more bytes once encoded
-    })
-  })
-
-  it('should upsert a message for a given key', () => {
-    batch.upsert({ message: '1' }, 'a')
-    batch.upsert({ message: '2' }, 'a')
-    batch.upsert({ message: '3' }, 'b')
-    batch.upsert({ message: '4' }, 'c')
-    flushController.notifyFlush()
-
-    expect(transport.send.calls.mostRecent().args[0]).toEqual({
-      data: '{"message":"2"}\n{"message":"3"}\n{"message":"4"}',
-      bytesCount: jasmine.any(Number),
-      encoding: undefined,
-    })
-
-    batch.upsert({ message: '5' }, 'c')
-    batch.upsert({ message: '6' }, 'b')
-    batch.upsert({ message: '7' }, 'a')
-    flushController.notifyFlush()
-
-    expect(transport.send.calls.mostRecent().args[0]).toEqual({
-      data: '{"message":"5"}\n{"message":"6"}\n{"message":"7"}',
-      bytesCount: jasmine.any(Number),
-      encoding: undefined,
-    })
-
-    batch.upsert({ message: '8' }, 'a')
-    batch.upsert({ message: '9' }, 'b')
-    batch.upsert({ message: '10' }, 'a')
-    batch.upsert({ message: '11' }, 'b')
-    flushController.notifyFlush()
-
-    expect(transport.send.calls.mostRecent().args[0]).toEqual({
-      data: '{"message":"10"}\n{"message":"11"}',
-      bytesCount: jasmine.any(Number),
-      encoding: undefined,
-    })
-  })
-
-  describe('flush messages when the page is not exiting or with a synchronous encoder', () => {
-    it('should send addend and upserted messages in the same request', () => {
-      batch.add({ message: '1' })
-      batch.upsert({ message: '2' }, 'a')
-
-      flushController.notifyFlush()
-
-      expect(transport.send.calls.mostRecent().args[0]).toEqual({
-        data: '{"message":"1"}\n{"message":"2"}',
-        bytesCount: jasmine.any(Number),
-        encoding: undefined,
-      })
-    })
-
-    it('should encode upserted messages', () => {
-      const encoderWriteSpy = spyOn(encoder, 'write')
-
-      batch.upsert({ message: '2' }, 'a')
-
-      flushController.notifyFlush()
-
-      expect(encoderWriteSpy).toHaveBeenCalledOnceWith('{"message":"2"}')
-    })
-
-    it('should be able to use telemetry in the httpRequest.send', () => {
-      transport.send.and.callFake(() => {
-        addTelemetryDebugFake()
-      })
-      const addTelemetryDebugFake = () => batch.add({ message: 'telemetry message' })
-
-      batch.add({ message: 'normal message' })
-      expect(flushController.notifyBeforeAddMessage).toHaveBeenCalledTimes(1)
-
-      flushController.notifyFlush()
-      expect(transport.send).toHaveBeenCalledTimes(1)
-      expect(flushController.notifyBeforeAddMessage).toHaveBeenCalledTimes(2)
-
-      flushController.notifyFlush()
-      expect(transport.send).toHaveBeenCalledTimes(2)
-    })
-  })
-
-  describe('flush messages when the page is exiting and with an asynchronous encoder', () => {
-    beforeEach(() => {
-      encoder.isAsync = true
-    })
-
-    //
-    ;[
-      {
-        title: 'when adding a message, it should be sent in one request',
-        add: { message: 1 },
-        expectedRequests: ['{"message":1}'],
-      },
-      {
-        title: 'when upserting a message, it should be sent in one request',
-        upsert: { message: 1 },
-        expectedRequests: ['{"message":1}'],
-      },
-      {
-        title: 'when adding a message and upserting another, they should be sent in two separate requests',
-        add: { message: 1 },
-        upsert: { message: 2 },
-        expectedRequests: ['{"message":1}', '{"message":2}'],
-      },
-      {
-        title:
-          'when adding a message and another message is still pending, they should be sent in two separate requests',
-        add: { message: 1 },
-        pending: { message: 2 },
-        expectedRequests: ['{"message":1}', '{"message":2}'],
-      },
-      {
-        title: 'when upserting a message and another message is still pending, they should be sent in one request',
-        upsert: { message: 1 },
-        pending: { message: 2 },
-        expectedRequests: ['{"message":2}\n{"message":1}'],
-      },
-    ].forEach(({ title, add, upsert, pending, expectedRequests }) => {
-      it(title, () => {
-        if (add) {
-          batch.add(add)
-        }
-        if (upsert) {
-          batch.upsert(upsert, 'a')
-        }
-        if (pending) {
-          // eslint-disable-next-line @typescript-eslint/unbound-method
-          const original = encoder.finishSync
-          spyOn(encoder, 'finishSync').and.callFake(() => ({
-            ...original(),
-            pendingData: JSON.stringify(pending),
-          }))
-        }
-
-        flushController.notifyFlush('before_unload')
-
-        expect(transport.sendOnExit.calls.allArgs().map(([payload]) => payload.data)).toEqual(expectedRequests)
-      })
-    })
-
-    it('should be able to use telemetry in the httpRequest.sendOnExit', () => {
-      transport.sendOnExit.and.callFake(() => {
-        addTelemetryDebugFake()
-      })
-      const addTelemetryDebugFake = () => batch.add({ message: 'telemetry message' })
-
-      batch.add({ message: 'normal message' })
-      batch.upsert({ message: '2' }, 'a')
-      expect(flushController.notifyBeforeAddMessage).toHaveBeenCalledTimes(2)
-
-      flushController.notifyFlush('before_unload')
-      expect(transport.sendOnExit).toHaveBeenCalledTimes(2)
-      expect(flushController.notifyBeforeAddMessage).toHaveBeenCalledTimes(4)
-
-      flushController.notifyFlush('before_unload')
-      expect(transport.sendOnExit).toHaveBeenCalledTimes(3)
-    })
-  })
-})