server/lib/opentelemetry/metric-helpers/stats-observers-builder.ts

   1 import memoizee from 'memoizee'
   2 import { Meter } from '@opentelemetry/api-metrics'
   3 import { MEMOIZE_TTL } from '@server/initializers/constants'
   4 import { buildAvailableActivities } from '@server/lib/activitypub/activity'
   5 import { StatsManager } from '@server/lib/stat-manager'
   6
   7 export class StatsObserverBuilder {
   8
   9   private readonly getInstanceStats = memoizee(() => {
  10     return StatsManager.Instance.getStats()
  11   }, { maxAge: MEMOIZE_TTL.GET_STATS_FOR_OPEN_TELEMETRY_METRICS })
  12
  13   constructor (private readonly meter: Meter) {
  14
  15   }
  16
  17   buildObservers () {
  18     this.buildUserStatsObserver()
  19     this.buildVideoStatsObserver()
  20     this.buildCommentStatsObserver()
  21     this.buildPlaylistStatsObserver()
  22     this.buildChannelStatsObserver()
  23     this.buildInstanceFollowsStatsObserver()
  24     this.buildRedundancyStatsObserver()
  25     this.buildActivityPubStatsObserver()
  26   }
  27
  28   private buildUserStatsObserver () {
  29     this.meter.createObservableGauge('peertube_users_total', {
  30       description: 'Total users on the instance'
  31     }).addCallback(async observableResult => {
  32       const stats = await this.getInstanceStats()
  33
  34       observableResult.observe(stats.totalUsers)
  35     })
  36
  37     this.meter.createObservableGauge('peertube_active_users_total', {
  38       description: 'Total active users on the instance'
  39     }).addCallback(async observableResult => {
  40       const stats = await this.getInstanceStats()
  41
  42       observableResult.observe(stats.totalDailyActiveUsers, { activeInterval: 'daily' })
  43       observableResult.observe(stats.totalWeeklyActiveUsers, { activeInterval: 'weekly' })
  44       observableResult.observe(stats.totalMonthlyActiveUsers, { activeInterval: 'monthly' })
  45     })
  46   }
  47
  48   private buildChannelStatsObserver () {
  49     this.meter.createObservableGauge('peertube_channels_total', {
  50       description: 'Total channels on the instance'
  51     }).addCallback(async observableResult => {
  52       const stats = await this.getInstanceStats()
  53
  54       observableResult.observe(stats.totalLocalVideoChannels, { channelOrigin: 'local' })
  55     })
  56
  57     this.meter.createObservableGauge('peertube_active_channels_total', {
  58       description: 'Total active channels on the instance'
  59     }).addCallback(async observableResult => {
  60       const stats = await this.getInstanceStats()
  61
  62       observableResult.observe(stats.totalLocalDailyActiveVideoChannels, { channelOrigin: 'local', activeInterval: 'daily' })
  63       observableResult.observe(stats.totalLocalWeeklyActiveVideoChannels, { channelOrigin: 'local', activeInterval: 'weekly' })
  64       observableResult.observe(stats.totalLocalMonthlyActiveVideoChannels, { channelOrigin: 'local', activeInterval: 'monthly' })
  65     })
  66   }
  67
  68   private buildVideoStatsObserver () {
  69     this.meter.createObservableGauge('peertube_videos_total', {
  70       description: 'Total videos on the instance'
  71     }).addCallback(async observableResult => {
  72       const stats = await this.getInstanceStats()
  73
  74       observableResult.observe(stats.totalLocalVideos, { videoOrigin: 'local' })
  75       observableResult.observe(stats.totalVideos - stats.totalLocalVideos, { videoOrigin: 'remote' })
  76     })
  77
  78     this.meter.createObservableGauge('peertube_video_views_total', {
  79       description: 'Total video views made on the instance'
  80     }).addCallback(async observableResult => {
  81       const stats = await this.getInstanceStats()
  82
  83       observableResult.observe(stats.totalLocalVideoViews, { viewOrigin: 'local' })
  84     })
  85
  86     this.meter.createObservableGauge('peertube_video_bytes_total', {
  87       description: 'Total bytes of videos'
  88     }).addCallback(async observableResult => {
  89       const stats = await this.getInstanceStats()
  90
  91       observableResult.observe(stats.totalLocalVideoFilesSize, { videoOrigin: 'local' })
  92     })
  93   }
  94
  95   private buildCommentStatsObserver () {
  96     this.meter.createObservableGauge('peertube_comments_total', {
  97       description: 'Total comments on the instance'
  98     }).addCallback(async observableResult => {
  99       const stats = await this.getInstanceStats()
 100
 101       observableResult.observe(stats.totalLocalVideoComments, { accountOrigin: 'local' })
 102     })
 103   }
 104
 105   private buildPlaylistStatsObserver () {
 106     this.meter.createObservableGauge('peertube_playlists_total', {
 107       description: 'Total playlists on the instance'
 108     }).addCallback(async observableResult => {
 109       const stats = await this.getInstanceStats()
 110
 111       observableResult.observe(stats.totalLocalPlaylists, { playlistOrigin: 'local' })
 112     })
 113   }
 114
 115   private buildInstanceFollowsStatsObserver () {
 116     this.meter.createObservableGauge('peertube_instance_followers_total', {
 117       description: 'Total followers of the instance'
 118     }).addCallback(async observableResult => {
 119       const stats = await this.getInstanceStats()
 120
 121       observableResult.observe(stats.totalInstanceFollowers)
 122     })
 123
 124     this.meter.createObservableGauge('peertube_instance_following_total', {
 125       description: 'Total following of the instance'
 126     }).addCallback(async observableResult => {
 127       const stats = await this.getInstanceStats()
 128
 129       observableResult.observe(stats.totalInstanceFollowing)
 130     })
 131   }
 132
 133   private buildRedundancyStatsObserver () {
 134     this.meter.createObservableGauge('peertube_redundancy_used_bytes_total', {
 135       description: 'Total redundancy used of the instance'
 136     }).addCallback(async observableResult => {
 137       const stats = await this.getInstanceStats()
 138
 139       for (const r of stats.videosRedundancy) {
 140         observableResult.observe(r.totalUsed, { strategy: r.strategy })
 141       }
 142     })
 143
 144     this.meter.createObservableGauge('peertube_redundancy_available_bytes_total', {
 145       description: 'Total redundancy available of the instance'
 146     }).addCallback(async observableResult => {
 147       const stats = await this.getInstanceStats()
 148
 149       for (const r of stats.videosRedundancy) {
 150         observableResult.observe(r.totalSize, { strategy: r.strategy })
 151       }
 152     })
 153   }
 154
 155   private buildActivityPubStatsObserver () {
 156     const availableActivities = buildAvailableActivities()
 157
 158     this.meter.createObservableGauge('peertube_ap_inbox_success_total', {
 159       description: 'Total inbox messages processed with success'
 160     }).addCallback(async observableResult => {
 161       const stats = await this.getInstanceStats()
 162
 163       for (const type of availableActivities) {
 164         observableResult.observe(stats[`totalActivityPub${type}MessagesSuccesses`], { activityType: type })
 165       }
 166     })
 167
 168     this.meter.createObservableGauge('peertube_ap_inbox_error_total', {
 169       description: 'Total inbox messages processed with error'
 170     }).addCallback(async observableResult => {
 171       const stats = await this.getInstanceStats()
 172
 173       for (const type of availableActivities) {
 174         observableResult.observe(stats[`totalActivityPub${type}MessagesErrors`], { activityType: type })
 175       }
 176     })
 177
 178     this.meter.createObservableGauge('peertube_ap_inbox_waiting_total', {
 179       description: 'Total inbox messages waiting for being processed'
 180     }).addCallback(async observableResult => {
 181       const stats = await this.getInstanceStats()
 182
 183       observableResult.observe(stats.totalActivityPubMessagesWaiting)
 184     })
 185   }
 186 }