server/tests/api/server/open-telemetry.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import { expect } from 'chai'
   4 import { expectLogContain, expectLogDoesNotContain, MockHTTP } from '@server/tests/shared'
   5 import { HttpStatusCode, VideoPrivacy, VideoResolution } from '@shared/models'
   6 import { cleanupTests, createSingleServer, makeRawRequest, PeerTubeServer, setAccessTokensToServers } from '@shared/server-commands'
   7
   8 describe('Open Telemetry', function () {
   9   let server: PeerTubeServer
  10
  11   describe('Metrics', function () {
  12     const metricsUrl = 'http://localhost:9092/metrics'
  13
  14     it('Should not enable open telemetry metrics', async function () {
  15       server = await createSingleServer(1)
  16
  17       let hasError = false
  18       try {
  19         await makeRawRequest(metricsUrl, HttpStatusCode.NOT_FOUND_404)
  20       } catch (err) {
  21         hasError = err.message.includes('ECONNREFUSED')
  22       }
  23
  24       expect(hasError).to.be.true
  25
  26       await server.kill()
  27     })
  28
  29     it('Should enable open telemetry metrics', async function () {
  30       server = await createSingleServer(1, {
  31         open_telemetry: {
  32           metrics: {
  33             enabled: true
  34           }
  35         }
  36       })
  37
  38       const res = await makeRawRequest(metricsUrl, HttpStatusCode.OK_200)
  39       expect(res.text).to.contain('peertube_job_queue_total{')
  40     })
  41
  42     it('Should have playback metrics', async function () {
  43       await setAccessTokensToServers([ server ])
  44
  45       const video = await server.videos.quickUpload({ name: 'video' })
  46
  47       await server.metrics.addPlaybackMetric({
  48         metrics: {
  49           playerMode: 'p2p-media-loader',
  50           resolution: VideoResolution.H_1080P,
  51           fps: 30,
  52           resolutionChanges: 1,
  53           errors: 2,
  54           downloadedBytesP2P: 0,
  55           downloadedBytesHTTP: 0,
  56           uploadedBytesP2P: 5,
  57           videoId: video.uuid
  58         }
  59       })
  60
  61       const res = await makeRawRequest(metricsUrl, HttpStatusCode.OK_200)
  62       expect(res.text).to.contain('peertube_playback_http_uploaded_bytes_total{')
  63     })
  64
  65     after(async function () {
  66       await server.kill()
  67     })
  68   })
  69
  70   describe('Tracing', function () {
  71     let mockHTTP: MockHTTP
  72     let mockPort: number
  73
  74     before(async function () {
  75       mockHTTP = new MockHTTP()
  76       mockPort = await mockHTTP.initialize()
  77     })
  78
  79     it('Should enable open telemetry tracing', async function () {
  80       server = await createSingleServer(1)
  81
  82       await expectLogDoesNotContain(server, 'Registering Open Telemetry tracing')
  83
  84       await server.kill()
  85     })
  86
  87     it('Should enable open telemetry metrics', async function () {
  88       server = await createSingleServer(1, {
  89         open_telemetry: {
  90           tracing: {
  91             enabled: true,
  92             jaeger_exporter: {
  93               endpoint: 'http://localhost:' + mockPort
  94             }
  95           }
  96         }
  97       })
  98
  99       await expectLogContain(server, 'Registering Open Telemetry tracing')
 100     })
 101
 102     it('Should upload a video and correctly works', async function () {
 103       await setAccessTokensToServers([ server ])
 104
 105       const { uuid } = await server.videos.quickUpload({ name: 'video', privacy: VideoPrivacy.PUBLIC })
 106
 107       const video = await server.videos.get({ id: uuid })
 108
 109       expect(video.name).to.equal('video')
 110     })
 111
 112     after(async function () {
 113       await mockHTTP.terminate()
 114     })
 115   })
 116
 117   after(async function () {
 118     await cleanupTests([ server ])
 119   })
 120 })