@openobserve/browser-core 0.2.12-beta.9 → 0.3.0

package/src/browser/pageMayExitObservable.spec.ts

@@ -0,0 +1,56 @@
+import type { Configuration } from '../domain/configuration'
+import { createNewEvent, restorePageVisibility, setPageVisibility, registerCleanupTask } from '../../test'
+import type { PageMayExitEvent } from './pageMayExitObservable'
+import { PageExitReason, createPageMayExitObservable } from './pageMayExitObservable'
+
+describe('createPageMayExitObservable', () => {
+  let onExitSpy: jasmine.Spy<(event: PageMayExitEvent) => void>
+  let configuration: Configuration
+
+  beforeEach(() => {
+    onExitSpy = jasmine.createSpy()
+    configuration = {} as Configuration
+    registerCleanupTask(createPageMayExitObservable(configuration).subscribe(onExitSpy).unsubscribe)
+  })
+
+  afterEach(() => {
+    restorePageVisibility()
+  })
+
+  it('notifies when the page fires beforeunload', () => {
+    window.dispatchEvent(createNewEvent('beforeunload'))
+
+    expect(onExitSpy).toHaveBeenCalledOnceWith({ reason: PageExitReason.UNLOADING })
+  })
+
+  it('notifies when the page becomes hidden', () => {
+    emulatePageVisibilityChange('hidden')
+
+    expect(onExitSpy).toHaveBeenCalledOnceWith({ reason: PageExitReason.HIDDEN })
+  })
+
+  it('notifies when the page becomes frozen', () => {
+    window.dispatchEvent(createNewEvent('freeze'))
+
+    expect(onExitSpy).toHaveBeenCalledOnceWith({ reason: PageExitReason.FROZEN })
+  })
+
+  it('notifies multiple times', () => {
+    window.dispatchEvent(createNewEvent('beforeunload'))
+    window.dispatchEvent(createNewEvent('beforeunload'))
+    emulatePageVisibilityChange('hidden')
+
+    expect(onExitSpy).toHaveBeenCalledTimes(3)
+  })
+
+  it('does not notify when the page becomes visible', () => {
+    emulatePageVisibilityChange('visible')
+
+    expect(onExitSpy).not.toHaveBeenCalled()
+  })
+
+  function emulatePageVisibilityChange(visibility: 'visible' | 'hidden') {
+    setPageVisibility(visibility)
+    document.dispatchEvent(createNewEvent('visibilitychange'))
+  }
+})

package/src/browser/xhrObservable.spec.ts

@@ -0,0 +1,405 @@
+import type { Configuration } from '../domain/configuration'
+import { withXhr, mockXhr } from '../../test'
+import type { Subscription } from '../tools/observable'
+import type { XhrCompleteContext, XhrContext } from './xhrObservable'
+import { initXhrObservable } from './xhrObservable'
+
+describe('xhr observable', () => {
+  let requestsTrackingSubscription: Subscription
+  let contextEditionSubscription: Subscription | undefined
+  let requests: XhrCompleteContext[]
+  let originalMockXhrSend: XMLHttpRequest['send']
+  let configuration: Configuration
+
+  beforeEach(() => {
+    mockXhr()
+    configuration = {} as Configuration
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    originalMockXhrSend = XMLHttpRequest.prototype.send
+
+    requests = []
+    startTrackingRequests()
+  })
+
+  afterEach(() => {
+    requestsTrackingSubscription.unsubscribe()
+    contextEditionSubscription?.unsubscribe()
+  })
+
+  function startTrackingRequests() {
+    requestsTrackingSubscription = initXhrObservable(configuration).subscribe((context) => {
+      if (context.state === 'complete') {
+        requests.push(context)
+      }
+    })
+  }
+
+  it('should track successful request', (done) => {
+    withXhr({
+      setup(xhr) {
+        xhr.open('GET', '/ok')
+        xhr.send()
+        xhr.complete(200, 'ok')
+      },
+      onComplete() {
+        const request = requests[0]
+        expect(request.method).toBe('GET')
+        expect(request.url).toContain('/ok')
+        expect(request.status).toBe(200)
+        expect(request.isAborted).toBe(false)
+        expect(request.duration).toEqual(jasmine.any(Number))
+        expect(request.handlingStack).toBeDefined()
+        done()
+      },
+    })
+  })
+
+  it('should sanitize request method', (done) => {
+    withXhr({
+      setup(xhr) {
+        xhr.open('get', '/ok')
+        xhr.send()
+        xhr.complete(200, 'ok')
+      },
+      onComplete() {
+        const request = requests[0]
+        expect(request.method).toBe('GET')
+        expect(request.handlingStack).toBeDefined()
+        done()
+      },
+    })
+  })
+
+  it('should track client error', (done) => {
+    withXhr({
+      setup(xhr) {
+        xhr.open('GET', '/expected-404')
+        xhr.send()
+        xhr.complete(404, 'NOT FOUND')
+      },
+      onComplete() {
+        const request = requests[0]
+        expect(request.method).toBe('GET')
+        expect(request.url).toContain('/expected-404')
+        expect(request.status).toBe(404)
+        expect(request.isAborted).toBe(false)
+        expect(request.duration).toEqual(jasmine.any(Number))
+        expect(request.handlingStack).toBeDefined()
+        done()
+      },
+    })
+  })
+
+  it('should track server error', (done) => {
+    withXhr({
+      setup(xhr) {
+        xhr.open('GET', '/throw')
+        xhr.send()
+        xhr.complete(500, 'expected server error')
+      },
+      onComplete() {
+        const request = requests[0]
+        expect(request.method).toBe('GET')
+        expect(request.url).toContain('/throw')
+        expect(request.status).toBe(500)
+        expect(request.isAborted).toBe(false)
+        expect(request.duration).toEqual(jasmine.any(Number))
+        expect(request.handlingStack).toBeDefined()
+        done()
+      },
+    })
+  })
+
+  it('should track network error', (done) => {
+    withXhr({
+      setup(xhr) {
+        xhr.open('GET', 'http://foo.bar/qux')
+        xhr.send()
+        xhr.complete(0, '')
+      },
+      onComplete() {
+        const request = requests[0]
+        expect(request.method).toBe('GET')
+        expect(request.url).toBe('http://foo.bar/qux')
+        expect(request.status).toBe(0)
+        expect(request.isAborted).toBe(false)
+        expect(request.duration).toEqual(jasmine.any(Number))
+        expect(request.handlingStack).toBeDefined()
+        done()
+      },
+    })
+  })
+
+  it('should track successful request aborted', (done) => {
+    withXhr({
+      setup(xhr) {
+        xhr.onreadystatechange = () => {
+          if (xhr.readyState === XMLHttpRequest.DONE) {
+            xhr.abort()
+          }
+        }
+        spyOn(xhr, 'onreadystatechange').and.callThrough()
+        xhr.open('GET', '/ok')
+        xhr.send()
+        xhr.complete(200, 'ok')
+      },
+      onComplete(xhr) {
+        const request = requests[0]
+        expect(requests.length).toBe(1)
+        expect(request.method).toBe('GET')
+        expect(request.url).toContain('/ok')
+        expect(request.status).toBe(200)
+        expect(request.duration).toEqual(jasmine.any(Number))
+        expect(request.isAborted).toBe(false)
+        expect(xhr.status).toBe(0)
+        expect(xhr.onreadystatechange).toHaveBeenCalledTimes(1)
+        expect(request.handlingStack).toBeDefined()
+        done()
+      },
+    })
+  })
+
+  it('should track aborted requests', (done) => {
+    withXhr({
+      setup(xhr) {
+        xhr.open('GET', '/ok')
+        xhr.send()
+        xhr.abort()
+      },
+      onComplete(xhr) {
+        const request = requests[0]
+        expect(request.method).toBe('GET')
+        expect(request.url).toContain('/ok')
+        expect(request.status).toBe(0)
+        expect(request.duration).toEqual(jasmine.any(Number))
+        expect(request.isAborted).toBe(true)
+        expect(xhr.status).toBe(0)
+        expect(request.handlingStack).toBeDefined()
+        done()
+      },
+    })
+  })
+
+  it('should track request with onreadystatechange overridden before open', (done) => {
+    withXhr({
+      setup(xhr) {
+        xhr.onreadystatechange = jasmine.createSpy()
+        xhr.open('GET', '/ok')
+        xhr.send()
+        xhr.complete(200, 'ok')
+      },
+      onComplete(xhr) {
+        const request = requests[0]
+        expect(request.method).toBe('GET')
+        expect(request.url).toContain('/ok')
+        expect(request.status).toBe(200)
+        expect(request.isAborted).toBe(false)
+        expect(request.duration).toEqual(jasmine.any(Number))
+        expect(xhr.onreadystatechange).toHaveBeenCalled()
+        expect(request.handlingStack).toBeDefined()
+        done()
+      },
+    })
+  })
+
+  it('should track request with onreadystatechange overridden after open', (done) => {
+    withXhr({
+      setup(xhr) {
+        xhr.open('GET', '/ok')
+        xhr.send()
+        xhr.onreadystatechange = jasmine.createSpy()
+        xhr.complete(200, 'ok')
+      },
+      onComplete(xhr) {
+        const request = requests[0]
+        expect(request.method).toBe('GET')
+        expect(request.url).toContain('/ok')
+        expect(request.status).toBe(200)
+        expect(request.isAborted).toBe(false)
+        expect(request.duration).toEqual(jasmine.any(Number))
+        expect(xhr.onreadystatechange).toHaveBeenCalled()
+        expect(request.handlingStack).toBeDefined()
+        done()
+      },
+    })
+  })
+
+  it('should allow to enhance the context', (done) => {
+    type CustomContext = XhrContext & { foo: string }
+    contextEditionSubscription = initXhrObservable(configuration).subscribe((rawContext) => {
+      const context = rawContext as CustomContext
+      if (context.state === 'start') {
+        context.foo = 'bar'
+      }
+    })
+    withXhr({
+      setup(xhr) {
+        xhr.open('GET', '/ok')
+        xhr.send()
+        xhr.complete(200)
+      },
+      onComplete() {
+        const request = requests[0]
+        expect((request as CustomContext).foo).toBe('bar')
+        done()
+      },
+    })
+  })
+
+  it('should not break xhr opened before the instrumentation', (done) => {
+    requestsTrackingSubscription.unsubscribe()
+    withXhr({
+      setup(xhr) {
+        xhr.open('GET', '/ok')
+        startTrackingRequests()
+        xhr.send()
+        xhr.complete(200)
+      },
+      onComplete() {
+        expect(requests.length).toBe(0)
+        done()
+      },
+    })
+  })
+
+  it('should track multiple requests with the same xhr instance', (done) => {
+    let listeners: { [k: string]: Array<(event: Event) => void> }
+    withXhr({
+      setup(xhr) {
+        const secondOnload = () => {
+          xhr.removeEventListener('load', secondOnload)
+        }
+        const onLoad = () => {
+          xhr.removeEventListener('load', onLoad)
+          xhr.addEventListener('load', secondOnload)
+          xhr.open('GET', '/ok?request=2')
+          xhr.send()
+          xhr.complete(400, 'ok')
+        }
+        xhr.onreadystatechange = jasmine.createSpy()
+        xhr.addEventListener('load', onLoad)
+        xhr.open('GET', '/ok?request=1')
+        xhr.send()
+        xhr.complete(200, 'ok')
+        listeners = xhr.listeners
+      },
+      onComplete(xhr) {
+        const firstRequest = requests[0]
+        expect(firstRequest.method).toBe('GET')
+        expect(firstRequest.url).toContain('/ok?request=1')
+        expect(firstRequest.status).toBe(200)
+        expect(firstRequest.isAborted).toBe(false)
+        expect(firstRequest.duration).toEqual(jasmine.any(Number))
+        expect(firstRequest.handlingStack).toBeDefined()
+
+        const secondRequest = requests[1]
+        expect(secondRequest.method).toBe('GET')
+        expect(secondRequest.url).toContain('/ok?request=2')
+        expect(secondRequest.status).toBe(400)
+        expect(secondRequest.isAborted).toBe(false)
+        expect(secondRequest.duration).toEqual(jasmine.any(Number))
+        expect(secondRequest.handlingStack).toBeDefined()
+
+        expect(xhr.onreadystatechange).toHaveBeenCalledTimes(2)
+        expect(listeners.load.length).toBe(0)
+        expect(listeners.loadend.length).toBe(0)
+        done()
+      },
+    })
+  })
+
+  it('should track request to undefined url', (done) => {
+    withXhr({
+      setup(xhr) {
+        xhr.open('GET', undefined)
+        xhr.send()
+        xhr.complete(404, 'NOT FOUND')
+      },
+      onComplete() {
+        const request = requests[0]
+        expect(request.method).toBe('GET')
+        expect(request.url).toContain('/undefined')
+        expect(request.status).toBe(404)
+        done()
+      },
+    })
+  })
+
+  it('should track request to null url', (done) => {
+    withXhr({
+      setup(xhr) {
+        xhr.open('GET', null)
+        xhr.send()
+        xhr.complete(404, 'NOT FOUND')
+      },
+      onComplete() {
+        const request = requests[0]
+        expect(request.method).toBe('GET')
+        expect(request.url).toContain('/null')
+        expect(request.status).toBe(404)
+        done()
+      },
+    })
+  })
+
+  it('should track request to URL object', (done) => {
+    withXhr({
+      setup(xhr) {
+        xhr.open('GET', new URL('http://example.com/path'))
+        xhr.send()
+        xhr.complete(200, 'ok')
+      },
+      onComplete() {
+        const request = requests[0]
+        expect(request.method).toBe('GET')
+        expect(request.url).toBe('http://example.com/path')
+        done()
+      },
+    })
+  })
+
+  describe('when unsubscribing', () => {
+    it('should stop tracking requests', (done) => {
+      requestsTrackingSubscription.unsubscribe()
+
+      withXhr({
+        setup(xhr) {
+          xhr.open('GET', '/ok')
+          xhr.send()
+          xhr.complete(200)
+        },
+        onComplete() {
+          expect(requests.length).toBe(0)
+          done()
+        },
+      })
+    })
+
+    it('should restore original XMLHttpRequest methods', () => {
+      requestsTrackingSubscription.unsubscribe()
+
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      expect(XMLHttpRequest.prototype.send).toBe(originalMockXhrSend)
+    })
+  })
+
+  it('should track request with undefined or null methods', (done) => {
+    withXhr({
+      setup(xhr) {
+        xhr.open(null, '/ok')
+        xhr.send()
+        xhr.onreadystatechange = jasmine.createSpy()
+        xhr.complete(200, 'ok')
+        xhr.open(undefined, '/ok')
+        xhr.send()
+        xhr.onreadystatechange = jasmine.createSpy()
+        xhr.complete(200, 'ok')
+      },
+      onComplete() {
+        expect(requests[0].method).toBe('NULL')
+        expect(requests[1].method).toBe('UNDEFINED')
+        done()
+      },
+    })
+  })
+})

package/src/domain/allowedTrackingOrigins.spec.ts

@@ -0,0 +1,210 @@
+import { STACK_WITH_INIT_IN_EXTENSION, STACK_WITH_INIT_IN_PAGE } from '../../test'
+import { display } from '../tools/display'
+import {
+  isAllowedTrackingOrigins,
+  ERROR_NOT_ALLOWED_TRACKING_ORIGIN,
+  ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN,
+} from './allowedTrackingOrigins'
+
+const DEFAULT_CONFIG = {
+  applicationId: 'xxx',
+  clientToken: 'xxx',
+  allowedTrackingOrigins: undefined as any,
+}
+
+describe('checkForAllowedTrackingOrigins', () => {
+  let displayErrorSpy: jasmine.Spy
+
+  beforeEach(() => {
+    displayErrorSpy = spyOn(display, 'error')
+  })
+
+  it('should not warn if not in extension environment', () => {
+    const result = isAllowedTrackingOrigins(DEFAULT_CONFIG, STACK_WITH_INIT_IN_PAGE, 'https://app.example.com')
+    expect(displayErrorSpy).not.toHaveBeenCalled()
+    expect(result).toBe(true)
+  })
+
+  describe('when configuration has allowedTrackingOrigins and origin is allowed', () => {
+    it('should not warn if origin matches exactly', () => {
+      const result = isAllowedTrackingOrigins(
+        {
+          ...DEFAULT_CONFIG,
+          allowedTrackingOrigins: ['https://app.example.com'],
+        },
+        STACK_WITH_INIT_IN_PAGE,
+        'https://app.example.com'
+      )
+      expect(displayErrorSpy).not.toHaveBeenCalled()
+      expect(result).toBe(true)
+    })
+
+    it('should not warn if origin matches regex pattern', () => {
+      const result = isAllowedTrackingOrigins(
+        {
+          ...DEFAULT_CONFIG,
+          allowedTrackingOrigins: [/^https:\/\/.*\.example\.com$/],
+        },
+        STACK_WITH_INIT_IN_PAGE,
+        'https://app.example.com'
+      )
+      expect(displayErrorSpy).not.toHaveBeenCalled()
+      expect(result).toBe(true)
+    })
+
+    it('should not warn if origin matches predicate function', () => {
+      const result = isAllowedTrackingOrigins(
+        {
+          ...DEFAULT_CONFIG,
+          allowedTrackingOrigins: [(origin: string) => origin.includes('example.com')],
+        },
+        STACK_WITH_INIT_IN_PAGE,
+        'https://app.example.com'
+      )
+      expect(displayErrorSpy).not.toHaveBeenCalled()
+      expect(result).toBe(true)
+    })
+
+    it('should handle multiple patterns', () => {
+      const result = isAllowedTrackingOrigins(
+        {
+          ...DEFAULT_CONFIG,
+          allowedTrackingOrigins: [
+            'https://exact-match.com',
+            /^https:\/\/.*\.example\.com$/,
+            (origin: string) => origin.startsWith('https://app.'),
+          ],
+        },
+        STACK_WITH_INIT_IN_PAGE,
+        'https://app.example.com'
+      )
+      expect(displayErrorSpy).not.toHaveBeenCalled()
+      expect(result).toBe(true)
+    })
+  })
+
+  describe('when configuration has allowedTrackingOrigins but origin is not allowed in extension context', () => {
+    it('should error when origin does not match any allowed pattern', () => {
+      const result = isAllowedTrackingOrigins(
+        {
+          ...DEFAULT_CONFIG,
+          allowedTrackingOrigins: ['https://different.com'],
+        },
+        STACK_WITH_INIT_IN_EXTENSION,
+        'https://example.com'
+      )
+      expect(displayErrorSpy).toHaveBeenCalledWith(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)
+      expect(result).toBe(false)
+    })
+
+    it('should error when origin does not match regex pattern', () => {
+      const result = isAllowedTrackingOrigins(
+        {
+          ...DEFAULT_CONFIG,
+          allowedTrackingOrigins: [/^https:\/\/specific-[a-z]+\.com$/],
+        },
+        STACK_WITH_INIT_IN_EXTENSION,
+        'https://example.com'
+      )
+      expect(displayErrorSpy).toHaveBeenCalledWith(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)
+      expect(result).toBe(false)
+    })
+
+    it('should error when origin does not match predicate function', () => {
+      const result = isAllowedTrackingOrigins(
+        {
+          ...DEFAULT_CONFIG,
+          allowedTrackingOrigins: [(origin: string) => origin.includes('specific-id')],
+        },
+        STACK_WITH_INIT_IN_EXTENSION,
+        'https://example.com'
+      )
+      expect(displayErrorSpy).toHaveBeenCalledWith(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)
+      expect(result).toBe(false)
+    })
+
+    it('should error when origin does not match any of multiple patterns', () => {
+      const result = isAllowedTrackingOrigins(
+        {
+          ...DEFAULT_CONFIG,
+          allowedTrackingOrigins: [
+            'https://specific.com',
+            /^https:\/\/.*\.specific\.com$/,
+            (origin: string) => origin.includes('specific-id'),
+          ],
+        },
+        STACK_WITH_INIT_IN_EXTENSION,
+        'https://example.com'
+      )
+      expect(displayErrorSpy).toHaveBeenCalledWith(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)
+      expect(result).toBe(false)
+    })
+
+    it('should error when origin is a partial match', () => {
+      const result = isAllowedTrackingOrigins(
+        {
+          ...DEFAULT_CONFIG,
+          allowedTrackingOrigins: ['https://example.com'],
+        },
+        STACK_WITH_INIT_IN_EXTENSION,
+        'https://example.com.extra.com'
+      )
+      expect(displayErrorSpy).toHaveBeenCalledWith(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)
+      expect(result).toBe(false)
+    })
+
+    it('should not error when in extension and origin matches', () => {
+      const result = isAllowedTrackingOrigins(
+        {
+          ...DEFAULT_CONFIG,
+          allowedTrackingOrigins: [/^chrome-extension:\/\//],
+        },
+        STACK_WITH_INIT_IN_EXTENSION,
+        'chrome-extension://abcdefghijklmno'
+      )
+      expect(displayErrorSpy).not.toHaveBeenCalled()
+      expect(result).toBe(true)
+    })
+  })
+
+  describe('when configuration does not have allowedTrackingOrigins', () => {
+    it('should log an error when in extension environment and allowedTrackingOrigins is undefined', () => {
+      const result = isAllowedTrackingOrigins(
+        {
+          ...DEFAULT_CONFIG,
+          allowedTrackingOrigins: undefined,
+        },
+        STACK_WITH_INIT_IN_EXTENSION,
+        'https://example.com'
+      )
+      expect(displayErrorSpy).toHaveBeenCalledWith(ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN)
+      expect(result).toBe(false)
+    })
+
+    it('should error when in extension environment and allowedTrackingOrigins is an empty array', () => {
+      const result = isAllowedTrackingOrigins(
+        {
+          ...DEFAULT_CONFIG,
+          allowedTrackingOrigins: [],
+        },
+        STACK_WITH_INIT_IN_EXTENSION,
+        'https://example.com'
+      )
+      expect(displayErrorSpy).toHaveBeenCalledWith(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)
+      expect(result).toBe(false)
+    })
+
+    it('should not warn when not in extension environment and allowedTrackingOrigins is undefined', () => {
+      const result = isAllowedTrackingOrigins(
+        {
+          ...DEFAULT_CONFIG,
+          allowedTrackingOrigins: undefined,
+        },
+        STACK_WITH_INIT_IN_PAGE,
+        'https://example.com'
+      )
+      expect(displayErrorSpy).not.toHaveBeenCalled()
+      expect(result).toBe(true)
+    })
+  })
+})

package/src/domain/bufferedData.spec.ts

@@ -0,0 +1,34 @@
+import { registerCleanupTask } from '../../test'
+import { Observable } from '../tools/observable'
+import { clocksNow } from '../tools/utils/timeUtils'
+import { BufferedDataType, startBufferingData } from './bufferedData'
+import { ErrorHandling, ErrorSource, type RawError } from './error/error.types'
+
+describe('startBufferingData', () => {
+  it('collects runtime errors', (done) => {
+    const runtimeErrorObservable = new Observable<RawError>()
+    const { observable, stop } = startBufferingData(() => runtimeErrorObservable)
+    registerCleanupTask(stop)
+
+    const rawError = {
+      startClocks: clocksNow(),
+      source: ErrorSource.SOURCE,
+      type: 'Error',
+      stack: 'Error: error!',
+      handling: ErrorHandling.UNHANDLED,
+      causes: undefined,
+      fingerprint: undefined,
+      message: 'error!',
+    }
+
+    runtimeErrorObservable.notify(rawError)
+
+    observable.subscribe((data) => {
+      expect(data).toEqual({
+        type: BufferedDataType.RUNTIME_ERROR,
+        error: rawError,
+      })
+      done()
+    })
+  })
+})