From b81bac0ec3772efd96dce9eb13e02362d4515f5a Mon Sep 17 00:00:00 2001 From: Raja Subramanian Date: Mon, 16 Feb 2026 13:56:13 +0530 Subject: [PATCH] Key telemetry stats worker using combination of roomID, participantID (#4323) * Key telemetry stats work using combination of roomID, participantID With forwarded participant, the same participantID can existing in two rooms. NOTE: This does not yet allow a participant session to report its events/track stats into multiple rooms. That would require regitering multiple listeners (from rooms a participant is forwarded to). * missed file * data channel stats * PR comments + pass in room name so that telemetry events have proper room name also --- pkg/rtc/mediatrack.go | 10 +- pkg/rtc/mediatrackreceiver.go | 24 +- pkg/rtc/mediatracksubscriptions.go | 5 +- pkg/rtc/participant.go | 33 +- pkg/rtc/participant_internal_test.go | 3 +- pkg/rtc/room.go | 77 ++- pkg/{telemetry => rtc}/signalanddatastats.go | 60 +- pkg/rtc/subscribedtrack.go | 4 +- pkg/rtc/subscriptionmanager.go | 32 +- pkg/rtc/subscriptionmanager_test.go | 35 +- pkg/rtc/transportmanager.go | 3 +- pkg/rtc/types/interfaces.go | 55 ++ .../fake_participant_telemetry_listener.go | 620 ++++++++++++++++++ pkg/service/roommanager.go | 2 +- pkg/service/rtcservice.go | 2 +- pkg/telemetry/events.go | 80 ++- pkg/telemetry/events_test.go | 6 +- pkg/telemetry/stats.go | 4 +- pkg/telemetry/stats_test.go | 64 +- .../telemetryfakes/fake_telemetry_service.go | 460 +++++++------ pkg/telemetry/telemetryservice.go | 91 +-- 21 files changed, 1256 insertions(+), 414 deletions(-) rename pkg/{telemetry => rtc}/signalanddatastats.go (80%) create mode 100644 pkg/rtc/types/typesfakes/fake_participant_telemetry_listener.go diff --git a/pkg/rtc/mediatrack.go b/pkg/rtc/mediatrack.go index 7c43edc2d..886b84506 100644 --- a/pkg/rtc/mediatrack.go +++ b/pkg/rtc/mediatrack.go @@ -15,7 +15,6 @@ package rtc import ( - "context" "math" "sync" "time" @@ -86,7 +85,7 @@ type MediaTrackParams struct { PLIThrottleConfig sfu.PLIThrottleConfig AudioConfig sfu.AudioConfig VideoConfig config.VideoConfig - Telemetry telemetry.TelemetryService + TelemetryListener types.ParticipantTelemetryListener Logger logger.Logger Reporter roomobs.TrackReporter SimTracks map[uint32]interceptor.SimulcastTrackInfo @@ -124,7 +123,7 @@ func NewMediaTrack(params MediaTrackParams, ti *livekit.TrackInfo) *MediaTrack { ReceiverConfig: params.ReceiverConfig, SubscriberConfig: params.SubscriberConfig, AudioConfig: params.AudioConfig, - Telemetry: params.Telemetry, + TelemetryListener: params.TelemetryListener, Logger: params.Logger, RegressionTargetCodec: t.regressionTargetCodec, PreferVideoSizeFromMedia: params.PreferVideoSizeFromMedia, @@ -445,7 +444,7 @@ func (t *MediaTrack) AddReceiver(receiver *webrtc.RTPReceiver, track sfu.TrackRe regressionTargetCodecReceived := t.regressionTargetCodecReceived t.lock.RUnlock() if priority == 0 || regressionTargetCodecReceived { - t.params.Telemetry.TrackStats(statsKey, stat) + t.params.TelemetryListener.OnTrackStats(statsKey, stat) if cs, ok := telemetry.CondenseStat(stat); ok { t.params.Reporter.Tx(func(tx roomobs.TrackTx) { @@ -587,8 +586,7 @@ func (t *MediaTrack) AddReceiver(receiver *webrtc.RTPReceiver, track sfu.TrackRe }) buff.OnFinalRtpStats(func(stats *livekit.RTPStats) { - t.params.Telemetry.TrackPublishRTPStats( - context.Background(), + t.params.TelemetryListener.OnTrackPublishRTPStats( t.params.ParticipantID(), t.ID(), mimeType, diff --git a/pkg/rtc/mediatrackreceiver.go b/pkg/rtc/mediatrackreceiver.go index 9c4d64906..b1c0152d7 100644 --- a/pkg/rtc/mediatrackreceiver.go +++ b/pkg/rtc/mediatrackreceiver.go @@ -15,7 +15,6 @@ package rtc import ( - "context" "errors" "fmt" "slices" @@ -37,7 +36,6 @@ import ( "github.com/livekit/livekit-server/pkg/sfu" "github.com/livekit/livekit-server/pkg/sfu/buffer" "github.com/livekit/livekit-server/pkg/sfu/rtpstats" - "github.com/livekit/livekit-server/pkg/telemetry" sutils "github.com/livekit/livekit-server/pkg/utils" ) @@ -127,7 +125,7 @@ type MediaTrackReceiverParams struct { ReceiverConfig ReceiverConfig SubscriberConfig DirectionConfig AudioConfig sfu.AudioConfig - Telemetry telemetry.TelemetryService + TelemetryListener types.ParticipantTelemetryListener Logger logger.Logger RegressionTargetCodec mime.MimeType PreferVideoSizeFromMedia bool @@ -159,12 +157,12 @@ func NewMediaTrackReceiver(params MediaTrackReceiverParams, ti *livekit.TrackInf t.trackInfo.Store(utils.CloneProto(ti)) t.MediaTrackSubscriptions = NewMediaTrackSubscriptions(MediaTrackSubscriptionsParams{ - MediaTrack: params.MediaTrack, - IsRelayed: params.IsRelayed, - ReceiverConfig: params.ReceiverConfig, - SubscriberConfig: params.SubscriberConfig, - Telemetry: params.Telemetry, - Logger: params.Logger, + MediaTrack: params.MediaTrack, + IsRelayed: params.IsRelayed, + ReceiverConfig: params.ReceiverConfig, + SubscriberConfig: params.SubscriberConfig, + TelemetryListener: params.TelemetryListener, + Logger: params.Logger, }) t.MediaTrackSubscriptions.OnDownTrackCreated(t.onDownTrackCreated) return t @@ -937,7 +935,7 @@ func (t *MediaTrackReceiver) UpdateAudioTrack(update *livekit.UpdateLocalAudioTr t.updateTrackInfoOfReceivers() - t.params.Telemetry.TrackPublishedUpdate(context.Background(), t.PublisherID(), clonedInfo) + t.params.TelemetryListener.OnTrackPublishedUpdate(t.PublisherID(), clonedInfo) t.params.Logger.Debugw("updated audio track", "before", logger.Proto(trackInfo), "after", logger.Proto(clonedInfo)) } @@ -961,7 +959,7 @@ func (t *MediaTrackReceiver) UpdateVideoTrack(update *livekit.UpdateLocalVideoTr t.updateTrackInfoOfReceivers() - t.params.Telemetry.TrackPublishedUpdate(context.Background(), t.PublisherID(), clonedInfo) + t.params.TelemetryListener.OnTrackPublishedUpdate(t.PublisherID(), clonedInfo) t.params.Logger.Debugw("updated video track", "before", logger.Proto(trackInfo), "after", logger.Proto(clonedInfo)) } @@ -1007,7 +1005,7 @@ func (t *MediaTrackReceiver) UpdateVideoSize(mimeType mime.MimeType, sizes []buf t.updateTrackInfoOfReceivers() - t.params.Telemetry.TrackPublishedUpdate(context.Background(), t.PublisherID(), clonedInfo) + t.params.TelemetryListener.OnTrackPublishedUpdate(t.PublisherID(), clonedInfo) t.params.Logger.Debugw("updated video sizes", "before", logger.Proto(trackInfo), "after", logger.Proto(clonedInfo)) } @@ -1038,7 +1036,7 @@ func (t *MediaTrackReceiver) NotifyMaxLayerChange(mimeType mime.MimeType, maxLay } } - t.params.Telemetry.TrackPublishedUpdate(context.Background(), t.PublisherID(), ti) + t.params.TelemetryListener.OnTrackPublishedUpdate(t.PublisherID(), ti) } // GetQualityForDimension finds the closest quality to use for desired dimensions diff --git a/pkg/rtc/mediatracksubscriptions.go b/pkg/rtc/mediatracksubscriptions.go index c4dd38cd7..a8207198f 100644 --- a/pkg/rtc/mediatracksubscriptions.go +++ b/pkg/rtc/mediatracksubscriptions.go @@ -27,7 +27,6 @@ import ( "github.com/livekit/livekit-server/pkg/rtc/types" "github.com/livekit/livekit-server/pkg/sfu" - "github.com/livekit/livekit-server/pkg/telemetry" ) var ( @@ -54,7 +53,7 @@ type MediaTrackSubscriptionsParams struct { ReceiverConfig ReceiverConfig SubscriberConfig DirectionConfig - Telemetry telemetry.TelemetryService + TelemetryListener types.ParticipantTelemetryListener Logger logger.Logger } @@ -112,7 +111,7 @@ func (t *MediaTrackSubscriptions) AddSubscriber(sub types.LocalParticipant, wr * Subscriber: sub, MediaTrack: t.params.MediaTrack, AdaptiveStream: sub.GetAdaptiveStream(), - Telemetry: t.params.Telemetry, + TelemetryListener: t.params.TelemetryListener, WrappedReceiver: wr, IsRelayed: t.params.IsRelayed, OnDownTrackCreated: t.onDownTrackCreated, diff --git a/pkg/rtc/participant.go b/pkg/rtc/participant.go index 81a127f49..a50fa0411 100644 --- a/pkg/rtc/participant.go +++ b/pkg/rtc/participant.go @@ -15,7 +15,6 @@ package rtc import ( - "context" "fmt" "io" "math/rand" @@ -169,7 +168,7 @@ type ParticipantParams struct { LimitConfig config.LimitConfig ProtocolVersion types.ProtocolVersion SessionStartTime time.Time - Telemetry telemetry.TelemetryService + TelemetryListener types.ParticipantTelemetryListener Trailer []byte PLIThrottleConfig sfu.PLIThrottleConfig CongestionControlConfig config.CongestionControlConfig @@ -287,7 +286,7 @@ type ParticipantImpl struct { updateCache *lru.Cache[livekit.ParticipantID, participantUpdateInfo] updateLock utils.Mutex - dataChannelStats *telemetry.BytesTrackStats + dataChannelStats *BytesTrackStats reliableDataInfo reliableDataInfo @@ -373,11 +372,11 @@ func NewParticipant(params ParticipantParams) (*ParticipantImpl, error) { p.setupSignalling() p.id.Store(params.SID) - p.dataChannelStats = telemetry.NewBytesTrackStats( + p.dataChannelStats = NewBytesTrackStats( p.params.Country, - telemetry.BytesTrackIDForParticipantID(telemetry.BytesTrackTypeData, p.ID()), + BytesTrackIDForParticipantID(BytesTrackTypeData, p.ID()), p.ID(), - params.Telemetry, + params.TelemetryListener, params.Reporter, ) p.reliableDataInfo.lastPubReliableSeq.Store(params.LastPubReliableSeq) @@ -2038,7 +2037,7 @@ func (p *ParticipantImpl) setupSubscriptionManager() { DataTrackResolver: func(lp types.LocalParticipant, ti livekit.TrackID) types.DataResolverResult { return p.helper().ResolveDataTrack(lp, ti) }, - Telemetry: p.params.Telemetry, + TelemetryListener: p.params.TelemetryListener, OnTrackSubscribed: p.onTrackSubscribed, OnTrackUnsubscribed: p.onTrackUnsubscribed, OnSubscriptionError: p.onSubscriptionError, @@ -2721,8 +2720,7 @@ func (p *ParticipantImpl) onSubscribedMaxQualityChange( break } } - p.params.Telemetry.TrackMaxSubscribedVideoQuality( - context.Background(), + p.params.TelemetryListener.OnTrackMaxSubscribedVideoQuality( p.ID(), ti, maxSubscribedQuality.CodecMime, @@ -2961,7 +2959,7 @@ func (p *ParticipantImpl) addPendingTrackLocked(req *livekit.AddTrackRequest) *l } } - p.params.Telemetry.TrackPublishRequested(context.Background(), p.ID(), p.Identity(), utils.CloneProto(ti)) + p.params.TelemetryListener.OnTrackPublishRequested(p.ID(), p.Identity(), utils.CloneProto(ti)) if p.supervisor != nil { p.supervisor.AddPublication(livekit.TrackID(ti.Sid)) @@ -3072,9 +3070,9 @@ func (p *ParticipantImpl) setTrackMuted(mute *livekit.MuteTrackRequest, fromAdmi if trackInfo != nil && changed { if mute.Muted { - p.params.Telemetry.TrackMuted(context.Background(), p.ID(), trackInfo) + p.params.TelemetryListener.OnTrackMuted(p.ID(), trackInfo) } else { - p.params.Telemetry.TrackUnmuted(context.Background(), p.ID(), trackInfo) + p.params.TelemetryListener.OnTrackUnmuted(p.ID(), trackInfo) } } @@ -3291,7 +3289,7 @@ func (p *ParticipantImpl) addMediaTrack(signalCid string, ti *livekit.TrackInfo) ReceiverConfig: p.params.Config.Receiver, AudioConfig: p.params.AudioConfig, VideoConfig: p.params.VideoConfig, - Telemetry: p.params.Telemetry, + TelemetryListener: p.params.TelemetryListener, Logger: LoggerWithTrack(p.pubLogger, livekit.TrackID(ti.Sid), false), Reporter: p.params.Reporter.WithTrack(ti.Sid), SubscriberConfig: p.params.Config.Subscriber, @@ -3343,8 +3341,7 @@ func (p *ParticipantImpl) addMediaTrack(signalCid string, ti *livekit.TrackInfo) p.supervisor.ClearPublishedTrack(trackID, mt) } - p.params.Telemetry.TrackUnpublished( - context.Background(), + p.params.TelemetryListener.OnTrackUnpublished( p.ID(), p.Identity(), mt.ToProto(), @@ -3378,8 +3375,7 @@ func (p *ParticipantImpl) handleTrackPublished(track types.MediaTrack, isMigrate // send webhook after callbacks are complete, persistence and state handling happens // in `onTrackPublished` cb - p.params.Telemetry.TrackPublished( - context.Background(), + p.params.TelemetryListener.OnTrackPublished( p.ID(), p.Identity(), track.ToProto(), @@ -4012,8 +4008,7 @@ func (p *ParticipantImpl) MoveToRoom(params types.MoveToRoomParams) { track.(types.LocalMediaTrack).ClearSubscriberNodes() trackInfo := track.ToProto() - p.params.Telemetry.TrackUnpublished( - context.Background(), + p.params.TelemetryListener.OnTrackUnpublished( p.ID(), p.Identity(), trackInfo, diff --git a/pkg/rtc/participant_internal_test.go b/pkg/rtc/participant_internal_test.go index a48879801..781747a90 100644 --- a/pkg/rtc/participant_internal_test.go +++ b/pkg/rtc/participant_internal_test.go @@ -26,7 +26,6 @@ import ( "google.golang.org/protobuf/proto" "github.com/livekit/livekit-server/pkg/sfu/buffer" - "github.com/livekit/livekit-server/pkg/telemetry/telemetryfakes" "github.com/livekit/protocol/auth" protoCodecs "github.com/livekit/protocol/codecs" "github.com/livekit/protocol/codecs/mime" @@ -813,7 +812,7 @@ func newParticipantForTestWithOpts(identity livekit.ParticipantIdentity, opts *p ClientInfo: ClientInfo{ClientInfo: opts.clientInfo}, Logger: LoggerWithParticipant(logger.GetLogger(), identity, sid, false), Reporter: roomobs.NewNoopParticipantSessionReporter(), - Telemetry: &telemetryfakes.FakeTelemetryService{}, + TelemetryListener: &typesfakes.FakeParticipantTelemetryListener{}, VersionGenerator: utils.NewDefaultTimedVersionGenerator(), ParticipantListener: &typesfakes.FakeLocalParticipantListener{}, ParticipantHelper: &typesfakes.FakeLocalParticipantHelper{}, diff --git a/pkg/rtc/room.go b/pkg/rtc/room.go index 3a094c3a1..6517229a1 100644 --- a/pkg/rtc/room.go +++ b/pkg/rtc/room.go @@ -28,6 +28,7 @@ import ( "golang.org/x/exp/maps" "google.golang.org/protobuf/proto" + "github.com/livekit/protocol/codecs/mime" "github.com/livekit/protocol/livekit" "github.com/livekit/protocol/logger" "github.com/livekit/protocol/observability/roomobs" @@ -147,8 +148,9 @@ type Room struct { dataMessageCache *utils.TimeSizeCache[types.DataMessageCache] - onStateChangeMu sync.Mutex - localParticipantListener types.LocalParticipantListener + onStateChangeMu sync.Mutex + localParticipantListener types.LocalParticipantListener + participantTelemetryListener types.ParticipantTelemetryListener } type ParticipantOptions struct { @@ -286,6 +288,7 @@ func NewRoom( } r.trackManager = NewRoomTrackManager(r.logger) r.localParticipantListener = &localParticipantListener{room: r} + r.participantTelemetryListener = &participantTelemetryListener{room: r} if r.protoRoom.EmptyTimeout == 0 { r.protoRoom.EmptyTimeout = roomConfig.EmptyTimeout @@ -1890,6 +1893,10 @@ func (r *Room) LocalParticipantListener() types.LocalParticipantListener { return r.localParticipantListener } +func (r *Room) ParticipantTelemetryListener() types.ParticipantTelemetryListener { + return r.participantTelemetryListener +} + // ------------------------------------------------------------ var _ types.LocalParticipantListener = (*localParticipantListener)(nil) @@ -1983,6 +1990,72 @@ func (l *localParticipantListener) OnLeave(p types.LocalParticipant, closeReason // ------------------------------------------------------------ +var _ types.ParticipantTelemetryListener = (*participantTelemetryListener)(nil) + +type participantTelemetryListener struct { + room *Room +} + +func (l participantTelemetryListener) OnTrackPublishRequested(pID livekit.ParticipantID, identity livekit.ParticipantIdentity, ti *livekit.TrackInfo) { + l.room.telemetry.TrackPublishRequested(context.Background(), l.room.ID(), l.room.Name(), pID, identity, ti) +} + +func (l participantTelemetryListener) OnTrackPublished(pID livekit.ParticipantID, identity livekit.ParticipantIdentity, ti *livekit.TrackInfo, shouldSendEvent bool) { + l.room.telemetry.TrackPublished(context.Background(), l.room.ID(), l.room.Name(), pID, identity, ti, shouldSendEvent) +} + +func (l participantTelemetryListener) OnTrackUnpublished(pID livekit.ParticipantID, identity livekit.ParticipantIdentity, ti *livekit.TrackInfo, shouldSendEvent bool) { + l.room.telemetry.TrackUnpublished(context.Background(), l.room.ID(), l.room.Name(), pID, identity, ti, shouldSendEvent) +} + +func (l participantTelemetryListener) OnTrackSubscribeRequested(pID livekit.ParticipantID, ti *livekit.TrackInfo) { + l.room.telemetry.TrackSubscribeRequested(context.Background(), l.room.ID(), l.room.Name(), pID, ti) +} + +func (l participantTelemetryListener) OnTrackSubscribed(pID livekit.ParticipantID, ti *livekit.TrackInfo, publisherInfo *livekit.ParticipantInfo, shouldSendEvent bool) { + l.room.telemetry.TrackSubscribed(context.Background(), l.room.ID(), l.room.Name(), pID, ti, publisherInfo, shouldSendEvent) +} + +func (l participantTelemetryListener) OnTrackUnsubscribed(pID livekit.ParticipantID, ti *livekit.TrackInfo, shouldSendEvent bool) { + l.room.telemetry.TrackUnsubscribed(context.Background(), l.room.ID(), l.room.Name(), pID, ti, shouldSendEvent) +} + +func (l participantTelemetryListener) OnTrackSubscribeFailed(pID livekit.ParticipantID, ti livekit.TrackID, err error, isUserError bool) { + l.room.telemetry.TrackSubscribeFailed(context.Background(), l.room.ID(), l.room.Name(), pID, ti, err, isUserError) +} + +func (l participantTelemetryListener) OnTrackMuted(pID livekit.ParticipantID, ti *livekit.TrackInfo) { + l.room.telemetry.TrackMuted(context.Background(), l.room.ID(), l.room.Name(), pID, ti) +} + +func (l participantTelemetryListener) OnTrackUnmuted(pID livekit.ParticipantID, ti *livekit.TrackInfo) { + l.room.telemetry.TrackUnmuted(context.Background(), l.room.ID(), l.room.Name(), pID, ti) +} + +func (l participantTelemetryListener) OnTrackPublishedUpdate(pID livekit.ParticipantID, ti *livekit.TrackInfo) { + l.room.telemetry.TrackPublishedUpdate(context.Background(), l.room.ID(), l.room.Name(), pID, ti) +} + +func (l participantTelemetryListener) OnTrackMaxSubscribedVideoQuality(pID livekit.ParticipantID, ti *livekit.TrackInfo, mime mime.MimeType, maxQuality livekit.VideoQuality) { + l.room.telemetry.TrackMaxSubscribedVideoQuality(context.Background(), l.room.ID(), l.room.Name(), pID, ti, mime, maxQuality) +} + +func (l participantTelemetryListener) OnTrackPublishRTPStats(pID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, layer int, stats *livekit.RTPStats) { + l.room.telemetry.TrackPublishRTPStats(context.Background(), l.room.ID(), l.room.Name(), pID, trackID, mimeType, layer, stats) +} + +func (l participantTelemetryListener) OnTrackSubscribeRTPStats(pID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, stats *livekit.RTPStats) { + l.room.telemetry.TrackSubscribeRTPStats(context.Background(), l.room.ID(), l.room.Name(), pID, trackID, mimeType, stats) +} + +func (l participantTelemetryListener) OnTrackStats(key telemetry.StatsKey, stat *livekit.AnalyticsStat) { + roomID, roomName := l.room.ID(), l.room.Name() + stat.RoomId, stat.RoomName = string(roomID), string(roomName) + l.room.telemetry.TrackStats(roomID, roomName, key, stat) +} + +// ------------------------------------------------------------ + func BroadcastDataPacketForRoom( r types.Room, source types.LocalParticipant, diff --git a/pkg/telemetry/signalanddatastats.go b/pkg/rtc/signalanddatastats.go similarity index 80% rename from pkg/telemetry/signalanddatastats.go rename to pkg/rtc/signalanddatastats.go index 4b88cb969..17de369eb 100644 --- a/pkg/telemetry/signalanddatastats.go +++ b/pkg/rtc/signalanddatastats.go @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -package telemetry +package rtc import ( "context" @@ -23,6 +23,8 @@ import ( "github.com/frostbyte73/core" "go.uber.org/atomic" + "github.com/livekit/livekit-server/pkg/rtc/types" + "github.com/livekit/livekit-server/pkg/telemetry" "github.com/livekit/protocol/livekit" "github.com/livekit/protocol/observability/roomobs" "github.com/livekit/protocol/utils" @@ -50,13 +52,13 @@ type TrafficTotals struct { // stats for signal and data channel type BytesTrackStats struct { country string - trackID livekit.TrackID pID livekit.ParticipantID + trackID livekit.TrackID send, recv atomic.Uint64 sendMessages, recvMessages atomic.Uint32 totalSendBytes, totalRecvBytes atomic.Uint64 totalSendMessages, totalRecvMessages atomic.Uint32 - telemetry TelemetryService + telemetryListener types.ParticipantTelemetryListener reporter roomobs.TrackReporter done core.Fuse } @@ -65,15 +67,15 @@ func NewBytesTrackStats( country string, trackID livekit.TrackID, pID livekit.ParticipantID, - telemetry TelemetryService, + telemetryListener types.ParticipantTelemetryListener, participantReporter roomobs.ParticipantSessionReporter, ) *BytesTrackStats { s := &BytesTrackStats{ - country: country, - trackID: trackID, - pID: pID, - telemetry: telemetry, - reporter: participantReporter.WithTrack(trackID.String()), + country: country, + pID: pID, + trackID: trackID, + telemetryListener: telemetryListener, + reporter: participantReporter.WithTrack(trackID.String()), } go s.worker() return s @@ -122,8 +124,8 @@ func (s *BytesTrackStats) Stop() { func (s *BytesTrackStats) report() { if recv := s.recv.Swap(0); recv > 0 { packets := s.recvMessages.Swap(0) - s.telemetry.TrackStats( - StatsKeyForData(s.country, livekit.StreamType_UPSTREAM, s.pID, s.trackID), + s.telemetryListener.OnTrackStats( + telemetry.StatsKeyForData(s.country, livekit.StreamType_UPSTREAM, s.pID, s.trackID), &livekit.AnalyticsStat{ Streams: []*livekit.AnalyticsStream{ { @@ -137,8 +139,8 @@ func (s *BytesTrackStats) report() { if send := s.send.Swap(0); send > 0 { packets := s.sendMessages.Swap(0) - s.telemetry.TrackStats( - StatsKeyForData(s.country, livekit.StreamType_DOWNSTREAM, s.pID, s.trackID), + s.telemetryListener.OnTrackStats( + telemetry.StatsKeyForData(s.country, livekit.StreamType_DOWNSTREAM, s.pID, s.trackID), &livekit.AnalyticsStat{ Streams: []*livekit.AnalyticsStream{ { @@ -170,11 +172,14 @@ func (s *BytesTrackStats) worker() { // ----------------------------------------------------------------------- +var _ types.ParticipantTelemetryListener = (*BytesSignalStats)(nil) + type BytesSignalStats struct { BytesTrackStats ctx context.Context - guard *ReferenceGuard + telemetry telemetry.TelemetryService + guard *telemetry.ReferenceGuard participantResolver roomobs.ParticipantReporterResolver trackResolver roomobs.KeyResolver @@ -183,25 +188,29 @@ type BytesSignalStats struct { ri *livekit.Room pi *livekit.ParticipantInfo stopped chan struct{} + + types.NullParticipantTelemetryListener } func NewBytesSignalStats( ctx context.Context, - telemetry TelemetryService, + telemetryService telemetry.TelemetryService, ) *BytesSignalStats { - projectReporter := telemetry.RoomProjectReporter(ctx) + projectReporter := telemetryService.RoomProjectReporter(ctx) participantReporter, participantReporterResolver := roomobs.DeferredParticipantReporter(projectReporter) trackReporter, trackReporterResolver := participantReporter.WithDeferredTrack() - return &BytesSignalStats{ - BytesTrackStats: BytesTrackStats{ - telemetry: telemetry, - reporter: trackReporter, - }, + b := &BytesSignalStats{ ctx: ctx, - guard: &ReferenceGuard{}, + telemetry: telemetryService, + guard: &telemetry.ReferenceGuard{}, participantResolver: participantReporterResolver, trackResolver: trackReporterResolver, } + b.BytesTrackStats = BytesTrackStats{ + telemetryListener: b, + reporter: trackReporter, + } + return b } func (s *BytesSignalStats) ResolveRoom(ri *livekit.Room) { @@ -236,7 +245,7 @@ func (s *BytesSignalStats) Reset() { <-s.stopped s.stopped = nil s.done = core.Fuse{} - s.guard = &ReferenceGuard{} + s.guard = &telemetry.ReferenceGuard{} } s.ri = nil s.pi = nil @@ -272,6 +281,11 @@ func (s *BytesSignalStats) worker() { close(s.stopped) } +func (s *BytesSignalStats) OnTrackStats(key telemetry.StatsKey, stat *livekit.AnalyticsStat) { + stat.RoomId, stat.RoomName = s.ri.Sid, s.ri.Name + s.telemetry.TrackStats(livekit.RoomID(s.ri.Sid), livekit.RoomName(s.ri.Name), key, stat) +} + // ----------------------------------------------------------------------- func BytesTrackIDForParticipantID(typ BytesTrackType, participantID livekit.ParticipantID) livekit.TrackID { diff --git a/pkg/rtc/subscribedtrack.go b/pkg/rtc/subscribedtrack.go index 67eed6cc8..6f566b81e 100644 --- a/pkg/rtc/subscribedtrack.go +++ b/pkg/rtc/subscribedtrack.go @@ -48,7 +48,7 @@ type SubscribedTrackParams struct { Subscriber types.LocalParticipant MediaTrack types.MediaTrack AdaptiveStream bool - Telemetry telemetry.TelemetryService + TelemetryListener types.ParticipantTelemetryListener WrappedReceiver *WrappedReceiver IsRelayed bool OnDownTrackCreated func(downTrack *sfu.DownTrack) @@ -403,7 +403,7 @@ func (t *SubscribedTrack) OnBindAndConnected() { } func (t *SubscribedTrack) OnStatsUpdate(stat *livekit.AnalyticsStat) { - t.params.Telemetry.TrackStats(t.statsKey, stat) + t.params.TelemetryListener.OnTrackStats(t.statsKey, stat) if cs, ok := telemetry.CondenseStat(stat); ok { ti := t.params.WrappedReceiver.TrackInfo() diff --git a/pkg/rtc/subscriptionmanager.go b/pkg/rtc/subscriptionmanager.go index 8a5d07076..8e2590397 100644 --- a/pkg/rtc/subscriptionmanager.go +++ b/pkg/rtc/subscriptionmanager.go @@ -28,7 +28,6 @@ import ( "github.com/livekit/livekit-server/pkg/rtc/types" "github.com/livekit/livekit-server/pkg/sfu" - "github.com/livekit/livekit-server/pkg/telemetry" "github.com/livekit/livekit-server/pkg/telemetry/prometheus" "github.com/livekit/protocol/livekit" "github.com/livekit/protocol/logger" @@ -57,7 +56,7 @@ type SubscriptionManagerParams struct { OnTrackSubscribed func(subTrack types.SubscribedTrack) OnTrackUnsubscribed func(subTrack types.SubscribedTrack) OnSubscriptionError func(trackID livekit.TrackID, fatal bool, err error) - Telemetry telemetry.TelemetryService + TelemetryListener types.ParticipantTelemetryListener SubscriptionLimitVideo, SubscriptionLimitAudio int32 @@ -472,8 +471,7 @@ func (m *SubscriptionManager) reconcileSubscription(s *mediaTrackSubscription) { numAttempts := s.getNumAttempts() if numAttempts == 0 { - m.params.Telemetry.TrackSubscribeRequested( - context.Background(), + m.params.TelemetryListener.OnTrackSubscribeRequested( s.subscriberID, &livekit.TrackInfo{ Sid: string(s.trackID), @@ -493,14 +491,14 @@ func (m *SubscriptionManager) reconcileSubscription(s *mediaTrackSubscription) { // - ErrSubscriptionLimitExceeded: the participant have reached the limit of subscriptions, wait for the other subscription to be unsubscribed // We'll still log an event to reflect this in telemetry since it's been too long if s.durationSinceStart() > subscriptionTimeout { - s.maybeRecordError(m.params.Telemetry, s.subscriberID, err, true) + s.maybeRecordError(m.params.TelemetryListener, err, true) } case ErrTrackNotFound: // source track was never published or closed // if after timeout we'd unsubscribe from it. // this is the *only* case we'd change desired state if s.durationSinceStart() > notFoundTimeout { - s.maybeRecordError(m.params.Telemetry, s.subscriberID, err, true) + s.maybeRecordError(m.params.TelemetryListener, err, true) s.logger.Infow("unsubscribing from track after notFoundTimeout", "error", err) s.setDesired(false) m.queueReconcile(s.trackID) @@ -513,7 +511,7 @@ func (m *SubscriptionManager) reconcileSubscription(s *mediaTrackSubscription) { "failed to subscribe, triggering error handler", err, "attempt", s.getNumAttempts(), ) - s.maybeRecordError(m.params.Telemetry, s.subscriberID, err, false) + s.maybeRecordError(m.params.TelemetryListener, err, false) m.params.OnSubscriptionError(s.trackID, true, err) } else { s.logger.Debugw( @@ -552,7 +550,7 @@ func (m *SubscriptionManager) reconcileSubscription(s *mediaTrackSubscription) { wait := min(time.Since(activeAt), s.durationSinceStart()) if wait > subscriptionTimeout { s.logger.Warnw("track not bound after timeout", nil) - s.maybeRecordError(m.params.Telemetry, s.subscriberID, ErrTrackNotBound, false) + s.maybeRecordError(m.params.TelemetryListener, ErrTrackNotBound, false) m.params.OnSubscriptionError(s.trackID, true, ErrTrackNotBound) } } @@ -839,13 +837,13 @@ func (m *SubscriptionManager) addSubscriber(sub *mediaTrackSubscription, track t subTrack.AddOnBind(func(err error) { if err != nil { sub.logger.Infow("failed to bind track", "err", err) - sub.maybeRecordError(m.params.Telemetry, sub.subscriberID, err, true) + sub.maybeRecordError(m.params.TelemetryListener, err, true) m.UnsubscribeFromTrack(trackID) m.params.OnSubscriptionError(trackID, false, err) return } sub.setBound() - sub.maybeRecordSuccess(m.params.Telemetry, sub.subscriberID) + sub.maybeRecordSuccess(m.params.TelemetryListener) }) sub.setSubscribedTrack(subTrack) @@ -967,8 +965,7 @@ func (m *SubscriptionManager) handleSubscribedTrackClose(s *mediaTrackSubscripti // * the participant isn't closing // * it's not a migration if wasBound { - m.params.Telemetry.TrackUnsubscribed( - context.Background(), + m.params.TelemetryListener.OnTrackUnsubscribed( s.subscriberID, &livekit.TrackInfo{Sid: string(s.trackID), Type: subTrack.MediaTrack().Kind()}, !isExpectedToResume, @@ -978,8 +975,7 @@ func (m *SubscriptionManager) handleSubscribedTrackClose(s *mediaTrackSubscripti if dt != nil { stats := dt.GetTrackStats() if stats != nil { - m.params.Telemetry.TrackSubscribeRTPStats( - context.Background(), + m.params.TelemetryListener.OnTrackSubscribeRTPStats( s.subscriberID, s.trackID, dt.Mime(), @@ -1437,15 +1433,15 @@ func (s *mediaTrackSubscription) isBound() bool { return s.bound } -func (s *mediaTrackSubscription) maybeRecordError(ts telemetry.TelemetryService, pID livekit.ParticipantID, err error, isUserError bool) { +func (s *mediaTrackSubscription) maybeRecordError(tl types.ParticipantTelemetryListener, err error, isUserError bool) { if s.eventSent.Swap(true) { return } - ts.TrackSubscribeFailed(context.Background(), pID, s.trackID, err, isUserError) + tl.OnTrackSubscribeFailed(s.subscriberID, s.trackID, err, isUserError) } -func (s *mediaTrackSubscription) maybeRecordSuccess(ts telemetry.TelemetryService, pID livekit.ParticipantID) { +func (s *mediaTrackSubscription) maybeRecordSuccess(tl types.ParticipantTelemetryListener) { subTrack := s.getSubscribedTrack() if subTrack == nil { return @@ -1474,7 +1470,7 @@ func (s *mediaTrackSubscription) maybeRecordSuccess(ts telemetry.TelemetryServic Identity: string(subTrack.PublisherIdentity()), Sid: string(subTrack.PublisherID()), } - ts.TrackSubscribed(context.Background(), pID, mediaTrack.ToProto(), pi, !eventSent) + tl.OnTrackSubscribed(s.subscriberID, mediaTrack.ToProto(), pi, !eventSent) } func (s *mediaTrackSubscription) isCanceled() bool { diff --git a/pkg/rtc/subscriptionmanager_test.go b/pkg/rtc/subscriptionmanager_test.go index af7fce880..557711959 100644 --- a/pkg/rtc/subscriptionmanager_test.go +++ b/pkg/rtc/subscriptionmanager_test.go @@ -26,7 +26,6 @@ import ( "github.com/livekit/livekit-server/pkg/rtc/types" "github.com/livekit/livekit-server/pkg/rtc/types/typesfakes" - "github.com/livekit/livekit-server/pkg/telemetry/telemetryfakes" "github.com/livekit/livekit-server/pkg/utils" "github.com/livekit/protocol/livekit" "github.com/livekit/protocol/logger" @@ -83,8 +82,8 @@ func TestSubscribe(t *testing.T) { require.Equal(t, "pubID", string(sm.GetSubscribedParticipants()[0])) // ensure telemetry events are sent - tm := sm.params.Telemetry.(*telemetryfakes.FakeTelemetryService) - require.Equal(t, 1, tm.TrackSubscribeRequestedCallCount()) + tl := sm.params.TelemetryListener.(*typesfakes.FakeParticipantTelemetryListener) + require.Equal(t, 1, tl.OnTrackSubscribeRequestedCallCount()) // ensure bound setTestSubscribedTrackBound(t, s.getSubscribedTrack()) @@ -93,7 +92,7 @@ func TestSubscribe(t *testing.T) { }, subSettleTimeout, subCheckInterval, "track was not bound") // telemetry event should have been sent - require.Equal(t, 1, tm.TrackSubscribedCallCount()) + require.Equal(t, 1, tl.OnTrackSubscribedCallCount()) time.Sleep(notFoundTimeout) require.False(t, failed.Load()) @@ -142,9 +141,9 @@ func TestSubscribe(t *testing.T) { require.Len(t, sm.GetSubscribedTracks(), 0) // trackSubscribed telemetry not sent - tm := sm.params.Telemetry.(*telemetryfakes.FakeTelemetryService) - require.Equal(t, 1, tm.TrackSubscribeRequestedCallCount()) - require.Equal(t, 0, tm.TrackSubscribedCallCount()) + tl := sm.params.TelemetryListener.(*typesfakes.FakeParticipantTelemetryListener) + require.Equal(t, 1, tl.OnTrackSubscribeRequestedCallCount()) + require.Equal(t, 0, tl.OnTrackSubscribedCallCount()) // give permissions now resolver.lock.Lock() @@ -254,8 +253,8 @@ func TestUnsubscribe(t *testing.T) { require.Len(t, sm.GetSubscribedTracks(), 0) require.False(t, res.TrackChangedNotifier.HasObservers()) - tm := sm.params.Telemetry.(*telemetryfakes.FakeTelemetryService) - require.Equal(t, 1, tm.TrackUnsubscribedCallCount()) + tl := sm.params.TelemetryListener.(*typesfakes.FakeParticipantTelemetryListener) + require.Equal(t, 1, tl.OnTrackUnsubscribedCallCount()) } func TestSubscribeStatusChanged(t *testing.T) { @@ -394,8 +393,8 @@ func TestSubscriptionLimits(t *testing.T) { require.Equal(t, "pubID", string(sm.GetSubscribedParticipants()[0])) // ensure telemetry events are sent - tm := sm.params.Telemetry.(*telemetryfakes.FakeTelemetryService) - require.Equal(t, 1, tm.TrackSubscribeRequestedCallCount()) + tl := sm.params.TelemetryListener.(*typesfakes.FakeParticipantTelemetryListener) + require.Equal(t, 1, tl.OnTrackSubscribeRequestedCallCount()) // ensure bound setTestSubscribedTrackBound(t, s.getSubscribedTrack()) @@ -404,15 +403,15 @@ func TestSubscriptionLimits(t *testing.T) { }, subSettleTimeout, subCheckInterval, "track was not bound") // telemetry event should have been sent - require.Equal(t, 1, tm.TrackSubscribedCallCount()) + require.Equal(t, 1, tl.OnTrackSubscribedCallCount()) // reach subscription limit, subscribe pending sm.SubscribeToTrack("track2", false) s2 := sm.subscriptions["track2"] time.Sleep(subscriptionTimeout * 2) require.True(t, s2.needsSubscribe()) - require.Equal(t, 2, tm.TrackSubscribeRequestedCallCount()) - require.Equal(t, 1, tm.TrackSubscribeFailedCallCount()) + require.Equal(t, 2, tl.OnTrackSubscribeRequestedCallCount()) + require.Equal(t, 1, tl.OnTrackSubscribeFailedCallCount()) require.Len(t, sm.GetSubscribedTracks(), 1) // unsubscribe track1, then track2 should be subscribed @@ -429,7 +428,7 @@ func TestSubscriptionLimits(t *testing.T) { require.False(t, s2.needsSubscribe()) require.EqualValues(t, 2, subCount.Load()) require.NotNil(t, s2.getSubscribedTrack()) - require.Equal(t, 2, tm.TrackSubscribeRequestedCallCount()) + require.Equal(t, 2, tl.OnTrackSubscribeRequestedCallCount()) require.Len(t, sm.GetSubscribedTracks(), 1) // ensure bound @@ -444,8 +443,8 @@ func TestSubscriptionLimits(t *testing.T) { require.True(t, s.isDesired()) time.Sleep(subscriptionTimeout * 2) require.True(t, s.needsSubscribe()) - require.Equal(t, 3, tm.TrackSubscribeRequestedCallCount()) - require.Equal(t, 2, tm.TrackSubscribeFailedCallCount()) + require.Equal(t, 3, tl.OnTrackSubscribeRequestedCallCount()) + require.Equal(t, 2, tl.OnTrackSubscribeFailedCallCount()) require.Len(t, sm.GetSubscribedTracks(), 1) } @@ -473,7 +472,7 @@ func newTestSubscriptionManagerWithParams(params testSubscriptionParams) *Subscr TrackResolver: func(sub types.LocalParticipant, trackID livekit.TrackID) types.MediaResolverResult { return types.MediaResolverResult{} }, - Telemetry: &telemetryfakes.FakeTelemetryService{}, + TelemetryListener: &typesfakes.FakeParticipantTelemetryListener{}, SubscriptionLimitAudio: params.SubscriptionLimitAudio, SubscriptionLimitVideo: params.SubscriptionLimitVideo, }) diff --git a/pkg/rtc/transportmanager.go b/pkg/rtc/transportmanager.go index 83fcaace1..bc5307668 100644 --- a/pkg/rtc/transportmanager.go +++ b/pkg/rtc/transportmanager.go @@ -41,7 +41,6 @@ import ( "github.com/livekit/livekit-server/pkg/sfu/datachannel" "github.com/livekit/livekit-server/pkg/sfu/interceptor" "github.com/livekit/livekit-server/pkg/sfu/pacer" - "github.com/livekit/livekit-server/pkg/telemetry" ) const ( @@ -95,7 +94,7 @@ type TransportManagerParams struct { Logger logger.Logger PublisherHandler transport.Handler SubscriberHandler transport.Handler - DataChannelStats *telemetry.BytesTrackStats + DataChannelStats *BytesTrackStats UseOneShotSignallingMode bool FireOnTrackBySdp bool EnableDataTracks bool diff --git a/pkg/rtc/types/interfaces.go b/pkg/rtc/types/interfaces.go index 4f0d6c698..ba492a8c3 100644 --- a/pkg/rtc/types/interfaces.go +++ b/pkg/rtc/types/interfaces.go @@ -636,6 +636,61 @@ func (*NullLocalParticipantListener) OnLeave(LocalParticipant, ParticipantCloseR // --------------------------------------------- +//counterfeiter:generate . ParticipantTelemetryListener +type ParticipantTelemetryListener interface { + OnTrackPublishRequested(pID livekit.ParticipantID, identity livekit.ParticipantIdentity, ti *livekit.TrackInfo) + OnTrackPublished(pID livekit.ParticipantID, identity livekit.ParticipantIdentity, ti *livekit.TrackInfo, shouldSendEvent bool) + OnTrackUnpublished(pID livekit.ParticipantID, identity livekit.ParticipantIdentity, ti *livekit.TrackInfo, shouldSendEvent bool) + OnTrackSubscribeRequested(pID livekit.ParticipantID, ti *livekit.TrackInfo) + OnTrackSubscribed(pID livekit.ParticipantID, ti *livekit.TrackInfo, publisherInfo *livekit.ParticipantInfo, shouldSendEvent bool) + OnTrackUnsubscribed(pID livekit.ParticipantID, ti *livekit.TrackInfo, shouldSendEvent bool) + OnTrackSubscribeFailed(pID livekit.ParticipantID, ti livekit.TrackID, err error, isUserError bool) + OnTrackMuted(pID livekit.ParticipantID, ti *livekit.TrackInfo) + OnTrackUnmuted(pID livekit.ParticipantID, ti *livekit.TrackInfo) + OnTrackPublishedUpdate(pID livekit.ParticipantID, ti *livekit.TrackInfo) + OnTrackMaxSubscribedVideoQuality(pID livekit.ParticipantID, ti *livekit.TrackInfo, mime mime.MimeType, maxQuality livekit.VideoQuality) + OnTrackPublishRTPStats(pID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, layer int, stats *livekit.RTPStats) + OnTrackSubscribeRTPStats(pID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, stats *livekit.RTPStats) + + OnTrackStats(key telemetry.StatsKey, stat *livekit.AnalyticsStat) +} + +var _ ParticipantTelemetryListener = (*NullParticipantTelemetryListener)(nil) + +type NullParticipantTelemetryListener struct{} + +func (NullParticipantTelemetryListener) OnTrackPublishRequested(pID livekit.ParticipantID, identity livekit.ParticipantIdentity, ti *livekit.TrackInfo) { +} +func (NullParticipantTelemetryListener) OnTrackPublished(pID livekit.ParticipantID, identity livekit.ParticipantIdentity, ti *livekit.TrackInfo, shouldSendEvent bool) { +} +func (NullParticipantTelemetryListener) OnTrackUnpublished(pID livekit.ParticipantID, identity livekit.ParticipantIdentity, ti *livekit.TrackInfo, shouldSendEvent bool) { +} +func (NullParticipantTelemetryListener) OnTrackSubscribeRequested(pID livekit.ParticipantID, ti *livekit.TrackInfo) { +} +func (NullParticipantTelemetryListener) OnTrackSubscribed(pID livekit.ParticipantID, ti *livekit.TrackInfo, publisherInfo *livekit.ParticipantInfo, shouldSendEvent bool) { +} +func (NullParticipantTelemetryListener) OnTrackUnsubscribed(pID livekit.ParticipantID, ti *livekit.TrackInfo, shouldSendEvent bool) { +} +func (NullParticipantTelemetryListener) OnTrackSubscribeFailed(pID livekit.ParticipantID, ti livekit.TrackID, err error, isUserError bool) { +} +func (NullParticipantTelemetryListener) OnTrackMuted(pID livekit.ParticipantID, ti *livekit.TrackInfo) { +} +func (NullParticipantTelemetryListener) OnTrackUnmuted(pID livekit.ParticipantID, ti *livekit.TrackInfo) { +} +func (NullParticipantTelemetryListener) OnTrackPublishedUpdate(pID livekit.ParticipantID, ti *livekit.TrackInfo) { +} +func (NullParticipantTelemetryListener) OnTrackMaxSubscribedVideoQuality(pID livekit.ParticipantID, ti *livekit.TrackInfo, mime mime.MimeType, maxQuality livekit.VideoQuality) { +} +func (NullParticipantTelemetryListener) OnTrackPublishRTPStats(pID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, layer int, stats *livekit.RTPStats) { +} +func (NullParticipantTelemetryListener) OnTrackSubscribeRTPStats(pID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, stats *livekit.RTPStats) { +} + +func (NullParticipantTelemetryListener) OnTrackStats(key telemetry.StatsKey, stat *livekit.AnalyticsStat) { +} + +// --------------------------------------------- + // Room is a container of participants, and can provide room-level actions // //counterfeiter:generate . Room diff --git a/pkg/rtc/types/typesfakes/fake_participant_telemetry_listener.go b/pkg/rtc/types/typesfakes/fake_participant_telemetry_listener.go new file mode 100644 index 000000000..dd00c817a --- /dev/null +++ b/pkg/rtc/types/typesfakes/fake_participant_telemetry_listener.go @@ -0,0 +1,620 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package typesfakes + +import ( + "sync" + + "github.com/livekit/livekit-server/pkg/rtc/types" + "github.com/livekit/livekit-server/pkg/telemetry" + "github.com/livekit/protocol/codecs/mime" + "github.com/livekit/protocol/livekit" +) + +type FakeParticipantTelemetryListener struct { + OnTrackMaxSubscribedVideoQualityStub func(livekit.ParticipantID, *livekit.TrackInfo, mime.MimeType, livekit.VideoQuality) + onTrackMaxSubscribedVideoQualityMutex sync.RWMutex + onTrackMaxSubscribedVideoQualityArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 *livekit.TrackInfo + arg3 mime.MimeType + arg4 livekit.VideoQuality + } + OnTrackMutedStub func(livekit.ParticipantID, *livekit.TrackInfo) + onTrackMutedMutex sync.RWMutex + onTrackMutedArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 *livekit.TrackInfo + } + OnTrackPublishRTPStatsStub func(livekit.ParticipantID, livekit.TrackID, mime.MimeType, int, *livekit.RTPStats) + onTrackPublishRTPStatsMutex sync.RWMutex + onTrackPublishRTPStatsArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 livekit.TrackID + arg3 mime.MimeType + arg4 int + arg5 *livekit.RTPStats + } + OnTrackPublishRequestedStub func(livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo) + onTrackPublishRequestedMutex sync.RWMutex + onTrackPublishRequestedArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 livekit.ParticipantIdentity + arg3 *livekit.TrackInfo + } + OnTrackPublishedStub func(livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool) + onTrackPublishedMutex sync.RWMutex + onTrackPublishedArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 livekit.ParticipantIdentity + arg3 *livekit.TrackInfo + arg4 bool + } + OnTrackPublishedUpdateStub func(livekit.ParticipantID, *livekit.TrackInfo) + onTrackPublishedUpdateMutex sync.RWMutex + onTrackPublishedUpdateArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 *livekit.TrackInfo + } + OnTrackStatsStub func(telemetry.StatsKey, *livekit.AnalyticsStat) + onTrackStatsMutex sync.RWMutex + onTrackStatsArgsForCall []struct { + arg1 telemetry.StatsKey + arg2 *livekit.AnalyticsStat + } + OnTrackSubscribeFailedStub func(livekit.ParticipantID, livekit.TrackID, error, bool) + onTrackSubscribeFailedMutex sync.RWMutex + onTrackSubscribeFailedArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 livekit.TrackID + arg3 error + arg4 bool + } + OnTrackSubscribeRTPStatsStub func(livekit.ParticipantID, livekit.TrackID, mime.MimeType, *livekit.RTPStats) + onTrackSubscribeRTPStatsMutex sync.RWMutex + onTrackSubscribeRTPStatsArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 livekit.TrackID + arg3 mime.MimeType + arg4 *livekit.RTPStats + } + OnTrackSubscribeRequestedStub func(livekit.ParticipantID, *livekit.TrackInfo) + onTrackSubscribeRequestedMutex sync.RWMutex + onTrackSubscribeRequestedArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 *livekit.TrackInfo + } + OnTrackSubscribedStub func(livekit.ParticipantID, *livekit.TrackInfo, *livekit.ParticipantInfo, bool) + onTrackSubscribedMutex sync.RWMutex + onTrackSubscribedArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 *livekit.TrackInfo + arg3 *livekit.ParticipantInfo + arg4 bool + } + OnTrackUnmutedStub func(livekit.ParticipantID, *livekit.TrackInfo) + onTrackUnmutedMutex sync.RWMutex + onTrackUnmutedArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 *livekit.TrackInfo + } + OnTrackUnpublishedStub func(livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool) + onTrackUnpublishedMutex sync.RWMutex + onTrackUnpublishedArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 livekit.ParticipantIdentity + arg3 *livekit.TrackInfo + arg4 bool + } + OnTrackUnsubscribedStub func(livekit.ParticipantID, *livekit.TrackInfo, bool) + onTrackUnsubscribedMutex sync.RWMutex + onTrackUnsubscribedArgsForCall []struct { + arg1 livekit.ParticipantID + arg2 *livekit.TrackInfo + arg3 bool + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeParticipantTelemetryListener) OnTrackMaxSubscribedVideoQuality(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo, arg3 mime.MimeType, arg4 livekit.VideoQuality) { + fake.onTrackMaxSubscribedVideoQualityMutex.Lock() + fake.onTrackMaxSubscribedVideoQualityArgsForCall = append(fake.onTrackMaxSubscribedVideoQualityArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 *livekit.TrackInfo + arg3 mime.MimeType + arg4 livekit.VideoQuality + }{arg1, arg2, arg3, arg4}) + stub := fake.OnTrackMaxSubscribedVideoQualityStub + fake.recordInvocation("OnTrackMaxSubscribedVideoQuality", []interface{}{arg1, arg2, arg3, arg4}) + fake.onTrackMaxSubscribedVideoQualityMutex.Unlock() + if stub != nil { + fake.OnTrackMaxSubscribedVideoQualityStub(arg1, arg2, arg3, arg4) + } +} + +func (fake *FakeParticipantTelemetryListener) OnTrackMaxSubscribedVideoQualityCallCount() int { + fake.onTrackMaxSubscribedVideoQualityMutex.RLock() + defer fake.onTrackMaxSubscribedVideoQualityMutex.RUnlock() + return len(fake.onTrackMaxSubscribedVideoQualityArgsForCall) +} + +func (fake *FakeParticipantTelemetryListener) OnTrackMaxSubscribedVideoQualityCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo, mime.MimeType, livekit.VideoQuality)) { + fake.onTrackMaxSubscribedVideoQualityMutex.Lock() + defer fake.onTrackMaxSubscribedVideoQualityMutex.Unlock() + fake.OnTrackMaxSubscribedVideoQualityStub = stub +} + +func (fake *FakeParticipantTelemetryListener) OnTrackMaxSubscribedVideoQualityArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo, mime.MimeType, livekit.VideoQuality) { + fake.onTrackMaxSubscribedVideoQualityMutex.RLock() + defer fake.onTrackMaxSubscribedVideoQualityMutex.RUnlock() + argsForCall := fake.onTrackMaxSubscribedVideoQualityArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeParticipantTelemetryListener) OnTrackMuted(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo) { + fake.onTrackMutedMutex.Lock() + fake.onTrackMutedArgsForCall = append(fake.onTrackMutedArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 *livekit.TrackInfo + }{arg1, arg2}) + stub := fake.OnTrackMutedStub + fake.recordInvocation("OnTrackMuted", []interface{}{arg1, arg2}) + fake.onTrackMutedMutex.Unlock() + if stub != nil { + fake.OnTrackMutedStub(arg1, arg2) + } +} + +func (fake *FakeParticipantTelemetryListener) OnTrackMutedCallCount() int { + fake.onTrackMutedMutex.RLock() + defer fake.onTrackMutedMutex.RUnlock() + return len(fake.onTrackMutedArgsForCall) +} + +func (fake *FakeParticipantTelemetryListener) OnTrackMutedCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo)) { + fake.onTrackMutedMutex.Lock() + defer fake.onTrackMutedMutex.Unlock() + fake.OnTrackMutedStub = stub +} + +func (fake *FakeParticipantTelemetryListener) OnTrackMutedArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo) { + fake.onTrackMutedMutex.RLock() + defer fake.onTrackMutedMutex.RUnlock() + argsForCall := fake.onTrackMutedArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishRTPStats(arg1 livekit.ParticipantID, arg2 livekit.TrackID, arg3 mime.MimeType, arg4 int, arg5 *livekit.RTPStats) { + fake.onTrackPublishRTPStatsMutex.Lock() + fake.onTrackPublishRTPStatsArgsForCall = append(fake.onTrackPublishRTPStatsArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 livekit.TrackID + arg3 mime.MimeType + arg4 int + arg5 *livekit.RTPStats + }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.OnTrackPublishRTPStatsStub + fake.recordInvocation("OnTrackPublishRTPStats", []interface{}{arg1, arg2, arg3, arg4, arg5}) + fake.onTrackPublishRTPStatsMutex.Unlock() + if stub != nil { + fake.OnTrackPublishRTPStatsStub(arg1, arg2, arg3, arg4, arg5) + } +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishRTPStatsCallCount() int { + fake.onTrackPublishRTPStatsMutex.RLock() + defer fake.onTrackPublishRTPStatsMutex.RUnlock() + return len(fake.onTrackPublishRTPStatsArgsForCall) +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishRTPStatsCalls(stub func(livekit.ParticipantID, livekit.TrackID, mime.MimeType, int, *livekit.RTPStats)) { + fake.onTrackPublishRTPStatsMutex.Lock() + defer fake.onTrackPublishRTPStatsMutex.Unlock() + fake.OnTrackPublishRTPStatsStub = stub +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishRTPStatsArgsForCall(i int) (livekit.ParticipantID, livekit.TrackID, mime.MimeType, int, *livekit.RTPStats) { + fake.onTrackPublishRTPStatsMutex.RLock() + defer fake.onTrackPublishRTPStatsMutex.RUnlock() + argsForCall := fake.onTrackPublishRTPStatsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishRequested(arg1 livekit.ParticipantID, arg2 livekit.ParticipantIdentity, arg3 *livekit.TrackInfo) { + fake.onTrackPublishRequestedMutex.Lock() + fake.onTrackPublishRequestedArgsForCall = append(fake.onTrackPublishRequestedArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 livekit.ParticipantIdentity + arg3 *livekit.TrackInfo + }{arg1, arg2, arg3}) + stub := fake.OnTrackPublishRequestedStub + fake.recordInvocation("OnTrackPublishRequested", []interface{}{arg1, arg2, arg3}) + fake.onTrackPublishRequestedMutex.Unlock() + if stub != nil { + fake.OnTrackPublishRequestedStub(arg1, arg2, arg3) + } +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishRequestedCallCount() int { + fake.onTrackPublishRequestedMutex.RLock() + defer fake.onTrackPublishRequestedMutex.RUnlock() + return len(fake.onTrackPublishRequestedArgsForCall) +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishRequestedCalls(stub func(livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo)) { + fake.onTrackPublishRequestedMutex.Lock() + defer fake.onTrackPublishRequestedMutex.Unlock() + fake.OnTrackPublishRequestedStub = stub +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishRequestedArgsForCall(i int) (livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo) { + fake.onTrackPublishRequestedMutex.RLock() + defer fake.onTrackPublishRequestedMutex.RUnlock() + argsForCall := fake.onTrackPublishRequestedArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublished(arg1 livekit.ParticipantID, arg2 livekit.ParticipantIdentity, arg3 *livekit.TrackInfo, arg4 bool) { + fake.onTrackPublishedMutex.Lock() + fake.onTrackPublishedArgsForCall = append(fake.onTrackPublishedArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 livekit.ParticipantIdentity + arg3 *livekit.TrackInfo + arg4 bool + }{arg1, arg2, arg3, arg4}) + stub := fake.OnTrackPublishedStub + fake.recordInvocation("OnTrackPublished", []interface{}{arg1, arg2, arg3, arg4}) + fake.onTrackPublishedMutex.Unlock() + if stub != nil { + fake.OnTrackPublishedStub(arg1, arg2, arg3, arg4) + } +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishedCallCount() int { + fake.onTrackPublishedMutex.RLock() + defer fake.onTrackPublishedMutex.RUnlock() + return len(fake.onTrackPublishedArgsForCall) +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishedCalls(stub func(livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool)) { + fake.onTrackPublishedMutex.Lock() + defer fake.onTrackPublishedMutex.Unlock() + fake.OnTrackPublishedStub = stub +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishedArgsForCall(i int) (livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool) { + fake.onTrackPublishedMutex.RLock() + defer fake.onTrackPublishedMutex.RUnlock() + argsForCall := fake.onTrackPublishedArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishedUpdate(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo) { + fake.onTrackPublishedUpdateMutex.Lock() + fake.onTrackPublishedUpdateArgsForCall = append(fake.onTrackPublishedUpdateArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 *livekit.TrackInfo + }{arg1, arg2}) + stub := fake.OnTrackPublishedUpdateStub + fake.recordInvocation("OnTrackPublishedUpdate", []interface{}{arg1, arg2}) + fake.onTrackPublishedUpdateMutex.Unlock() + if stub != nil { + fake.OnTrackPublishedUpdateStub(arg1, arg2) + } +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishedUpdateCallCount() int { + fake.onTrackPublishedUpdateMutex.RLock() + defer fake.onTrackPublishedUpdateMutex.RUnlock() + return len(fake.onTrackPublishedUpdateArgsForCall) +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishedUpdateCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo)) { + fake.onTrackPublishedUpdateMutex.Lock() + defer fake.onTrackPublishedUpdateMutex.Unlock() + fake.OnTrackPublishedUpdateStub = stub +} + +func (fake *FakeParticipantTelemetryListener) OnTrackPublishedUpdateArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo) { + fake.onTrackPublishedUpdateMutex.RLock() + defer fake.onTrackPublishedUpdateMutex.RUnlock() + argsForCall := fake.onTrackPublishedUpdateArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeParticipantTelemetryListener) OnTrackStats(arg1 telemetry.StatsKey, arg2 *livekit.AnalyticsStat) { + fake.onTrackStatsMutex.Lock() + fake.onTrackStatsArgsForCall = append(fake.onTrackStatsArgsForCall, struct { + arg1 telemetry.StatsKey + arg2 *livekit.AnalyticsStat + }{arg1, arg2}) + stub := fake.OnTrackStatsStub + fake.recordInvocation("OnTrackStats", []interface{}{arg1, arg2}) + fake.onTrackStatsMutex.Unlock() + if stub != nil { + fake.OnTrackStatsStub(arg1, arg2) + } +} + +func (fake *FakeParticipantTelemetryListener) OnTrackStatsCallCount() int { + fake.onTrackStatsMutex.RLock() + defer fake.onTrackStatsMutex.RUnlock() + return len(fake.onTrackStatsArgsForCall) +} + +func (fake *FakeParticipantTelemetryListener) OnTrackStatsCalls(stub func(telemetry.StatsKey, *livekit.AnalyticsStat)) { + fake.onTrackStatsMutex.Lock() + defer fake.onTrackStatsMutex.Unlock() + fake.OnTrackStatsStub = stub +} + +func (fake *FakeParticipantTelemetryListener) OnTrackStatsArgsForCall(i int) (telemetry.StatsKey, *livekit.AnalyticsStat) { + fake.onTrackStatsMutex.RLock() + defer fake.onTrackStatsMutex.RUnlock() + argsForCall := fake.onTrackStatsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeFailed(arg1 livekit.ParticipantID, arg2 livekit.TrackID, arg3 error, arg4 bool) { + fake.onTrackSubscribeFailedMutex.Lock() + fake.onTrackSubscribeFailedArgsForCall = append(fake.onTrackSubscribeFailedArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 livekit.TrackID + arg3 error + arg4 bool + }{arg1, arg2, arg3, arg4}) + stub := fake.OnTrackSubscribeFailedStub + fake.recordInvocation("OnTrackSubscribeFailed", []interface{}{arg1, arg2, arg3, arg4}) + fake.onTrackSubscribeFailedMutex.Unlock() + if stub != nil { + fake.OnTrackSubscribeFailedStub(arg1, arg2, arg3, arg4) + } +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeFailedCallCount() int { + fake.onTrackSubscribeFailedMutex.RLock() + defer fake.onTrackSubscribeFailedMutex.RUnlock() + return len(fake.onTrackSubscribeFailedArgsForCall) +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeFailedCalls(stub func(livekit.ParticipantID, livekit.TrackID, error, bool)) { + fake.onTrackSubscribeFailedMutex.Lock() + defer fake.onTrackSubscribeFailedMutex.Unlock() + fake.OnTrackSubscribeFailedStub = stub +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeFailedArgsForCall(i int) (livekit.ParticipantID, livekit.TrackID, error, bool) { + fake.onTrackSubscribeFailedMutex.RLock() + defer fake.onTrackSubscribeFailedMutex.RUnlock() + argsForCall := fake.onTrackSubscribeFailedArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRTPStats(arg1 livekit.ParticipantID, arg2 livekit.TrackID, arg3 mime.MimeType, arg4 *livekit.RTPStats) { + fake.onTrackSubscribeRTPStatsMutex.Lock() + fake.onTrackSubscribeRTPStatsArgsForCall = append(fake.onTrackSubscribeRTPStatsArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 livekit.TrackID + arg3 mime.MimeType + arg4 *livekit.RTPStats + }{arg1, arg2, arg3, arg4}) + stub := fake.OnTrackSubscribeRTPStatsStub + fake.recordInvocation("OnTrackSubscribeRTPStats", []interface{}{arg1, arg2, arg3, arg4}) + fake.onTrackSubscribeRTPStatsMutex.Unlock() + if stub != nil { + fake.OnTrackSubscribeRTPStatsStub(arg1, arg2, arg3, arg4) + } +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRTPStatsCallCount() int { + fake.onTrackSubscribeRTPStatsMutex.RLock() + defer fake.onTrackSubscribeRTPStatsMutex.RUnlock() + return len(fake.onTrackSubscribeRTPStatsArgsForCall) +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRTPStatsCalls(stub func(livekit.ParticipantID, livekit.TrackID, mime.MimeType, *livekit.RTPStats)) { + fake.onTrackSubscribeRTPStatsMutex.Lock() + defer fake.onTrackSubscribeRTPStatsMutex.Unlock() + fake.OnTrackSubscribeRTPStatsStub = stub +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRTPStatsArgsForCall(i int) (livekit.ParticipantID, livekit.TrackID, mime.MimeType, *livekit.RTPStats) { + fake.onTrackSubscribeRTPStatsMutex.RLock() + defer fake.onTrackSubscribeRTPStatsMutex.RUnlock() + argsForCall := fake.onTrackSubscribeRTPStatsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRequested(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo) { + fake.onTrackSubscribeRequestedMutex.Lock() + fake.onTrackSubscribeRequestedArgsForCall = append(fake.onTrackSubscribeRequestedArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 *livekit.TrackInfo + }{arg1, arg2}) + stub := fake.OnTrackSubscribeRequestedStub + fake.recordInvocation("OnTrackSubscribeRequested", []interface{}{arg1, arg2}) + fake.onTrackSubscribeRequestedMutex.Unlock() + if stub != nil { + fake.OnTrackSubscribeRequestedStub(arg1, arg2) + } +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRequestedCallCount() int { + fake.onTrackSubscribeRequestedMutex.RLock() + defer fake.onTrackSubscribeRequestedMutex.RUnlock() + return len(fake.onTrackSubscribeRequestedArgsForCall) +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRequestedCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo)) { + fake.onTrackSubscribeRequestedMutex.Lock() + defer fake.onTrackSubscribeRequestedMutex.Unlock() + fake.OnTrackSubscribeRequestedStub = stub +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribeRequestedArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo) { + fake.onTrackSubscribeRequestedMutex.RLock() + defer fake.onTrackSubscribeRequestedMutex.RUnlock() + argsForCall := fake.onTrackSubscribeRequestedArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribed(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo, arg3 *livekit.ParticipantInfo, arg4 bool) { + fake.onTrackSubscribedMutex.Lock() + fake.onTrackSubscribedArgsForCall = append(fake.onTrackSubscribedArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 *livekit.TrackInfo + arg3 *livekit.ParticipantInfo + arg4 bool + }{arg1, arg2, arg3, arg4}) + stub := fake.OnTrackSubscribedStub + fake.recordInvocation("OnTrackSubscribed", []interface{}{arg1, arg2, arg3, arg4}) + fake.onTrackSubscribedMutex.Unlock() + if stub != nil { + fake.OnTrackSubscribedStub(arg1, arg2, arg3, arg4) + } +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribedCallCount() int { + fake.onTrackSubscribedMutex.RLock() + defer fake.onTrackSubscribedMutex.RUnlock() + return len(fake.onTrackSubscribedArgsForCall) +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribedCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo, *livekit.ParticipantInfo, bool)) { + fake.onTrackSubscribedMutex.Lock() + defer fake.onTrackSubscribedMutex.Unlock() + fake.OnTrackSubscribedStub = stub +} + +func (fake *FakeParticipantTelemetryListener) OnTrackSubscribedArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo, *livekit.ParticipantInfo, bool) { + fake.onTrackSubscribedMutex.RLock() + defer fake.onTrackSubscribedMutex.RUnlock() + argsForCall := fake.onTrackSubscribedArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeParticipantTelemetryListener) OnTrackUnmuted(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo) { + fake.onTrackUnmutedMutex.Lock() + fake.onTrackUnmutedArgsForCall = append(fake.onTrackUnmutedArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 *livekit.TrackInfo + }{arg1, arg2}) + stub := fake.OnTrackUnmutedStub + fake.recordInvocation("OnTrackUnmuted", []interface{}{arg1, arg2}) + fake.onTrackUnmutedMutex.Unlock() + if stub != nil { + fake.OnTrackUnmutedStub(arg1, arg2) + } +} + +func (fake *FakeParticipantTelemetryListener) OnTrackUnmutedCallCount() int { + fake.onTrackUnmutedMutex.RLock() + defer fake.onTrackUnmutedMutex.RUnlock() + return len(fake.onTrackUnmutedArgsForCall) +} + +func (fake *FakeParticipantTelemetryListener) OnTrackUnmutedCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo)) { + fake.onTrackUnmutedMutex.Lock() + defer fake.onTrackUnmutedMutex.Unlock() + fake.OnTrackUnmutedStub = stub +} + +func (fake *FakeParticipantTelemetryListener) OnTrackUnmutedArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo) { + fake.onTrackUnmutedMutex.RLock() + defer fake.onTrackUnmutedMutex.RUnlock() + argsForCall := fake.onTrackUnmutedArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeParticipantTelemetryListener) OnTrackUnpublished(arg1 livekit.ParticipantID, arg2 livekit.ParticipantIdentity, arg3 *livekit.TrackInfo, arg4 bool) { + fake.onTrackUnpublishedMutex.Lock() + fake.onTrackUnpublishedArgsForCall = append(fake.onTrackUnpublishedArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 livekit.ParticipantIdentity + arg3 *livekit.TrackInfo + arg4 bool + }{arg1, arg2, arg3, arg4}) + stub := fake.OnTrackUnpublishedStub + fake.recordInvocation("OnTrackUnpublished", []interface{}{arg1, arg2, arg3, arg4}) + fake.onTrackUnpublishedMutex.Unlock() + if stub != nil { + fake.OnTrackUnpublishedStub(arg1, arg2, arg3, arg4) + } +} + +func (fake *FakeParticipantTelemetryListener) OnTrackUnpublishedCallCount() int { + fake.onTrackUnpublishedMutex.RLock() + defer fake.onTrackUnpublishedMutex.RUnlock() + return len(fake.onTrackUnpublishedArgsForCall) +} + +func (fake *FakeParticipantTelemetryListener) OnTrackUnpublishedCalls(stub func(livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool)) { + fake.onTrackUnpublishedMutex.Lock() + defer fake.onTrackUnpublishedMutex.Unlock() + fake.OnTrackUnpublishedStub = stub +} + +func (fake *FakeParticipantTelemetryListener) OnTrackUnpublishedArgsForCall(i int) (livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool) { + fake.onTrackUnpublishedMutex.RLock() + defer fake.onTrackUnpublishedMutex.RUnlock() + argsForCall := fake.onTrackUnpublishedArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeParticipantTelemetryListener) OnTrackUnsubscribed(arg1 livekit.ParticipantID, arg2 *livekit.TrackInfo, arg3 bool) { + fake.onTrackUnsubscribedMutex.Lock() + fake.onTrackUnsubscribedArgsForCall = append(fake.onTrackUnsubscribedArgsForCall, struct { + arg1 livekit.ParticipantID + arg2 *livekit.TrackInfo + arg3 bool + }{arg1, arg2, arg3}) + stub := fake.OnTrackUnsubscribedStub + fake.recordInvocation("OnTrackUnsubscribed", []interface{}{arg1, arg2, arg3}) + fake.onTrackUnsubscribedMutex.Unlock() + if stub != nil { + fake.OnTrackUnsubscribedStub(arg1, arg2, arg3) + } +} + +func (fake *FakeParticipantTelemetryListener) OnTrackUnsubscribedCallCount() int { + fake.onTrackUnsubscribedMutex.RLock() + defer fake.onTrackUnsubscribedMutex.RUnlock() + return len(fake.onTrackUnsubscribedArgsForCall) +} + +func (fake *FakeParticipantTelemetryListener) OnTrackUnsubscribedCalls(stub func(livekit.ParticipantID, *livekit.TrackInfo, bool)) { + fake.onTrackUnsubscribedMutex.Lock() + defer fake.onTrackUnsubscribedMutex.Unlock() + fake.OnTrackUnsubscribedStub = stub +} + +func (fake *FakeParticipantTelemetryListener) OnTrackUnsubscribedArgsForCall(i int) (livekit.ParticipantID, *livekit.TrackInfo, bool) { + fake.onTrackUnsubscribedMutex.RLock() + defer fake.onTrackUnsubscribedMutex.RUnlock() + argsForCall := fake.onTrackUnsubscribedArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeParticipantTelemetryListener) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeParticipantTelemetryListener) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ types.ParticipantTelemetryListener = new(FakeParticipantTelemetryListener) diff --git a/pkg/service/roommanager.go b/pkg/service/roommanager.go index 59dc588e7..fcd3868e0 100644 --- a/pkg/service/roommanager.go +++ b/pkg/service/roommanager.go @@ -469,7 +469,7 @@ func (r *RoomManager) StartSession( LimitConfig: r.config.Limit, ProtocolVersion: pv, SessionStartTime: sessionStartTime, - Telemetry: r.telemetry, + TelemetryListener: room.ParticipantTelemetryListener(), Trailer: room.Trailer(), PLIThrottleConfig: r.config.RTC.PLIThrottle, CongestionControlConfig: r.config.RTC.CongestionControl, diff --git a/pkg/service/rtcservice.go b/pkg/service/rtcservice.go index 03fc13941..2cac95d37 100644 --- a/pkg/service/rtcservice.go +++ b/pkg/service/rtcservice.go @@ -382,7 +382,7 @@ func (s *RTCService) serve(w http.ResponseWriter, r *http.Request, needsJoinRequ resolveLogger(false) } - signalStats := telemetry.NewBytesSignalStats(r.Context(), s.telemetry) + signalStats := rtc.NewBytesSignalStats(r.Context(), s.telemetry) if join := initialResponse.GetJoin(); join != nil { signalStats.ResolveRoom(join.GetRoom()) signalStats.ResolveParticipant(join.GetParticipant()) diff --git a/pkg/telemetry/events.go b/pkg/telemetry/events.go index fb4de3656..6a84eaeb6 100644 --- a/pkg/telemetry/events.go +++ b/pkg/telemetry/events.go @@ -188,7 +188,7 @@ func (t *telemetryService) ParticipantLeft(ctx context.Context, ) { t.enqueue(func() { isConnected := false - if worker, ok := t.getWorker(livekit.ParticipantID(participant.Sid)); ok { + if worker, ok := t.getWorker(livekit.RoomID(room.Sid), livekit.ParticipantID(participant.Sid)); ok { isConnected = worker.IsConnected() if worker.Close(guard) { prometheus.SubParticipant() @@ -224,13 +224,15 @@ func (t *telemetryService) ParticipantLeft(ctx context.Context, func (t *telemetryService) TrackPublishRequested( ctx context.Context, + roomID livekit.RoomID, + roomName livekit.RoomName, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo, ) { t.enqueue(func() { prometheus.RecordTrackPublishAttempt(track.Type.String()) - room := t.getRoomDetails(participantID) + room := toMinimalRoomProto(roomID, roomName) ev := newTrackEvent(livekit.AnalyticsEventType_TRACK_PUBLISH_REQUESTED, room, participantID, track) if ev.Participant != nil { ev.Participant.Identity = string(identity) @@ -241,6 +243,8 @@ func (t *telemetryService) TrackPublishRequested( func (t *telemetryService) TrackPublished( ctx context.Context, + roomID livekit.RoomID, + roomName livekit.RoomName, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo, @@ -253,7 +257,7 @@ func (t *telemetryService) TrackPublished( return } - room := t.getRoomDetails(participantID) + room := toMinimalRoomProto(roomID, roomName) participant := &livekit.ParticipantInfo{ Sid: string(participantID), Identity: string(identity), @@ -271,22 +275,30 @@ func (t *telemetryService) TrackPublished( }) } -func (t *telemetryService) TrackPublishedUpdate(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo) { +func (t *telemetryService) TrackPublishedUpdate( + ctx context.Context, + roomID livekit.RoomID, + roomName livekit.RoomName, + participantID livekit.ParticipantID, + track *livekit.TrackInfo, +) { t.enqueue(func() { - room := t.getRoomDetails(participantID) + room := toMinimalRoomProto(roomID, roomName) t.SendEvent(ctx, newTrackEvent(livekit.AnalyticsEventType_TRACK_PUBLISHED_UPDATE, room, participantID, track)) }) } func (t *telemetryService) TrackMaxSubscribedVideoQuality( ctx context.Context, + roomID livekit.RoomID, + roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo, mime mime.MimeType, maxQuality livekit.VideoQuality, ) { t.enqueue(func() { - room := t.getRoomDetails(participantID) + room := toMinimalRoomProto(roomID, roomName) ev := newTrackEvent(livekit.AnalyticsEventType_TRACK_MAX_SUBSCRIBED_VIDEO_QUALITY, room, participantID, track) ev.MaxSubscribedVideoQuality = maxQuality ev.Mime = mime.String() @@ -296,13 +308,15 @@ func (t *telemetryService) TrackMaxSubscribedVideoQuality( func (t *telemetryService) TrackSubscribeRequested( ctx context.Context, + roomID livekit.RoomID, + roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo, ) { t.enqueue(func() { prometheus.RecordTrackSubscribeAttempt() - room := t.getRoomDetails(participantID) + room := toMinimalRoomProto(roomID, roomName) ev := newTrackEvent(livekit.AnalyticsEventType_TRACK_SUBSCRIBE_REQUESTED, room, participantID, track) t.SendEvent(ctx, ev) }) @@ -310,6 +324,8 @@ func (t *telemetryService) TrackSubscribeRequested( func (t *telemetryService) TrackSubscribed( ctx context.Context, + roomID livekit.RoomID, + roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo, publisher *livekit.ParticipantInfo, @@ -322,7 +338,7 @@ func (t *telemetryService) TrackSubscribed( return } - room := t.getRoomDetails(participantID) + room := toMinimalRoomProto(roomID, roomName) ev := newTrackEvent(livekit.AnalyticsEventType_TRACK_SUBSCRIBED, room, participantID, track) ev.Publisher = publisher t.SendEvent(ctx, ev) @@ -331,6 +347,8 @@ func (t *telemetryService) TrackSubscribed( func (t *telemetryService) TrackSubscribeFailed( ctx context.Context, + roomID livekit.RoomID, + roomName livekit.RoomName, participantID livekit.ParticipantID, trackID livekit.TrackID, err error, @@ -339,7 +357,7 @@ func (t *telemetryService) TrackSubscribeFailed( t.enqueue(func() { prometheus.RecordTrackSubscribeFailure(err, isUserError) - room := t.getRoomDetails(participantID) + room := toMinimalRoomProto(roomID, roomName) ev := newTrackEvent(livekit.AnalyticsEventType_TRACK_SUBSCRIBE_FAILED, room, participantID, &livekit.TrackInfo{ Sid: string(trackID), }) @@ -350,6 +368,8 @@ func (t *telemetryService) TrackSubscribeFailed( func (t *telemetryService) TrackUnsubscribed( ctx context.Context, + roomID livekit.RoomID, + roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo, shouldSendEvent bool, @@ -358,7 +378,7 @@ func (t *telemetryService) TrackUnsubscribed( prometheus.RecordTrackUnsubscribed(track.Type.String()) if shouldSendEvent { - room := t.getRoomDetails(participantID) + room := toMinimalRoomProto(roomID, roomName) t.SendEvent(ctx, newTrackEvent(livekit.AnalyticsEventType_TRACK_UNSUBSCRIBED, room, participantID, track)) } }) @@ -366,6 +386,8 @@ func (t *telemetryService) TrackUnsubscribed( func (t *telemetryService) TrackUnpublished( ctx context.Context, + roomID livekit.RoomID, + roomName livekit.RoomName, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo, @@ -377,7 +399,7 @@ func (t *telemetryService) TrackUnpublished( return } - room := t.getRoomDetails(participantID) + room := toMinimalRoomProto(roomID, roomName) participant := &livekit.ParticipantInfo{ Sid: string(participantID), Identity: string(identity), @@ -395,28 +417,34 @@ func (t *telemetryService) TrackUnpublished( func (t *telemetryService) TrackMuted( ctx context.Context, + roomID livekit.RoomID, + roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo, ) { t.enqueue(func() { - room := t.getRoomDetails(participantID) + room := toMinimalRoomProto(roomID, roomName) t.SendEvent(ctx, newTrackEvent(livekit.AnalyticsEventType_TRACK_MUTED, room, participantID, track)) }) } func (t *telemetryService) TrackUnmuted( ctx context.Context, + roomID livekit.RoomID, + roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo, ) { t.enqueue(func() { - room := t.getRoomDetails(participantID) + room := toMinimalRoomProto(roomID, roomName) t.SendEvent(ctx, newTrackEvent(livekit.AnalyticsEventType_TRACK_UNMUTED, room, participantID, track)) }) } func (t *telemetryService) TrackPublishRTPStats( ctx context.Context, + roomID livekit.RoomID, + roomName livekit.RoomName, participantID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, @@ -424,7 +452,7 @@ func (t *telemetryService) TrackPublishRTPStats( stats *livekit.RTPStats, ) { t.enqueue(func() { - room := t.getRoomDetails(participantID) + room := toMinimalRoomProto(roomID, roomName) ev := newRoomEvent(livekit.AnalyticsEventType_TRACK_PUBLISH_STATS, room) ev.ParticipantId = string(participantID) ev.TrackId = string(trackID) @@ -437,13 +465,15 @@ func (t *telemetryService) TrackPublishRTPStats( func (t *telemetryService) TrackSubscribeRTPStats( ctx context.Context, + roomID livekit.RoomID, + roomName livekit.RoomName, participantID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, stats *livekit.RTPStats, ) { t.enqueue(func() { - room := t.getRoomDetails(participantID) + room := toMinimalRoomProto(roomID, roomName) ev := newRoomEvent(livekit.AnalyticsEventType_TRACK_SUBSCRIBE_STATS, room) ev.ParticipantId = string(participantID) ev.TrackId = string(trackID) @@ -560,19 +590,6 @@ func (t *telemetryService) Webhook(ctx context.Context, webhookInfo *livekit.Web }) } -// returns a livekit.Room with only name and sid filled out -// returns nil if room is not found -func (t *telemetryService) getRoomDetails(participantID livekit.ParticipantID) *livekit.Room { - if worker, ok := t.getWorker(participantID); ok { - return &livekit.Room{ - Sid: string(worker.roomID), - Name: string(worker.roomName), - } - } - - return nil -} - func newRoomEvent(event livekit.AnalyticsEventType, room *livekit.Room) *livekit.AnalyticsEvent { ev := &livekit.AnalyticsEvent{ Type: event, @@ -623,3 +640,10 @@ func newIngressEvent(event livekit.AnalyticsEventType, ingress *livekit.IngressI Ingress: ingress, } } + +func toMinimalRoomProto(roomID livekit.RoomID, roomName livekit.RoomName) *livekit.Room { + return &livekit.Room{ + Sid: string(roomID), + Name: string(roomName), + } +} diff --git a/pkg/telemetry/events_test.go b/pkg/telemetry/events_test.go index 0be7de176..c5bb0626c 100644 --- a/pkg/telemetry/events_test.go +++ b/pkg/telemetry/events_test.go @@ -103,6 +103,8 @@ func Test_OnTrackUpdate_EventIsSent(t *testing.T) { fixture := createFixture() // prepare + roomID := "room1" + roomName := "RoomName" partID := "part1" trackID := "track1" layer := &livekit.VideoLayer{ @@ -122,7 +124,7 @@ func Test_OnTrackUpdate_EventIsSent(t *testing.T) { } // do - fixture.sut.TrackPublishedUpdate(context.Background(), livekit.ParticipantID(partID), trackInfo) + fixture.sut.TrackPublishedUpdate(context.Background(), livekit.RoomID(roomID), livekit.RoomName(roomName), livekit.ParticipantID(partID), trackInfo) time.Sleep(time.Millisecond * 500) // test @@ -226,7 +228,7 @@ func Test_OnTrackSubscribed_EventIsSent(t *testing.T) { require.Equal(t, room, event.Room) // do - fixture.sut.TrackSubscribed(context.Background(), livekit.ParticipantID(partSID), trackInfo, publisherInfo, true) + fixture.sut.TrackSubscribed(context.Background(), livekit.RoomID(room.Sid), livekit.RoomName(room.Name), livekit.ParticipantID(partSID), trackInfo, publisherInfo, true) time.Sleep(time.Millisecond * 500) require.Eventually(t, func() bool { diff --git a/pkg/telemetry/stats.go b/pkg/telemetry/stats.go index 7ff082abb..56dc530e4 100644 --- a/pkg/telemetry/stats.go +++ b/pkg/telemetry/stats.go @@ -62,7 +62,7 @@ func StatsKeyForData( } } -func (t *telemetryService) TrackStats(key StatsKey, stat *livekit.AnalyticsStat) { +func (t *telemetryService) TrackStats(roomID livekit.RoomID, _roomName livekit.RoomName, key StatsKey, stat *livekit.AnalyticsStat) { t.enqueue(func() { direction := prometheus.Incoming if key.streamType == livekit.StreamType_DOWNSTREAM { @@ -107,7 +107,7 @@ func (t *telemetryService) TrackStats(key StatsKey, stat *livekit.AnalyticsStat) prometheus.IncrementBytes(key.country, direction, retransmitBytes, true) } - if worker, ok := t.getWorker(key.participantID); ok { + if worker, ok := t.getWorker(roomID, key.participantID); ok { worker.OnTrackStat(key.trackID, key.streamType, stat) } }) diff --git a/pkg/telemetry/stats_test.go b/pkg/telemetry/stats_test.go index 8db18df6a..eb70d048a 100644 --- a/pkg/telemetry/stats_test.go +++ b/pkg/telemetry/stats_test.go @@ -58,7 +58,7 @@ func Test_ParticipantAndRoomDataAreSentWithAnalytics(t *testing.T) { // do packet := 33 stat := &livekit.AnalyticsStat{Streams: []*livekit.AnalyticsStream{{PrimaryBytes: uint64(packet)}}} - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, ""), stat) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, ""), stat) // flush fixture.flush() @@ -77,7 +77,7 @@ func Test_OnDownstreamPackets(t *testing.T) { fixture := createFixture() // prepare - room := &livekit.Room{} + room := &livekit.Room{Sid: "RoomSid", Name: "RoomName"} partSID := livekit.ParticipantID("part1") clientInfo := &livekit.ClientInfo{Sdk: 2} participantInfo := &livekit.ParticipantInfo{Sid: string(partSID)} @@ -91,7 +91,7 @@ func Test_OnDownstreamPackets(t *testing.T) { trackID := livekit.TrackID("trackID") for i := range packets { stat := &livekit.AnalyticsStat{Streams: []*livekit.AnalyticsStream{{PrimaryBytes: uint64(packets[i]), PrimaryPackets: uint32(1)}}} - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID), stat) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID), stat) } // flush @@ -111,7 +111,7 @@ func Test_OnDownstreamPackets_SeveralTracks(t *testing.T) { fixture := createFixture() // prepare - room := &livekit.Room{} + room := &livekit.Room{Sid: "RoomSid", Name: "RoomName"} partSID := livekit.ParticipantID("part1") clientInfo := &livekit.ClientInfo{Sdk: 2} participantInfo := &livekit.ParticipantInfo{Sid: string(partSID)} @@ -122,12 +122,12 @@ func Test_OnDownstreamPackets_SeveralTracks(t *testing.T) { packet1 := 33 trackID1 := livekit.TrackID("trackID1") stat1 := &livekit.AnalyticsStat{Streams: []*livekit.AnalyticsStream{{PrimaryBytes: uint64(packet1), PrimaryPackets: 1}}} - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID1), stat1) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID1), stat1) packet2 := 23 trackID2 := livekit.TrackID("trackID2") stat2 := &livekit.AnalyticsStat{Streams: []*livekit.AnalyticsStream{{PrimaryBytes: uint64(packet2), PrimaryPackets: 1}}} - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID2), stat2) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID2), stat2) // flush fixture.flush() @@ -158,7 +158,7 @@ func Test_OnDownStreamStat(t *testing.T) { fixture := createFixture() // prepare - room := &livekit.Room{} + room := &livekit.Room{Sid: "RoomSid", Name: "RoomName"} partSID := livekit.ParticipantID("part1") participantInfo := &livekit.ParticipantInfo{Sid: string(partSID)} guard := &telemetry.ReferenceGuard{} @@ -179,7 +179,7 @@ func Test_OnDownStreamStat(t *testing.T) { }, } trackID := livekit.TrackID("trackID1") - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID), stat1) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID), stat1) stat2 := &livekit.AnalyticsStat{ Streams: []*livekit.AnalyticsStream{ @@ -195,7 +195,7 @@ func Test_OnDownStreamStat(t *testing.T) { }, }, } - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID), stat2) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID), stat2) // flush fixture.flush() @@ -218,7 +218,7 @@ func Test_PacketLostDiffShouldBeSentToTelemetry(t *testing.T) { fixture := createFixture() // prepare - room := &livekit.Room{} + room := &livekit.Room{Sid: "RoomSid", Name: "RoomName"} partSID := livekit.ParticipantID("part1") participantInfo := &livekit.ParticipantInfo{Sid: string(partSID)} guard := &telemetry.ReferenceGuard{} @@ -235,7 +235,7 @@ func Test_PacketLostDiffShouldBeSentToTelemetry(t *testing.T) { }, }, } - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID), stat1) // there should be bytes reported so that stats are sent + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID), stat1) // there should be bytes reported so that stats are sent // flush fixture.flush() @@ -249,7 +249,7 @@ func Test_PacketLostDiffShouldBeSentToTelemetry(t *testing.T) { }, }, } - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID), stat2) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID), stat2) // flush fixture.flush() @@ -271,7 +271,7 @@ func Test_OnDownStreamRTCP_SeveralTracks(t *testing.T) { fixture := createFixture() // prepare - room := &livekit.Room{} + room := &livekit.Room{Sid: "RoomSid", Name: "RoomName"} partSID := livekit.ParticipantID("part1") participantInfo := &livekit.ParticipantInfo{Sid: string(partSID)} guard := &telemetry.ReferenceGuard{} @@ -288,7 +288,7 @@ func Test_OnDownStreamRTCP_SeveralTracks(t *testing.T) { }, }, } - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID1), stat1) // there should be bytes reported so that stats are sent + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID1), stat1) // there should be bytes reported so that stats are sent stat2 := &livekit.AnalyticsStat{ Streams: []*livekit.AnalyticsStream{ @@ -299,7 +299,7 @@ func Test_OnDownStreamRTCP_SeveralTracks(t *testing.T) { }, }, } - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID1), stat2) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID1), stat2) stat3 := &livekit.AnalyticsStat{ Streams: []*livekit.AnalyticsStream{ @@ -310,7 +310,7 @@ func Test_OnDownStreamRTCP_SeveralTracks(t *testing.T) { }, }, } - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID2), stat3) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, trackID2), stat3) // flush fixture.flush() @@ -341,7 +341,7 @@ func Test_OnUpstreamStat(t *testing.T) { fixture := createFixture() // prepare - room := &livekit.Room{} + room := &livekit.Room{Sid: "RoomSid", Name: "RoomName"} partSID := livekit.ParticipantID("part1") participantInfo := &livekit.ParticipantInfo{Sid: string(partSID)} guard := &telemetry.ReferenceGuard{} @@ -364,7 +364,7 @@ func Test_OnUpstreamStat(t *testing.T) { } trackID := livekit.TrackID("trackID") - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID), stat1) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID), stat1) stat2 := &livekit.AnalyticsStat{ Streams: []*livekit.AnalyticsStream{ @@ -380,7 +380,7 @@ func Test_OnUpstreamStat(t *testing.T) { }, }, } - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID), stat2) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID), stat2) // flush fixture.flush() @@ -403,7 +403,7 @@ func Test_OnUpstreamRTCP_SeveralTracks(t *testing.T) { fixture := createFixture() // prepare - room := &livekit.Room{} + room := &livekit.Room{Sid: "RoomSid", Name: "RoomName"} partSID := livekit.ParticipantID("part1") identity := livekit.ParticipantIdentity("part1Identity") participantInfo := &livekit.ParticipantInfo{Sid: string(partSID), Identity: string(identity)} @@ -424,8 +424,8 @@ func Test_OnUpstreamRTCP_SeveralTracks(t *testing.T) { }, }, } - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID1), stat1) - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID2), stat1) // using same buffer is not correct but for test it is fine + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID1), stat1) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID2), stat1) // using same buffer is not correct but for test it is fine // do totalBytes++ @@ -439,7 +439,7 @@ func Test_OnUpstreamRTCP_SeveralTracks(t *testing.T) { }, }, } - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID1), stat2) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID1), stat2) stat3 := &livekit.AnalyticsStat{ Streams: []*livekit.AnalyticsStream{ @@ -450,7 +450,7 @@ func Test_OnUpstreamRTCP_SeveralTracks(t *testing.T) { }, }, } - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID2), stat3) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID2), stat3) // flush fixture.flush() @@ -479,7 +479,7 @@ func Test_OnUpstreamRTCP_SeveralTracks(t *testing.T) { require.True(t, found2) // remove 1 track - track stats were flushed above, so no more calls to SendStats - fixture.sut.TrackUnpublished(context.Background(), partSID, identity, &livekit.TrackInfo{Sid: string(trackID2)}, true) + fixture.sut.TrackUnpublished(context.Background(), livekit.RoomID(room.Sid), livekit.RoomName(room.Name), partSID, identity, &livekit.TrackInfo{Sid: string(trackID2)}, true) // flush fixture.flush() @@ -509,7 +509,7 @@ func Test_AddUpTrack(t *testing.T) { fixture := createFixture() // prepare - room := &livekit.Room{} + room := &livekit.Room{Sid: "RoomSid", Name: "RoomName"} partSID := livekit.ParticipantID("part1") participantInfo := &livekit.ParticipantInfo{Sid: string(partSID)} guard := &telemetry.ReferenceGuard{} @@ -528,7 +528,7 @@ func Test_AddUpTrack(t *testing.T) { }, } trackID := livekit.TrackID("trackID") - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID), stat) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID), stat) // flush fixture.flush() @@ -547,7 +547,7 @@ func Test_AddUpTrack_SeveralBuffers_Simulcast(t *testing.T) { fixture := createFixture() // prepare - room := &livekit.Room{} + room := &livekit.Room{Sid: "RoomSid", Name: "RoomName"} partSID := livekit.ParticipantID("part1") participantInfo := &livekit.ParticipantInfo{Sid: string(partSID)} guard := &telemetry.ReferenceGuard{} @@ -567,7 +567,7 @@ func Test_AddUpTrack_SeveralBuffers_Simulcast(t *testing.T) { }, }, } - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID), stat1) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, trackID), stat1) // flush fixture.flush() @@ -587,7 +587,7 @@ func Test_BothDownstreamAndUpstreamStatsAreSentTogether(t *testing.T) { fixture := createFixture() // prepare - room := &livekit.Room{} + room := &livekit.Room{Sid: "RoomSid", Name: "RoomName"} partSID := livekit.ParticipantID("part1") participantInfo := &livekit.ParticipantInfo{Sid: string(partSID)} guard := &telemetry.ReferenceGuard{} @@ -603,7 +603,7 @@ func Test_BothDownstreamAndUpstreamStatsAreSentTogether(t *testing.T) { }, }, } - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, "trackID"), stat1) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_UPSTREAM, partSID, "trackID"), stat1) // downstream bytes stat2 := &livekit.AnalyticsStat{ Streams: []*livekit.AnalyticsStream{ @@ -613,7 +613,7 @@ func Test_BothDownstreamAndUpstreamStatsAreSentTogether(t *testing.T) { }, }, } - fixture.sut.TrackStats(telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, "trackID1"), stat2) + fixture.sut.TrackStats(livekit.RoomID(room.Sid), livekit.RoomName(room.Name), telemetry.StatsKeyForData("test", livekit.StreamType_DOWNSTREAM, partSID, "trackID1"), stat2) // flush fixture.flush() diff --git a/pkg/telemetry/telemetryfakes/fake_telemetry_service.go b/pkg/telemetry/telemetryfakes/fake_telemetry_service.go index 855f80024..f8eecd7e2 100644 --- a/pkg/telemetry/telemetryfakes/fake_telemetry_service.go +++ b/pkg/telemetry/telemetryfakes/fake_telemetry_service.go @@ -169,119 +169,147 @@ type FakeTelemetryService struct { arg1 context.Context arg2 []*livekit.AnalyticsStat } - TrackMaxSubscribedVideoQualityStub func(context.Context, livekit.ParticipantID, *livekit.TrackInfo, mime.MimeType, livekit.VideoQuality) + TrackMaxSubscribedVideoQualityStub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo, mime.MimeType, livekit.VideoQuality) trackMaxSubscribedVideoQualityMutex sync.RWMutex trackMaxSubscribedVideoQualityArgsForCall []struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 *livekit.TrackInfo - arg4 mime.MimeType - arg5 livekit.VideoQuality + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 *livekit.TrackInfo + arg6 mime.MimeType + arg7 livekit.VideoQuality } - TrackMutedStub func(context.Context, livekit.ParticipantID, *livekit.TrackInfo) + TrackMutedStub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo) trackMutedMutex sync.RWMutex trackMutedArgsForCall []struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 *livekit.TrackInfo + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 *livekit.TrackInfo } - TrackPublishRTPStatsStub func(context.Context, livekit.ParticipantID, livekit.TrackID, mime.MimeType, int, *livekit.RTPStats) + TrackPublishRTPStatsStub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.TrackID, mime.MimeType, int, *livekit.RTPStats) trackPublishRTPStatsMutex sync.RWMutex trackPublishRTPStatsArgsForCall []struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 livekit.TrackID - arg4 mime.MimeType - arg5 int - arg6 *livekit.RTPStats + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 livekit.TrackID + arg6 mime.MimeType + arg7 int + arg8 *livekit.RTPStats } - TrackPublishRequestedStub func(context.Context, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo) + TrackPublishRequestedStub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo) trackPublishRequestedMutex sync.RWMutex trackPublishRequestedArgsForCall []struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 livekit.ParticipantIdentity - arg4 *livekit.TrackInfo + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 livekit.ParticipantIdentity + arg6 *livekit.TrackInfo } - TrackPublishedStub func(context.Context, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool) + TrackPublishedStub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool) trackPublishedMutex sync.RWMutex trackPublishedArgsForCall []struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 livekit.ParticipantIdentity - arg4 *livekit.TrackInfo - arg5 bool + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 livekit.ParticipantIdentity + arg6 *livekit.TrackInfo + arg7 bool } - TrackPublishedUpdateStub func(context.Context, livekit.ParticipantID, *livekit.TrackInfo) + TrackPublishedUpdateStub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo) trackPublishedUpdateMutex sync.RWMutex trackPublishedUpdateArgsForCall []struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 *livekit.TrackInfo + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 *livekit.TrackInfo } - TrackStatsStub func(telemetry.StatsKey, *livekit.AnalyticsStat) + TrackStatsStub func(livekit.RoomID, livekit.RoomName, telemetry.StatsKey, *livekit.AnalyticsStat) trackStatsMutex sync.RWMutex trackStatsArgsForCall []struct { - arg1 telemetry.StatsKey - arg2 *livekit.AnalyticsStat + arg1 livekit.RoomID + arg2 livekit.RoomName + arg3 telemetry.StatsKey + arg4 *livekit.AnalyticsStat } - TrackSubscribeFailedStub func(context.Context, livekit.ParticipantID, livekit.TrackID, error, bool) + TrackSubscribeFailedStub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.TrackID, error, bool) trackSubscribeFailedMutex sync.RWMutex trackSubscribeFailedArgsForCall []struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 livekit.TrackID - arg4 error - arg5 bool + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 livekit.TrackID + arg6 error + arg7 bool } - TrackSubscribeRTPStatsStub func(context.Context, livekit.ParticipantID, livekit.TrackID, mime.MimeType, *livekit.RTPStats) + TrackSubscribeRTPStatsStub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.TrackID, mime.MimeType, *livekit.RTPStats) trackSubscribeRTPStatsMutex sync.RWMutex trackSubscribeRTPStatsArgsForCall []struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 livekit.TrackID - arg4 mime.MimeType - arg5 *livekit.RTPStats + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 livekit.TrackID + arg6 mime.MimeType + arg7 *livekit.RTPStats } - TrackSubscribeRequestedStub func(context.Context, livekit.ParticipantID, *livekit.TrackInfo) + TrackSubscribeRequestedStub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo) trackSubscribeRequestedMutex sync.RWMutex trackSubscribeRequestedArgsForCall []struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 *livekit.TrackInfo + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 *livekit.TrackInfo } - TrackSubscribedStub func(context.Context, livekit.ParticipantID, *livekit.TrackInfo, *livekit.ParticipantInfo, bool) + TrackSubscribedStub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo, *livekit.ParticipantInfo, bool) trackSubscribedMutex sync.RWMutex trackSubscribedArgsForCall []struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 *livekit.TrackInfo - arg4 *livekit.ParticipantInfo - arg5 bool + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 *livekit.TrackInfo + arg6 *livekit.ParticipantInfo + arg7 bool } - TrackUnmutedStub func(context.Context, livekit.ParticipantID, *livekit.TrackInfo) + TrackUnmutedStub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo) trackUnmutedMutex sync.RWMutex trackUnmutedArgsForCall []struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 *livekit.TrackInfo + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 *livekit.TrackInfo } - TrackUnpublishedStub func(context.Context, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool) + TrackUnpublishedStub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool) trackUnpublishedMutex sync.RWMutex trackUnpublishedArgsForCall []struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 livekit.ParticipantIdentity - arg4 *livekit.TrackInfo - arg5 bool + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 livekit.ParticipantIdentity + arg6 *livekit.TrackInfo + arg7 bool } - TrackUnsubscribedStub func(context.Context, livekit.ParticipantID, *livekit.TrackInfo, bool) + TrackUnsubscribedStub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo, bool) trackUnsubscribedMutex sync.RWMutex trackUnsubscribedArgsForCall []struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 *livekit.TrackInfo - arg4 bool + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 *livekit.TrackInfo + arg6 bool } WebhookStub func(context.Context, *livekit.WebhookInfo) webhookMutex sync.RWMutex @@ -1092,20 +1120,22 @@ func (fake *FakeTelemetryService) SendStatsArgsForCall(i int) (context.Context, return argsForCall.arg1, argsForCall.arg2 } -func (fake *FakeTelemetryService) TrackMaxSubscribedVideoQuality(arg1 context.Context, arg2 livekit.ParticipantID, arg3 *livekit.TrackInfo, arg4 mime.MimeType, arg5 livekit.VideoQuality) { +func (fake *FakeTelemetryService) TrackMaxSubscribedVideoQuality(arg1 context.Context, arg2 livekit.RoomID, arg3 livekit.RoomName, arg4 livekit.ParticipantID, arg5 *livekit.TrackInfo, arg6 mime.MimeType, arg7 livekit.VideoQuality) { fake.trackMaxSubscribedVideoQualityMutex.Lock() fake.trackMaxSubscribedVideoQualityArgsForCall = append(fake.trackMaxSubscribedVideoQualityArgsForCall, struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 *livekit.TrackInfo - arg4 mime.MimeType - arg5 livekit.VideoQuality - }{arg1, arg2, arg3, arg4, arg5}) + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 *livekit.TrackInfo + arg6 mime.MimeType + arg7 livekit.VideoQuality + }{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) stub := fake.TrackMaxSubscribedVideoQualityStub - fake.recordInvocation("TrackMaxSubscribedVideoQuality", []interface{}{arg1, arg2, arg3, arg4, arg5}) + fake.recordInvocation("TrackMaxSubscribedVideoQuality", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) fake.trackMaxSubscribedVideoQualityMutex.Unlock() if stub != nil { - fake.TrackMaxSubscribedVideoQualityStub(arg1, arg2, arg3, arg4, arg5) + fake.TrackMaxSubscribedVideoQualityStub(arg1, arg2, arg3, arg4, arg5, arg6, arg7) } } @@ -1115,31 +1145,33 @@ func (fake *FakeTelemetryService) TrackMaxSubscribedVideoQualityCallCount() int return len(fake.trackMaxSubscribedVideoQualityArgsForCall) } -func (fake *FakeTelemetryService) TrackMaxSubscribedVideoQualityCalls(stub func(context.Context, livekit.ParticipantID, *livekit.TrackInfo, mime.MimeType, livekit.VideoQuality)) { +func (fake *FakeTelemetryService) TrackMaxSubscribedVideoQualityCalls(stub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo, mime.MimeType, livekit.VideoQuality)) { fake.trackMaxSubscribedVideoQualityMutex.Lock() defer fake.trackMaxSubscribedVideoQualityMutex.Unlock() fake.TrackMaxSubscribedVideoQualityStub = stub } -func (fake *FakeTelemetryService) TrackMaxSubscribedVideoQualityArgsForCall(i int) (context.Context, livekit.ParticipantID, *livekit.TrackInfo, mime.MimeType, livekit.VideoQuality) { +func (fake *FakeTelemetryService) TrackMaxSubscribedVideoQualityArgsForCall(i int) (context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo, mime.MimeType, livekit.VideoQuality) { fake.trackMaxSubscribedVideoQualityMutex.RLock() defer fake.trackMaxSubscribedVideoQualityMutex.RUnlock() argsForCall := fake.trackMaxSubscribedVideoQualityArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7 } -func (fake *FakeTelemetryService) TrackMuted(arg1 context.Context, arg2 livekit.ParticipantID, arg3 *livekit.TrackInfo) { +func (fake *FakeTelemetryService) TrackMuted(arg1 context.Context, arg2 livekit.RoomID, arg3 livekit.RoomName, arg4 livekit.ParticipantID, arg5 *livekit.TrackInfo) { fake.trackMutedMutex.Lock() fake.trackMutedArgsForCall = append(fake.trackMutedArgsForCall, struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 *livekit.TrackInfo - }{arg1, arg2, arg3}) + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 *livekit.TrackInfo + }{arg1, arg2, arg3, arg4, arg5}) stub := fake.TrackMutedStub - fake.recordInvocation("TrackMuted", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("TrackMuted", []interface{}{arg1, arg2, arg3, arg4, arg5}) fake.trackMutedMutex.Unlock() if stub != nil { - fake.TrackMutedStub(arg1, arg2, arg3) + fake.TrackMutedStub(arg1, arg2, arg3, arg4, arg5) } } @@ -1149,34 +1181,36 @@ func (fake *FakeTelemetryService) TrackMutedCallCount() int { return len(fake.trackMutedArgsForCall) } -func (fake *FakeTelemetryService) TrackMutedCalls(stub func(context.Context, livekit.ParticipantID, *livekit.TrackInfo)) { +func (fake *FakeTelemetryService) TrackMutedCalls(stub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo)) { fake.trackMutedMutex.Lock() defer fake.trackMutedMutex.Unlock() fake.TrackMutedStub = stub } -func (fake *FakeTelemetryService) TrackMutedArgsForCall(i int) (context.Context, livekit.ParticipantID, *livekit.TrackInfo) { +func (fake *FakeTelemetryService) TrackMutedArgsForCall(i int) (context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo) { fake.trackMutedMutex.RLock() defer fake.trackMutedMutex.RUnlock() argsForCall := fake.trackMutedArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 } -func (fake *FakeTelemetryService) TrackPublishRTPStats(arg1 context.Context, arg2 livekit.ParticipantID, arg3 livekit.TrackID, arg4 mime.MimeType, arg5 int, arg6 *livekit.RTPStats) { +func (fake *FakeTelemetryService) TrackPublishRTPStats(arg1 context.Context, arg2 livekit.RoomID, arg3 livekit.RoomName, arg4 livekit.ParticipantID, arg5 livekit.TrackID, arg6 mime.MimeType, arg7 int, arg8 *livekit.RTPStats) { fake.trackPublishRTPStatsMutex.Lock() fake.trackPublishRTPStatsArgsForCall = append(fake.trackPublishRTPStatsArgsForCall, struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 livekit.TrackID - arg4 mime.MimeType - arg5 int - arg6 *livekit.RTPStats - }{arg1, arg2, arg3, arg4, arg5, arg6}) + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 livekit.TrackID + arg6 mime.MimeType + arg7 int + arg8 *livekit.RTPStats + }{arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8}) stub := fake.TrackPublishRTPStatsStub - fake.recordInvocation("TrackPublishRTPStats", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6}) + fake.recordInvocation("TrackPublishRTPStats", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8}) fake.trackPublishRTPStatsMutex.Unlock() if stub != nil { - fake.TrackPublishRTPStatsStub(arg1, arg2, arg3, arg4, arg5, arg6) + fake.TrackPublishRTPStatsStub(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) } } @@ -1186,32 +1220,34 @@ func (fake *FakeTelemetryService) TrackPublishRTPStatsCallCount() int { return len(fake.trackPublishRTPStatsArgsForCall) } -func (fake *FakeTelemetryService) TrackPublishRTPStatsCalls(stub func(context.Context, livekit.ParticipantID, livekit.TrackID, mime.MimeType, int, *livekit.RTPStats)) { +func (fake *FakeTelemetryService) TrackPublishRTPStatsCalls(stub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.TrackID, mime.MimeType, int, *livekit.RTPStats)) { fake.trackPublishRTPStatsMutex.Lock() defer fake.trackPublishRTPStatsMutex.Unlock() fake.TrackPublishRTPStatsStub = stub } -func (fake *FakeTelemetryService) TrackPublishRTPStatsArgsForCall(i int) (context.Context, livekit.ParticipantID, livekit.TrackID, mime.MimeType, int, *livekit.RTPStats) { +func (fake *FakeTelemetryService) TrackPublishRTPStatsArgsForCall(i int) (context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.TrackID, mime.MimeType, int, *livekit.RTPStats) { fake.trackPublishRTPStatsMutex.RLock() defer fake.trackPublishRTPStatsMutex.RUnlock() argsForCall := fake.trackPublishRTPStatsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7, argsForCall.arg8 } -func (fake *FakeTelemetryService) TrackPublishRequested(arg1 context.Context, arg2 livekit.ParticipantID, arg3 livekit.ParticipantIdentity, arg4 *livekit.TrackInfo) { +func (fake *FakeTelemetryService) TrackPublishRequested(arg1 context.Context, arg2 livekit.RoomID, arg3 livekit.RoomName, arg4 livekit.ParticipantID, arg5 livekit.ParticipantIdentity, arg6 *livekit.TrackInfo) { fake.trackPublishRequestedMutex.Lock() fake.trackPublishRequestedArgsForCall = append(fake.trackPublishRequestedArgsForCall, struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 livekit.ParticipantIdentity - arg4 *livekit.TrackInfo - }{arg1, arg2, arg3, arg4}) + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 livekit.ParticipantIdentity + arg6 *livekit.TrackInfo + }{arg1, arg2, arg3, arg4, arg5, arg6}) stub := fake.TrackPublishRequestedStub - fake.recordInvocation("TrackPublishRequested", []interface{}{arg1, arg2, arg3, arg4}) + fake.recordInvocation("TrackPublishRequested", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6}) fake.trackPublishRequestedMutex.Unlock() if stub != nil { - fake.TrackPublishRequestedStub(arg1, arg2, arg3, arg4) + fake.TrackPublishRequestedStub(arg1, arg2, arg3, arg4, arg5, arg6) } } @@ -1221,33 +1257,35 @@ func (fake *FakeTelemetryService) TrackPublishRequestedCallCount() int { return len(fake.trackPublishRequestedArgsForCall) } -func (fake *FakeTelemetryService) TrackPublishRequestedCalls(stub func(context.Context, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo)) { +func (fake *FakeTelemetryService) TrackPublishRequestedCalls(stub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo)) { fake.trackPublishRequestedMutex.Lock() defer fake.trackPublishRequestedMutex.Unlock() fake.TrackPublishRequestedStub = stub } -func (fake *FakeTelemetryService) TrackPublishRequestedArgsForCall(i int) (context.Context, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo) { +func (fake *FakeTelemetryService) TrackPublishRequestedArgsForCall(i int) (context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo) { fake.trackPublishRequestedMutex.RLock() defer fake.trackPublishRequestedMutex.RUnlock() argsForCall := fake.trackPublishRequestedArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6 } -func (fake *FakeTelemetryService) TrackPublished(arg1 context.Context, arg2 livekit.ParticipantID, arg3 livekit.ParticipantIdentity, arg4 *livekit.TrackInfo, arg5 bool) { +func (fake *FakeTelemetryService) TrackPublished(arg1 context.Context, arg2 livekit.RoomID, arg3 livekit.RoomName, arg4 livekit.ParticipantID, arg5 livekit.ParticipantIdentity, arg6 *livekit.TrackInfo, arg7 bool) { fake.trackPublishedMutex.Lock() fake.trackPublishedArgsForCall = append(fake.trackPublishedArgsForCall, struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 livekit.ParticipantIdentity - arg4 *livekit.TrackInfo - arg5 bool - }{arg1, arg2, arg3, arg4, arg5}) + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 livekit.ParticipantIdentity + arg6 *livekit.TrackInfo + arg7 bool + }{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) stub := fake.TrackPublishedStub - fake.recordInvocation("TrackPublished", []interface{}{arg1, arg2, arg3, arg4, arg5}) + fake.recordInvocation("TrackPublished", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) fake.trackPublishedMutex.Unlock() if stub != nil { - fake.TrackPublishedStub(arg1, arg2, arg3, arg4, arg5) + fake.TrackPublishedStub(arg1, arg2, arg3, arg4, arg5, arg6, arg7) } } @@ -1257,31 +1295,33 @@ func (fake *FakeTelemetryService) TrackPublishedCallCount() int { return len(fake.trackPublishedArgsForCall) } -func (fake *FakeTelemetryService) TrackPublishedCalls(stub func(context.Context, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool)) { +func (fake *FakeTelemetryService) TrackPublishedCalls(stub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool)) { fake.trackPublishedMutex.Lock() defer fake.trackPublishedMutex.Unlock() fake.TrackPublishedStub = stub } -func (fake *FakeTelemetryService) TrackPublishedArgsForCall(i int) (context.Context, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool) { +func (fake *FakeTelemetryService) TrackPublishedArgsForCall(i int) (context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool) { fake.trackPublishedMutex.RLock() defer fake.trackPublishedMutex.RUnlock() argsForCall := fake.trackPublishedArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7 } -func (fake *FakeTelemetryService) TrackPublishedUpdate(arg1 context.Context, arg2 livekit.ParticipantID, arg3 *livekit.TrackInfo) { +func (fake *FakeTelemetryService) TrackPublishedUpdate(arg1 context.Context, arg2 livekit.RoomID, arg3 livekit.RoomName, arg4 livekit.ParticipantID, arg5 *livekit.TrackInfo) { fake.trackPublishedUpdateMutex.Lock() fake.trackPublishedUpdateArgsForCall = append(fake.trackPublishedUpdateArgsForCall, struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 *livekit.TrackInfo - }{arg1, arg2, arg3}) + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 *livekit.TrackInfo + }{arg1, arg2, arg3, arg4, arg5}) stub := fake.TrackPublishedUpdateStub - fake.recordInvocation("TrackPublishedUpdate", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("TrackPublishedUpdate", []interface{}{arg1, arg2, arg3, arg4, arg5}) fake.trackPublishedUpdateMutex.Unlock() if stub != nil { - fake.TrackPublishedUpdateStub(arg1, arg2, arg3) + fake.TrackPublishedUpdateStub(arg1, arg2, arg3, arg4, arg5) } } @@ -1291,30 +1331,32 @@ func (fake *FakeTelemetryService) TrackPublishedUpdateCallCount() int { return len(fake.trackPublishedUpdateArgsForCall) } -func (fake *FakeTelemetryService) TrackPublishedUpdateCalls(stub func(context.Context, livekit.ParticipantID, *livekit.TrackInfo)) { +func (fake *FakeTelemetryService) TrackPublishedUpdateCalls(stub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo)) { fake.trackPublishedUpdateMutex.Lock() defer fake.trackPublishedUpdateMutex.Unlock() fake.TrackPublishedUpdateStub = stub } -func (fake *FakeTelemetryService) TrackPublishedUpdateArgsForCall(i int) (context.Context, livekit.ParticipantID, *livekit.TrackInfo) { +func (fake *FakeTelemetryService) TrackPublishedUpdateArgsForCall(i int) (context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo) { fake.trackPublishedUpdateMutex.RLock() defer fake.trackPublishedUpdateMutex.RUnlock() argsForCall := fake.trackPublishedUpdateArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 } -func (fake *FakeTelemetryService) TrackStats(arg1 telemetry.StatsKey, arg2 *livekit.AnalyticsStat) { +func (fake *FakeTelemetryService) TrackStats(arg1 livekit.RoomID, arg2 livekit.RoomName, arg3 telemetry.StatsKey, arg4 *livekit.AnalyticsStat) { fake.trackStatsMutex.Lock() fake.trackStatsArgsForCall = append(fake.trackStatsArgsForCall, struct { - arg1 telemetry.StatsKey - arg2 *livekit.AnalyticsStat - }{arg1, arg2}) + arg1 livekit.RoomID + arg2 livekit.RoomName + arg3 telemetry.StatsKey + arg4 *livekit.AnalyticsStat + }{arg1, arg2, arg3, arg4}) stub := fake.TrackStatsStub - fake.recordInvocation("TrackStats", []interface{}{arg1, arg2}) + fake.recordInvocation("TrackStats", []interface{}{arg1, arg2, arg3, arg4}) fake.trackStatsMutex.Unlock() if stub != nil { - fake.TrackStatsStub(arg1, arg2) + fake.TrackStatsStub(arg1, arg2, arg3, arg4) } } @@ -1324,33 +1366,35 @@ func (fake *FakeTelemetryService) TrackStatsCallCount() int { return len(fake.trackStatsArgsForCall) } -func (fake *FakeTelemetryService) TrackStatsCalls(stub func(telemetry.StatsKey, *livekit.AnalyticsStat)) { +func (fake *FakeTelemetryService) TrackStatsCalls(stub func(livekit.RoomID, livekit.RoomName, telemetry.StatsKey, *livekit.AnalyticsStat)) { fake.trackStatsMutex.Lock() defer fake.trackStatsMutex.Unlock() fake.TrackStatsStub = stub } -func (fake *FakeTelemetryService) TrackStatsArgsForCall(i int) (telemetry.StatsKey, *livekit.AnalyticsStat) { +func (fake *FakeTelemetryService) TrackStatsArgsForCall(i int) (livekit.RoomID, livekit.RoomName, telemetry.StatsKey, *livekit.AnalyticsStat) { fake.trackStatsMutex.RLock() defer fake.trackStatsMutex.RUnlock() argsForCall := fake.trackStatsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 } -func (fake *FakeTelemetryService) TrackSubscribeFailed(arg1 context.Context, arg2 livekit.ParticipantID, arg3 livekit.TrackID, arg4 error, arg5 bool) { +func (fake *FakeTelemetryService) TrackSubscribeFailed(arg1 context.Context, arg2 livekit.RoomID, arg3 livekit.RoomName, arg4 livekit.ParticipantID, arg5 livekit.TrackID, arg6 error, arg7 bool) { fake.trackSubscribeFailedMutex.Lock() fake.trackSubscribeFailedArgsForCall = append(fake.trackSubscribeFailedArgsForCall, struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 livekit.TrackID - arg4 error - arg5 bool - }{arg1, arg2, arg3, arg4, arg5}) + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 livekit.TrackID + arg6 error + arg7 bool + }{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) stub := fake.TrackSubscribeFailedStub - fake.recordInvocation("TrackSubscribeFailed", []interface{}{arg1, arg2, arg3, arg4, arg5}) + fake.recordInvocation("TrackSubscribeFailed", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) fake.trackSubscribeFailedMutex.Unlock() if stub != nil { - fake.TrackSubscribeFailedStub(arg1, arg2, arg3, arg4, arg5) + fake.TrackSubscribeFailedStub(arg1, arg2, arg3, arg4, arg5, arg6, arg7) } } @@ -1360,33 +1404,35 @@ func (fake *FakeTelemetryService) TrackSubscribeFailedCallCount() int { return len(fake.trackSubscribeFailedArgsForCall) } -func (fake *FakeTelemetryService) TrackSubscribeFailedCalls(stub func(context.Context, livekit.ParticipantID, livekit.TrackID, error, bool)) { +func (fake *FakeTelemetryService) TrackSubscribeFailedCalls(stub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.TrackID, error, bool)) { fake.trackSubscribeFailedMutex.Lock() defer fake.trackSubscribeFailedMutex.Unlock() fake.TrackSubscribeFailedStub = stub } -func (fake *FakeTelemetryService) TrackSubscribeFailedArgsForCall(i int) (context.Context, livekit.ParticipantID, livekit.TrackID, error, bool) { +func (fake *FakeTelemetryService) TrackSubscribeFailedArgsForCall(i int) (context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.TrackID, error, bool) { fake.trackSubscribeFailedMutex.RLock() defer fake.trackSubscribeFailedMutex.RUnlock() argsForCall := fake.trackSubscribeFailedArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7 } -func (fake *FakeTelemetryService) TrackSubscribeRTPStats(arg1 context.Context, arg2 livekit.ParticipantID, arg3 livekit.TrackID, arg4 mime.MimeType, arg5 *livekit.RTPStats) { +func (fake *FakeTelemetryService) TrackSubscribeRTPStats(arg1 context.Context, arg2 livekit.RoomID, arg3 livekit.RoomName, arg4 livekit.ParticipantID, arg5 livekit.TrackID, arg6 mime.MimeType, arg7 *livekit.RTPStats) { fake.trackSubscribeRTPStatsMutex.Lock() fake.trackSubscribeRTPStatsArgsForCall = append(fake.trackSubscribeRTPStatsArgsForCall, struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 livekit.TrackID - arg4 mime.MimeType - arg5 *livekit.RTPStats - }{arg1, arg2, arg3, arg4, arg5}) + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 livekit.TrackID + arg6 mime.MimeType + arg7 *livekit.RTPStats + }{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) stub := fake.TrackSubscribeRTPStatsStub - fake.recordInvocation("TrackSubscribeRTPStats", []interface{}{arg1, arg2, arg3, arg4, arg5}) + fake.recordInvocation("TrackSubscribeRTPStats", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) fake.trackSubscribeRTPStatsMutex.Unlock() if stub != nil { - fake.TrackSubscribeRTPStatsStub(arg1, arg2, arg3, arg4, arg5) + fake.TrackSubscribeRTPStatsStub(arg1, arg2, arg3, arg4, arg5, arg6, arg7) } } @@ -1396,31 +1442,33 @@ func (fake *FakeTelemetryService) TrackSubscribeRTPStatsCallCount() int { return len(fake.trackSubscribeRTPStatsArgsForCall) } -func (fake *FakeTelemetryService) TrackSubscribeRTPStatsCalls(stub func(context.Context, livekit.ParticipantID, livekit.TrackID, mime.MimeType, *livekit.RTPStats)) { +func (fake *FakeTelemetryService) TrackSubscribeRTPStatsCalls(stub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.TrackID, mime.MimeType, *livekit.RTPStats)) { fake.trackSubscribeRTPStatsMutex.Lock() defer fake.trackSubscribeRTPStatsMutex.Unlock() fake.TrackSubscribeRTPStatsStub = stub } -func (fake *FakeTelemetryService) TrackSubscribeRTPStatsArgsForCall(i int) (context.Context, livekit.ParticipantID, livekit.TrackID, mime.MimeType, *livekit.RTPStats) { +func (fake *FakeTelemetryService) TrackSubscribeRTPStatsArgsForCall(i int) (context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.TrackID, mime.MimeType, *livekit.RTPStats) { fake.trackSubscribeRTPStatsMutex.RLock() defer fake.trackSubscribeRTPStatsMutex.RUnlock() argsForCall := fake.trackSubscribeRTPStatsArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7 } -func (fake *FakeTelemetryService) TrackSubscribeRequested(arg1 context.Context, arg2 livekit.ParticipantID, arg3 *livekit.TrackInfo) { +func (fake *FakeTelemetryService) TrackSubscribeRequested(arg1 context.Context, arg2 livekit.RoomID, arg3 livekit.RoomName, arg4 livekit.ParticipantID, arg5 *livekit.TrackInfo) { fake.trackSubscribeRequestedMutex.Lock() fake.trackSubscribeRequestedArgsForCall = append(fake.trackSubscribeRequestedArgsForCall, struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 *livekit.TrackInfo - }{arg1, arg2, arg3}) + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 *livekit.TrackInfo + }{arg1, arg2, arg3, arg4, arg5}) stub := fake.TrackSubscribeRequestedStub - fake.recordInvocation("TrackSubscribeRequested", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("TrackSubscribeRequested", []interface{}{arg1, arg2, arg3, arg4, arg5}) fake.trackSubscribeRequestedMutex.Unlock() if stub != nil { - fake.TrackSubscribeRequestedStub(arg1, arg2, arg3) + fake.TrackSubscribeRequestedStub(arg1, arg2, arg3, arg4, arg5) } } @@ -1430,33 +1478,35 @@ func (fake *FakeTelemetryService) TrackSubscribeRequestedCallCount() int { return len(fake.trackSubscribeRequestedArgsForCall) } -func (fake *FakeTelemetryService) TrackSubscribeRequestedCalls(stub func(context.Context, livekit.ParticipantID, *livekit.TrackInfo)) { +func (fake *FakeTelemetryService) TrackSubscribeRequestedCalls(stub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo)) { fake.trackSubscribeRequestedMutex.Lock() defer fake.trackSubscribeRequestedMutex.Unlock() fake.TrackSubscribeRequestedStub = stub } -func (fake *FakeTelemetryService) TrackSubscribeRequestedArgsForCall(i int) (context.Context, livekit.ParticipantID, *livekit.TrackInfo) { +func (fake *FakeTelemetryService) TrackSubscribeRequestedArgsForCall(i int) (context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo) { fake.trackSubscribeRequestedMutex.RLock() defer fake.trackSubscribeRequestedMutex.RUnlock() argsForCall := fake.trackSubscribeRequestedArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 } -func (fake *FakeTelemetryService) TrackSubscribed(arg1 context.Context, arg2 livekit.ParticipantID, arg3 *livekit.TrackInfo, arg4 *livekit.ParticipantInfo, arg5 bool) { +func (fake *FakeTelemetryService) TrackSubscribed(arg1 context.Context, arg2 livekit.RoomID, arg3 livekit.RoomName, arg4 livekit.ParticipantID, arg5 *livekit.TrackInfo, arg6 *livekit.ParticipantInfo, arg7 bool) { fake.trackSubscribedMutex.Lock() fake.trackSubscribedArgsForCall = append(fake.trackSubscribedArgsForCall, struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 *livekit.TrackInfo - arg4 *livekit.ParticipantInfo - arg5 bool - }{arg1, arg2, arg3, arg4, arg5}) + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 *livekit.TrackInfo + arg6 *livekit.ParticipantInfo + arg7 bool + }{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) stub := fake.TrackSubscribedStub - fake.recordInvocation("TrackSubscribed", []interface{}{arg1, arg2, arg3, arg4, arg5}) + fake.recordInvocation("TrackSubscribed", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) fake.trackSubscribedMutex.Unlock() if stub != nil { - fake.TrackSubscribedStub(arg1, arg2, arg3, arg4, arg5) + fake.TrackSubscribedStub(arg1, arg2, arg3, arg4, arg5, arg6, arg7) } } @@ -1466,31 +1516,33 @@ func (fake *FakeTelemetryService) TrackSubscribedCallCount() int { return len(fake.trackSubscribedArgsForCall) } -func (fake *FakeTelemetryService) TrackSubscribedCalls(stub func(context.Context, livekit.ParticipantID, *livekit.TrackInfo, *livekit.ParticipantInfo, bool)) { +func (fake *FakeTelemetryService) TrackSubscribedCalls(stub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo, *livekit.ParticipantInfo, bool)) { fake.trackSubscribedMutex.Lock() defer fake.trackSubscribedMutex.Unlock() fake.TrackSubscribedStub = stub } -func (fake *FakeTelemetryService) TrackSubscribedArgsForCall(i int) (context.Context, livekit.ParticipantID, *livekit.TrackInfo, *livekit.ParticipantInfo, bool) { +func (fake *FakeTelemetryService) TrackSubscribedArgsForCall(i int) (context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo, *livekit.ParticipantInfo, bool) { fake.trackSubscribedMutex.RLock() defer fake.trackSubscribedMutex.RUnlock() argsForCall := fake.trackSubscribedArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7 } -func (fake *FakeTelemetryService) TrackUnmuted(arg1 context.Context, arg2 livekit.ParticipantID, arg3 *livekit.TrackInfo) { +func (fake *FakeTelemetryService) TrackUnmuted(arg1 context.Context, arg2 livekit.RoomID, arg3 livekit.RoomName, arg4 livekit.ParticipantID, arg5 *livekit.TrackInfo) { fake.trackUnmutedMutex.Lock() fake.trackUnmutedArgsForCall = append(fake.trackUnmutedArgsForCall, struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 *livekit.TrackInfo - }{arg1, arg2, arg3}) + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 *livekit.TrackInfo + }{arg1, arg2, arg3, arg4, arg5}) stub := fake.TrackUnmutedStub - fake.recordInvocation("TrackUnmuted", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("TrackUnmuted", []interface{}{arg1, arg2, arg3, arg4, arg5}) fake.trackUnmutedMutex.Unlock() if stub != nil { - fake.TrackUnmutedStub(arg1, arg2, arg3) + fake.TrackUnmutedStub(arg1, arg2, arg3, arg4, arg5) } } @@ -1500,33 +1552,35 @@ func (fake *FakeTelemetryService) TrackUnmutedCallCount() int { return len(fake.trackUnmutedArgsForCall) } -func (fake *FakeTelemetryService) TrackUnmutedCalls(stub func(context.Context, livekit.ParticipantID, *livekit.TrackInfo)) { +func (fake *FakeTelemetryService) TrackUnmutedCalls(stub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo)) { fake.trackUnmutedMutex.Lock() defer fake.trackUnmutedMutex.Unlock() fake.TrackUnmutedStub = stub } -func (fake *FakeTelemetryService) TrackUnmutedArgsForCall(i int) (context.Context, livekit.ParticipantID, *livekit.TrackInfo) { +func (fake *FakeTelemetryService) TrackUnmutedArgsForCall(i int) (context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo) { fake.trackUnmutedMutex.RLock() defer fake.trackUnmutedMutex.RUnlock() argsForCall := fake.trackUnmutedArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 } -func (fake *FakeTelemetryService) TrackUnpublished(arg1 context.Context, arg2 livekit.ParticipantID, arg3 livekit.ParticipantIdentity, arg4 *livekit.TrackInfo, arg5 bool) { +func (fake *FakeTelemetryService) TrackUnpublished(arg1 context.Context, arg2 livekit.RoomID, arg3 livekit.RoomName, arg4 livekit.ParticipantID, arg5 livekit.ParticipantIdentity, arg6 *livekit.TrackInfo, arg7 bool) { fake.trackUnpublishedMutex.Lock() fake.trackUnpublishedArgsForCall = append(fake.trackUnpublishedArgsForCall, struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 livekit.ParticipantIdentity - arg4 *livekit.TrackInfo - arg5 bool - }{arg1, arg2, arg3, arg4, arg5}) + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 livekit.ParticipantIdentity + arg6 *livekit.TrackInfo + arg7 bool + }{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) stub := fake.TrackUnpublishedStub - fake.recordInvocation("TrackUnpublished", []interface{}{arg1, arg2, arg3, arg4, arg5}) + fake.recordInvocation("TrackUnpublished", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) fake.trackUnpublishedMutex.Unlock() if stub != nil { - fake.TrackUnpublishedStub(arg1, arg2, arg3, arg4, arg5) + fake.TrackUnpublishedStub(arg1, arg2, arg3, arg4, arg5, arg6, arg7) } } @@ -1536,32 +1590,34 @@ func (fake *FakeTelemetryService) TrackUnpublishedCallCount() int { return len(fake.trackUnpublishedArgsForCall) } -func (fake *FakeTelemetryService) TrackUnpublishedCalls(stub func(context.Context, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool)) { +func (fake *FakeTelemetryService) TrackUnpublishedCalls(stub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool)) { fake.trackUnpublishedMutex.Lock() defer fake.trackUnpublishedMutex.Unlock() fake.TrackUnpublishedStub = stub } -func (fake *FakeTelemetryService) TrackUnpublishedArgsForCall(i int) (context.Context, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool) { +func (fake *FakeTelemetryService) TrackUnpublishedArgsForCall(i int) (context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, livekit.ParticipantIdentity, *livekit.TrackInfo, bool) { fake.trackUnpublishedMutex.RLock() defer fake.trackUnpublishedMutex.RUnlock() argsForCall := fake.trackUnpublishedArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7 } -func (fake *FakeTelemetryService) TrackUnsubscribed(arg1 context.Context, arg2 livekit.ParticipantID, arg3 *livekit.TrackInfo, arg4 bool) { +func (fake *FakeTelemetryService) TrackUnsubscribed(arg1 context.Context, arg2 livekit.RoomID, arg3 livekit.RoomName, arg4 livekit.ParticipantID, arg5 *livekit.TrackInfo, arg6 bool) { fake.trackUnsubscribedMutex.Lock() fake.trackUnsubscribedArgsForCall = append(fake.trackUnsubscribedArgsForCall, struct { arg1 context.Context - arg2 livekit.ParticipantID - arg3 *livekit.TrackInfo - arg4 bool - }{arg1, arg2, arg3, arg4}) + arg2 livekit.RoomID + arg3 livekit.RoomName + arg4 livekit.ParticipantID + arg5 *livekit.TrackInfo + arg6 bool + }{arg1, arg2, arg3, arg4, arg5, arg6}) stub := fake.TrackUnsubscribedStub - fake.recordInvocation("TrackUnsubscribed", []interface{}{arg1, arg2, arg3, arg4}) + fake.recordInvocation("TrackUnsubscribed", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6}) fake.trackUnsubscribedMutex.Unlock() if stub != nil { - fake.TrackUnsubscribedStub(arg1, arg2, arg3, arg4) + fake.TrackUnsubscribedStub(arg1, arg2, arg3, arg4, arg5, arg6) } } @@ -1571,17 +1627,17 @@ func (fake *FakeTelemetryService) TrackUnsubscribedCallCount() int { return len(fake.trackUnsubscribedArgsForCall) } -func (fake *FakeTelemetryService) TrackUnsubscribedCalls(stub func(context.Context, livekit.ParticipantID, *livekit.TrackInfo, bool)) { +func (fake *FakeTelemetryService) TrackUnsubscribedCalls(stub func(context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo, bool)) { fake.trackUnsubscribedMutex.Lock() defer fake.trackUnsubscribedMutex.Unlock() fake.TrackUnsubscribedStub = stub } -func (fake *FakeTelemetryService) TrackUnsubscribedArgsForCall(i int) (context.Context, livekit.ParticipantID, *livekit.TrackInfo, bool) { +func (fake *FakeTelemetryService) TrackUnsubscribedArgsForCall(i int) (context.Context, livekit.RoomID, livekit.RoomName, livekit.ParticipantID, *livekit.TrackInfo, bool) { fake.trackUnsubscribedMutex.RLock() defer fake.trackUnsubscribedMutex.RUnlock() argsForCall := fake.trackUnsubscribedArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6 } func (fake *FakeTelemetryService) Webhook(arg1 context.Context, arg2 *livekit.WebhookInfo) { diff --git a/pkg/telemetry/telemetryservice.go b/pkg/telemetry/telemetryservice.go index a22a31a6a..3f861992f 100644 --- a/pkg/telemetry/telemetryservice.go +++ b/pkg/telemetry/telemetryservice.go @@ -31,11 +31,12 @@ import ( //counterfeiter:generate . TelemetryService type TelemetryService interface { // TrackStats is called periodically for each track in both directions (published/subscribed) - TrackStats(key StatsKey, stat *livekit.AnalyticsStat) + TrackStats(roomID livekit.RoomID, roomName livekit.RoomName, key StatsKey, stat *livekit.AnalyticsStat) // events RoomStarted(ctx context.Context, room *livekit.Room) RoomEnded(ctx context.Context, room *livekit.Room) + // ParticipantJoined - a participant establishes signal connection to a room ParticipantJoined(ctx context.Context, room *livekit.Room, participant *livekit.ParticipantInfo, clientInfo *livekit.ClientInfo, clientMeta *livekit.AnalyticsClientMeta, shouldSendEvent bool, guard *ReferenceGuard) // ParticipantActive - a participant establishes media connection @@ -45,40 +46,46 @@ type TelemetryService interface { // ParticipantLeft - the participant leaves the room, only sent if ParticipantActive has been called before ParticipantLeft(ctx context.Context, room *livekit.Room, participant *livekit.ParticipantInfo, shouldSendEvent bool, guard *ReferenceGuard) // TrackPublishRequested - a publication attempt has been received - TrackPublishRequested(ctx context.Context, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo) + TrackPublishRequested(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo) // TrackPublished - a publication attempt has been successful - TrackPublished(ctx context.Context, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo, shouldSendEvent bool) + TrackPublished(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo, shouldSendEvent bool) // TrackUnpublished - a participant unpublished a track - TrackUnpublished(ctx context.Context, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo, shouldSendEvent bool) + TrackUnpublished(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo, shouldSendEvent bool) // TrackSubscribeRequested - a participant requested to subscribe to a track - TrackSubscribeRequested(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo) + TrackSubscribeRequested(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo) // TrackSubscribed - a participant subscribed to a track successfully - TrackSubscribed(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo, publisher *livekit.ParticipantInfo, shouldSendEvent bool) + TrackSubscribed(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo, publisher *livekit.ParticipantInfo, shouldSendEvent bool) // TrackUnsubscribed - a participant unsubscribed from a track successfully - TrackUnsubscribed(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo, shouldSendEvent bool) + TrackUnsubscribed(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo, shouldSendEvent bool) // TrackSubscribeFailed - failure to subscribe to a track - TrackSubscribeFailed(ctx context.Context, participantID livekit.ParticipantID, trackID livekit.TrackID, err error, isUserError bool) + TrackSubscribeFailed(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, trackID livekit.TrackID, err error, isUserError bool) // TrackMuted - the publisher has muted the Track - TrackMuted(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo) + TrackMuted(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo) // TrackUnmuted - the publisher has muted the Track - TrackUnmuted(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo) + TrackUnmuted(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo) // TrackPublishedUpdate - track metadata has been updated - TrackPublishedUpdate(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo) + TrackPublishedUpdate(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo) // TrackMaxSubscribedVideoQuality - publisher is notified of the max quality subscribers desire - TrackMaxSubscribedVideoQuality(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo, mime mime.MimeType, maxQuality livekit.VideoQuality) - TrackPublishRTPStats(ctx context.Context, participantID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, layer int, stats *livekit.RTPStats) - TrackSubscribeRTPStats(ctx context.Context, participantID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, stats *livekit.RTPStats) + TrackMaxSubscribedVideoQuality(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo, mime mime.MimeType, maxQuality livekit.VideoQuality) + TrackPublishRTPStats(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, layer int, stats *livekit.RTPStats) + TrackSubscribeRTPStats(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, stats *livekit.RTPStats) + EgressStarted(ctx context.Context, info *livekit.EgressInfo) EgressUpdated(ctx context.Context, info *livekit.EgressInfo) EgressEnded(ctx context.Context, info *livekit.EgressInfo) + IngressCreated(ctx context.Context, info *livekit.IngressInfo) IngressDeleted(ctx context.Context, info *livekit.IngressInfo) IngressStarted(ctx context.Context, info *livekit.IngressInfo) IngressUpdated(ctx context.Context, info *livekit.IngressInfo) IngressEnded(ctx context.Context, info *livekit.IngressInfo) + LocalRoomState(ctx context.Context, info *livekit.AnalyticsNodeRooms) + Report(ctx context.Context, reportInfo *livekit.ReportInfo) + APICall(ctx context.Context, apiCallInfo *livekit.APICallInfo) + Webhook(ctx context.Context, webhookInfo *livekit.WebhookInfo) // helpers @@ -95,9 +102,10 @@ type NullTelemetryService struct { NullAnalyticService } -func (n NullTelemetryService) TrackStats(key StatsKey, stat *livekit.AnalyticsStat) {} -func (n NullTelemetryService) RoomStarted(ctx context.Context, room *livekit.Room) {} -func (n NullTelemetryService) RoomEnded(ctx context.Context, room *livekit.Room) {} +func (n NullTelemetryService) TrackStats(roomID livekit.RoomID, roomName livekit.RoomName, key StatsKey, stat *livekit.AnalyticsStat) { +} +func (n NullTelemetryService) RoomStarted(ctx context.Context, room *livekit.Room) {} +func (n NullTelemetryService) RoomEnded(ctx context.Context, room *livekit.Room) {} func (n NullTelemetryService) ParticipantJoined(ctx context.Context, room *livekit.Room, participant *livekit.ParticipantInfo, clientInfo *livekit.ClientInfo, clientMeta *livekit.AnalyticsClientMeta, shouldSendEvent bool, guard *ReferenceGuard) { } func (n NullTelemetryService) ParticipantActive(ctx context.Context, room *livekit.Room, participant *livekit.ParticipantInfo, clientMeta *livekit.AnalyticsClientMeta, isMigration bool, guard *ReferenceGuard) { @@ -106,31 +114,31 @@ func (n NullTelemetryService) ParticipantResumed(ctx context.Context, room *live } func (n NullTelemetryService) ParticipantLeft(ctx context.Context, room *livekit.Room, participant *livekit.ParticipantInfo, shouldSendEvent bool, guard *ReferenceGuard) { } -func (n NullTelemetryService) TrackPublishRequested(ctx context.Context, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo) { +func (n NullTelemetryService) TrackPublishRequested(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo) { } -func (n NullTelemetryService) TrackPublished(ctx context.Context, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo, shouldSendEvent bool) { +func (n NullTelemetryService) TrackPublished(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo, shouldSendEvent bool) { } -func (n NullTelemetryService) TrackUnpublished(ctx context.Context, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo, shouldSendEvent bool) { +func (n NullTelemetryService) TrackUnpublished(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, identity livekit.ParticipantIdentity, track *livekit.TrackInfo, shouldSendEvent bool) { } -func (n NullTelemetryService) TrackSubscribeRequested(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo) { +func (n NullTelemetryService) TrackSubscribeRequested(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo) { } -func (n NullTelemetryService) TrackSubscribed(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo, publisher *livekit.ParticipantInfo, shouldSendEvent bool) { +func (n NullTelemetryService) TrackSubscribed(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo, publisher *livekit.ParticipantInfo, shouldSendEvent bool) { } -func (n NullTelemetryService) TrackUnsubscribed(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo, shouldSendEvent bool) { +func (n NullTelemetryService) TrackUnsubscribed(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo, shouldSendEvent bool) { } -func (n NullTelemetryService) TrackSubscribeFailed(ctx context.Context, participantID livekit.ParticipantID, trackID livekit.TrackID, err error, isUserError bool) { +func (n NullTelemetryService) TrackSubscribeFailed(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, trackID livekit.TrackID, err error, isUserError bool) { } -func (n NullTelemetryService) TrackMuted(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo) { +func (n NullTelemetryService) TrackMuted(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo) { } -func (n NullTelemetryService) TrackUnmuted(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo) { +func (n NullTelemetryService) TrackUnmuted(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo) { } -func (n NullTelemetryService) TrackPublishedUpdate(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo) { +func (n NullTelemetryService) TrackPublishedUpdate(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo) { } -func (n NullTelemetryService) TrackMaxSubscribedVideoQuality(ctx context.Context, participantID livekit.ParticipantID, track *livekit.TrackInfo, mime mime.MimeType, maxQuality livekit.VideoQuality) { +func (n NullTelemetryService) TrackMaxSubscribedVideoQuality(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, track *livekit.TrackInfo, mime mime.MimeType, maxQuality livekit.VideoQuality) { } -func (n NullTelemetryService) TrackPublishRTPStats(ctx context.Context, participantID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, layer int, stats *livekit.RTPStats) { +func (n NullTelemetryService) TrackPublishRTPStats(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, layer int, stats *livekit.RTPStats) { } -func (n NullTelemetryService) TrackSubscribeRTPStats(ctx context.Context, participantID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, stats *livekit.RTPStats) { +func (n NullTelemetryService) TrackSubscribeRTPStats(ctx context.Context, roomID livekit.RoomID, roomName livekit.RoomName, participantID livekit.ParticipantID, trackID livekit.TrackID, mimeType mime.MimeType, stats *livekit.RTPStats) { } func (n NullTelemetryService) EgressStarted(ctx context.Context, info *livekit.EgressInfo) {} func (n NullTelemetryService) EgressUpdated(ctx context.Context, info *livekit.EgressInfo) {} @@ -157,6 +165,11 @@ const ( telemetryStatsUpdateInterval = time.Second * 30 ) +type statsWorkerKey struct { + roomID livekit.RoomID + participantID livekit.ParticipantID +} + type telemetryService struct { AnalyticsService @@ -164,7 +177,7 @@ type telemetryService struct { jobsQueue *utils.OpsQueue workersMu sync.RWMutex - workers map[livekit.ParticipantID]*StatsWorker + workers map[statsWorkerKey]*StatsWorker workerList *StatsWorker flushMu sync.Mutex @@ -180,7 +193,7 @@ func NewTelemetryService(notifier webhook.QueuedNotifier, analytics AnalyticsSer FlushOnStop: true, Logger: logger.GetLogger(), }), - workers: make(map[livekit.ParticipantID]*StatsWorker), + workers: make(map[statsWorkerKey]*StatsWorker), } if t.notifier != nil { t.notifier.RegisterProcessedHook(func(ctx context.Context, whi *livekit.WebhookInfo) { @@ -234,8 +247,9 @@ func (t *telemetryService) FlushStats() { if reap != nil { t.workersMu.Lock() for reap != nil { - if reap == t.workers[reap.participantID] { - delete(t.workers, reap.participantID) + key := statsWorkerKey{reap.roomID, reap.participantID} + if reap == t.workers[key] { + delete(t.workers, key) } reap = reap.next } @@ -253,11 +267,11 @@ func (t *telemetryService) enqueue(op func()) { t.jobsQueue.Enqueue(op) } -func (t *telemetryService) getWorker(participantID livekit.ParticipantID) (worker *StatsWorker, ok bool) { +func (t *telemetryService) getWorker(roomID livekit.RoomID, participantID livekit.ParticipantID) (worker *StatsWorker, ok bool) { t.workersMu.RLock() defer t.workersMu.RUnlock() - worker, ok = t.workers[participantID] + worker, ok = t.workers[statsWorkerKey{roomID, participantID}] return } @@ -272,7 +286,8 @@ func (t *telemetryService) getOrCreateWorker( t.workersMu.Lock() defer t.workersMu.Unlock() - worker, ok := t.workers[participantID] + key := statsWorkerKey{roomID, participantID} + worker, ok := t.workers[key] if ok && !worker.Closed(guard) { return worker, true } @@ -295,7 +310,7 @@ func (t *telemetryService) getOrCreateWorker( worker.SetConnected() } - t.workers[participantID] = worker + t.workers[key] = worker worker.next = t.workerList t.workerList = worker