mediasoup 3.23.2 → 3.24.0

package/worker/src/RTC/RateCalculator.cpp

@@ -30,9 +30,9 @@ namespace RTC
 		MS_TRACE();
 
 		// Ignore too old data. Should never happen.
-		if (this->oldestItemStartTime.has_value() && Utils::Number::IsLowerThan<uint64_t>(nowMs, *this->oldestItemStartTime))
+		if (this->oldestItemStartTimeMs.has_value() && Utils::Number::IsLowerThan<uint64_t>(nowMs, *this->oldestItemStartTimeMs))
 		{
-			MS_WARN_DEV("nowMs < this->oldestItemStartTime, should never happen");
+			MS_WARN_DEV("nowMs < this->oldestItemStartTimeMs, should never happen");
 
 			return;
 		}
@@ -45,12 +45,12 @@ namespace RTC
 		// If the elapsed time from the newest item start time is greater than the
 		// item size (in milliseconds), increase the item index.
 		if (
-		  this->newestItemIndex < 0 || !this->newestItemStartTime.has_value() ||
+		  this->newestItemIndex < 0 || !this->newestItemStartTimeMs.has_value() ||
 		  Utils::Number::IsHigherOrEqualThan<uint64_t>(
-		    nowMs - *this->newestItemStartTime, this->itemSizeMs))
+		    nowMs - *this->newestItemStartTimeMs, this->itemSizeMs))
 		{
 			this->newestItemIndex++;
-			this->newestItemStartTime = nowMs;
+			this->newestItemStartTimeMs = nowMs;
 
 			if (this->newestItemIndex >= this->windowItems)
 			{
@@ -79,13 +79,15 @@ namespace RTC
 
 			// Set the newest item.
 			BufferItem& item = this->buffer[this->newestItemIndex];
-			item.count       = size;
-			item.time        = nowMs;
+
+			item.count  = size;
+			item.timeMs = nowMs;
 		}
 		else
 		{
 			// Update the newest item.
 			BufferItem& item = this->buffer[this->newestItemIndex];
+
 			item.count += size;
 		}
 
@@ -93,27 +95,27 @@ namespace RTC
 		if (this->oldestItemIndex < 0)
 		{
 			MS_DEBUG_DEV(
-			  "this->oldestItemIndex < 0, setting this->oldestItemIndex and this->oldestItemStartTime");
+			  "this->oldestItemIndex < 0, setting this->oldestItemIndex and this->oldestItemStartTimeMs");
 
-			this->oldestItemIndex     = this->newestItemIndex;
-			this->oldestItemStartTime = nowMs;
+			this->oldestItemIndex       = this->newestItemIndex;
+			this->oldestItemStartTimeMs = nowMs;
 		}
 
 		this->totalCount += size;
 
-		// Reset lastRate and lastTime so GetRate() will calculate rate again even
-		// if called with same now in the same loop iteration.
-		this->lastRate = 0;
-		this->lastTime = std::nullopt;
+		// Reset `lastRate` and `lastTimeMs` so `GetRate()` will calculate rate
+		// again even if called with same now in the same loop iteration.
+		this->lastRate   = 0;
+		this->lastTimeMs = std::nullopt;
 	}
 
 	uint32_t RateCalculator::GetRate(uint64_t nowMs)
 	{
 		MS_TRACE();
 
-		if (this->lastTime.has_value() && nowMs == *this->lastTime)
+		if (this->lastTimeMs.has_value() && nowMs == *this->lastTimeMs)
 		{
-			MS_DEBUG_DEV("nowMs == this->lastTime, early return");
+			MS_DEBUG_DEV("nowMs == this->lastTimeMs, early return");
 
 			return this->lastRate;
 		}
@@ -122,8 +124,8 @@ namespace RTC
 
 		const float scale = this->scale / this->windowSizeMs;
 
-		this->lastTime = nowMs;
-		this->lastRate = static_cast<uint32_t>(std::trunc((this->totalCount * scale) + 0.5f));
+		this->lastTimeMs = nowMs;
+		this->lastRate   = static_cast<uint32_t>(std::trunc((this->totalCount * scale) + 0.5f));
 
 		return this->lastRate;
 	}
@@ -137,20 +139,20 @@ namespace RTC
 		  0,
 		  sizeof(BufferItem) * this->buffer.size());
 
-		this->newestItemStartTime = std::nullopt;
-		this->newestItemIndex     = -1;
-		this->oldestItemStartTime = std::nullopt;
-		this->oldestItemIndex     = -1;
-		this->totalCount          = 0u;
-		this->lastRate            = 0u;
-		this->lastTime            = std::nullopt;
+		this->newestItemStartTimeMs = std::nullopt;
+		this->newestItemIndex       = -1;
+		this->oldestItemStartTimeMs = std::nullopt;
+		this->oldestItemIndex       = -1;
+		this->totalCount            = 0u;
+		this->lastRate              = 0u;
+		this->lastTimeMs            = std::nullopt;
 	}
 
 	void RateCalculator::RemoveOldData(uint64_t nowMs)
 	{
 		MS_TRACE();
 
-		if (!this->oldestItemStartTime.has_value())
+		if (!this->oldestItemStartTimeMs.has_value())
 		{
 			return;
 		}
@@ -164,29 +166,31 @@ namespace RTC
 		const uint64_t newOldestTime = nowMs - this->windowSizeMs;
 
 		// Oldest item already removed.
-		if (Utils::Number::IsLowerThan<uint64_t>(newOldestTime, *this->oldestItemStartTime))
+		if (Utils::Number::IsLowerThan<uint64_t>(newOldestTime, *this->oldestItemStartTimeMs))
 		{
 			return;
 		}
 
 		// A whole window size time has elapsed since last entry. Reset the buffer.
 		if (
-		  this->newestItemStartTime.has_value() &&
-		  Utils::Number::IsHigherOrEqualThan<uint64_t>(newOldestTime, *this->newestItemStartTime))
+		  this->newestItemStartTimeMs.has_value() &&
+		  Utils::Number::IsHigherOrEqualThan<uint64_t>(newOldestTime, *this->newestItemStartTimeMs))
 		{
-			MS_DEBUG_DEV("newOldestTime >= this->newestItemStartTime, resetting the buffer");
+			MS_DEBUG_DEV("newOldestTime >= this->newestItemStartTimeMs, resetting the buffer");
 
 			Reset();
 
 			return;
 		}
 
-		while (Utils::Number::IsHigherOrEqualThan<uint64_t>(newOldestTime, *this->oldestItemStartTime))
+		while (Utils::Number::IsHigherOrEqualThan<uint64_t>(newOldestTime, *this->oldestItemStartTimeMs))
 		{
 			BufferItem& oldestItem = this->buffer[this->oldestItemIndex];
+
 			this->totalCount -= oldestItem.count;
-			oldestItem.count = 0u;
-			oldestItem.time  = 0u;
+
+			oldestItem.count  = 0u;
+			oldestItem.timeMs = 0u;
 
 			if (++this->oldestItemIndex >= this->windowItems)
 			{
@@ -194,19 +198,20 @@ namespace RTC
 			}
 
 			const BufferItem& newOldestItem = this->buffer[this->oldestItemIndex];
-			this->oldestItemStartTime       = newOldestItem.time;
+
+			this->oldestItemStartTimeMs = newOldestItem.timeMs;
 		}
 	}
 
 	void RtpDataCounter::Update(const RTC::RTP::Packet* packet)
 	{
+		MS_TRACE();
+
 		this->packets++;
 
 		if (!this->ignorePaddingOnlyPackets || packet->GetPayloadLength() > 0)
 		{
-			const uint64_t nowMs = this->shared->GetTimeMs();
-
-			this->rate.Update(packet->GetLength(), nowMs);
+			this->rate.Update(packet->GetLength(), this->shared->GetTimeMs());
 		}
 	}
 } // namespace RTC

package/worker/src/RTC/Router.cpp

@@ -910,7 +910,8 @@ namespace RTC
 	  RTC::DataProducer* dataProducer,
 	  RTC::SCTP::Message message,
 	  std::vector<uint16_t>& subchannels,
-	  std::optional<uint16_t> requiredSubchannel)
+	  std::optional<uint16_t> requiredSubchannel,
+	  std::optional<uint16_t> ignoredSubchannel)
 	{
 		MS_TRACE();
 
@@ -936,7 +937,8 @@ namespace RTC
 					// NOLINTNEXTLINE(clang-analyzer-cplusplus.Move, bugprone-use-after-move, hicpp-invalid-access-moved)
 					message.SetStreamId(streamId);
 
-					dataConsumer->SendMessage(std::move(message), subchannels, requiredSubchannel);
+					dataConsumer->SendMessage(
+					  std::move(message), subchannels, requiredSubchannel, ignoredSubchannel);
 				}
 				// NOTE: Here we are cloning the message before passing it to each
 				// DataConsumer because each DataConsumer will pass std::move(message)
@@ -949,7 +951,8 @@ namespace RTC
 					// DataConsumer.
 					clonedMessage.SetStreamId(streamId);
 
-					dataConsumer->SendMessage(std::move(clonedMessage), subchannels, requiredSubchannel);
+					dataConsumer->SendMessage(
+					  std::move(clonedMessage), subchannels, requiredSubchannel, ignoredSubchannel);
 				}
 			}
 		}
@@ -1063,12 +1066,16 @@ namespace RTC
 
 	void Router::OnRtpObserverAddProducer(RTC::RtpObserver* rtpObserver, RTC::Producer* producer)
 	{
+		MS_TRACE();
+
 		// Add to the map.
 		this->mapProducerRtpObservers[producer].insert(rtpObserver);
 	}
 
 	void Router::OnRtpObserverRemoveProducer(RTC::RtpObserver* rtpObserver, RTC::Producer* producer)
 	{
+		MS_TRACE();
+
 		// Remove from the map.
 		this->mapProducerRtpObservers[producer].erase(rtpObserver);
 	}
@@ -1076,6 +1083,8 @@ namespace RTC
 	RTC::Producer* Router::RtpObserverGetProducer(
 	  RTC::RtpObserver* /* rtpObserver */, const std::string& id)
 	{
+		MS_TRACE();
+
 		const auto it = this->mapProducers.find(id);
 
 		if (it == this->mapProducers.end())

package/worker/src/RTC/RtpDictionaries/RtpHeaderExtensionUri.cpp

@@ -1,6 +1,7 @@
 #define MS_CLASS "RTC::RtpHeaderExtensionUri"
 // #define MS_LOG_DEV_LEVEL 3
 
+#include "Logger.hpp"
 #include "RTC/RtpDictionaries.hpp"
 
 namespace RTC
@@ -10,6 +11,8 @@ namespace RTC
 	RtpHeaderExtensionUri::Type RtpHeaderExtensionUri::TypeFromFbs(
 	  FBS::RtpParameters::RtpHeaderExtensionUri uri)
 	{
+		MS_TRACE();
+
 		switch (uri)
 		{
 			case FBS::RtpParameters::RtpHeaderExtensionUri::Mid:
@@ -79,6 +82,8 @@ namespace RTC
 	FBS::RtpParameters::RtpHeaderExtensionUri RtpHeaderExtensionUri::TypeToFbs(
 	  RtpHeaderExtensionUri::Type uri)
 	{
+		MS_TRACE();
+
 		switch (uri)
 		{
 			case RtpHeaderExtensionUri::Type::MID:

package/worker/src/RTC/RtpDictionaries/RtpParameters.cpp

@@ -308,6 +308,8 @@ namespace RTC
 
 	void RtpParameters::ValidateEncodings()
 	{
+		MS_TRACE();
+
 		uint8_t firstMediaPayloadType{ 0 };
 
 		{

package/worker/src/RTC/SCTP/association/Association.cpp

@@ -345,6 +345,8 @@ namespace RTC
 
 		std::optional<AssociationMetrics> Association::MakeMetrics() const
 		{
+			MS_TRACE();
+
 			if (!this->tcb)
 			{
 				return std::nullopt;

package/worker/src/RTC/SCTP/rx/DataTracker.cpp

@@ -176,6 +176,8 @@ namespace RTC
 
 		bool DataTracker::HandleForwardTsn(uint32_t newCumulativeTsn)
 		{
+			MS_TRACE();
+
 			// Forward-TSN is sent to make the receiver (this association) "forget"
 			// about partly received (or not received at all) data, up until
 			// `newCumulativeTsn`.

package/worker/src/RTC/SeqManager.cpp

@@ -11,24 +11,32 @@ namespace RTC
 	template<typename T, uint8_t N>
 	bool SeqManager<T, N>::SeqLowerThan::operator()(T lhs, T rhs) const
 	{
+		MS_TRACE();
+
 		return Utils::Number::IsLowerThan<T, N>(lhs, rhs);
 	}
 
 	template<typename T, uint8_t N>
 	bool SeqManager<T, N>::SeqHigherThan::operator()(T lhs, T rhs) const
 	{
+		MS_TRACE();
+
 		return Utils::Number::IsHigherThan<T, N>(lhs, rhs);
 	}
 
 	template<typename T, uint8_t N>
 	bool SeqManager<T, N>::IsSeqHigherThan(T lhs, T rhs)
 	{
+		MS_TRACE();
+
 		return Utils::Number::IsHigherThan<T, N>(lhs, rhs);
 	}
 
 	template<typename T, uint8_t N>
 	bool SeqManager<T, N>::IsSeqLowerThan(T lhs, T rhs)
 	{
+		MS_TRACE();
+
 		return Utils::Number::IsLowerThan<T, N>(lhs, rhs);
 	}
 
@@ -179,12 +187,16 @@ namespace RTC
 	template<typename T, uint8_t N>
 	T SeqManager<T, N>::GetMaxInput() const
 	{
+		MS_TRACE();
+
 		return this->maxInput;
 	}
 
 	template<typename T, uint8_t N>
 	T SeqManager<T, N>::GetMaxOutput() const
 	{
+		MS_TRACE();
+
 		// 'maxOutput' is stored in the offset-less space (as 'base' and comparisons
 		// use it), so apply 'initialOutput' here, just like `Input()` does before
 		// returning the output to the caller.

package/worker/src/RTC/SrtpSession.cpp

@@ -17,6 +17,8 @@ namespace RTC
 
 	void SrtpSession::ClassInit()
 	{
+		MS_TRACE();
+
 		// Set libsrtp event handler.
 		const srtp_err_status_t err =
 		  srtp_install_event_handler(static_cast<srtp_event_handler_func_t*>(OnSrtpEvent));
@@ -30,6 +32,8 @@ namespace RTC
 
 	FBS::SrtpParameters::SrtpCryptoSuite SrtpSession::CryptoSuiteToFbs(CryptoSuite cryptoSuite)
 	{
+		MS_TRACE();
+
 		switch (cryptoSuite)
 		{
 			case SrtpSession::CryptoSuite::AEAD_AES_256_GCM:
@@ -58,6 +62,8 @@ namespace RTC
 
 	SrtpSession::CryptoSuite SrtpSession::CryptoSuiteFromFbs(FBS::SrtpParameters::SrtpCryptoSuite cryptoSuite)
 	{
+		MS_TRACE();
+
 		switch (cryptoSuite)
 		{
 			case FBS::SrtpParameters::SrtpCryptoSuite::AEAD_AES_256_GCM:

package/worker/src/RTC/SubchannelsCodec.cpp

@@ -12,12 +12,13 @@ namespace RTC
 	bool SubchannelsCodec::EncodeSubchannels(
 	  RTC::SCTP::Message& message,
 	  const std::vector<uint16_t>& subchannels,
-	  std::optional<uint16_t> requiredSubchannel)
+	  std::optional<uint16_t> requiredSubchannel,
+	  std::optional<uint16_t> ignoredSubchannel)
 	{
 		MS_TRACE();
 
 		// Nothing to encode.
-		if (subchannels.empty() && !requiredSubchannel.has_value())
+		if (subchannels.empty() && !requiredSubchannel.has_value() && !ignoredSubchannel.has_value())
 		{
 			return false;
 		}
@@ -31,6 +32,7 @@ namespace RTC
 
 		const auto subchannelsCount       = static_cast<uint16_t>(subchannels.size());
 		const bool requiredSubchannelFlag = requiredSubchannel.has_value();
+		const bool ignoredSubchannelFlag  = ignoredSubchannel.has_value();
 
 		// Length of the header to prepend.
 		size_t headerLen =
@@ -41,6 +43,11 @@ namespace RTC
 			headerLen += 2;
 		}
 
+		if (ignoredSubchannelFlag)
+		{
+			headerLen += 2;
+		}
+
 		const auto payload = message.GetPayload();
 
 		// Build the whole new payload at once (header followed by the original
@@ -54,6 +61,11 @@ namespace RTC
 			magicToken |= SubchannelsCodec::RequiredSubchannelFlagMask;
 		}
 
+		if (ignoredSubchannelFlag)
+		{
+			magicToken |= SubchannelsCodec::IgnoredSubchannelFlagMask;
+		}
+
 		size_t offset = 0;
 
 		Utils::Byte::Set8Bytes(newPayload.data(), offset, magicToken);
@@ -74,6 +86,12 @@ namespace RTC
 			offset += 2;
 		}
 
+		if (ignoredSubchannelFlag)
+		{
+			Utils::Byte::Set2Bytes(newPayload.data(), offset, ignoredSubchannel.value());
+			offset += 2;
+		}
+
 		// Append the original payload right after the encoded header.
 		std::ranges::copy(payload, newPayload.begin() + offset);
 
@@ -85,7 +103,8 @@ namespace RTC
 	bool SubchannelsCodec::DecodeSubchannels(
 	  RTC::SCTP::Message& message,
 	  std::vector<uint16_t>& subchannels,
-	  std::optional<uint16_t>& requiredSubchannel)
+	  std::optional<uint16_t>& requiredSubchannel,
+	  std::optional<uint16_t>& ignoredSubchannel)
 	{
 		MS_TRACE();
 
@@ -102,13 +121,15 @@ namespace RTC
 		const uint64_t magicToken = Utils::Byte::Get8Bytes(payload.data(), 0);
 
 		// The message does not start with the Magic Token, so nothing to decode.
-		if ((magicToken & ~SubchannelsCodec::RequiredSubchannelFlagMask) != SubchannelsCodec::MagicToken)
+		if ((magicToken & ~SubchannelsCodec::FlagsMask) != SubchannelsCodec::MagicToken)
 		{
 			return false;
 		}
 
 		const bool requiredSubchannelFlag =
 		  (magicToken & SubchannelsCodec::RequiredSubchannelFlagMask) != 0;
+		const bool ignoredSubchannelFlag =
+		  (magicToken & SubchannelsCodec::IgnoredSubchannelFlagMask) != 0;
 
 		const uint16_t subchannelsCount = Utils::Byte::Get2Bytes(payload.data(), 8);
 
@@ -116,7 +137,7 @@ namespace RTC
 		size_t offset = 10;
 
 		// Bytes needed to hold all announced subchannels and, if present, the
-		// requiredSubchannel.
+		// requiredSubchannel and the ignoredSubchannel.
 		size_t neededLen = offset + (static_cast<size_t>(subchannelsCount) * 2);
 
 		if (requiredSubchannelFlag)
@@ -124,9 +145,14 @@ namespace RTC
 			neededLen += 2;
 		}
 
+		if (ignoredSubchannelFlag)
+		{
+			neededLen += 2;
+		}
+
 		if (len < neededLen)
 		{
-			MS_WARN_DEV("message too short to hold announced subchannels, ignoring");
+			MS_WARN_DEV("message too short to hold announced fields, ignoring");
 
 			return false;
 		}
@@ -145,6 +171,12 @@ namespace RTC
 			offset += 2;
 		}
 
+		if (ignoredSubchannelFlag)
+		{
+			ignoredSubchannel = Utils::Byte::Get2Bytes(payload.data(), offset);
+			offset += 2;
+		}
+
 		// Remove the decoded header from the beginning of the message payload.
 		message.RemovePayloadFront(offset);
 

package/worker/src/RTC/Transport.cpp

@@ -2826,12 +2826,13 @@ namespace RTC
 	  RTC::DataProducer* dataProducer,
 	  RTC::SCTP::Message message,
 	  std::vector<uint16_t>& subchannels,
-	  std::optional<uint16_t> requiredSubchannel)
+	  std::optional<uint16_t> requiredSubchannel,
+	  std::optional<uint16_t> ignoredSubchannel)
 	{
 		MS_TRACE();
 
 		this->listener->OnTransportDataProducerMessageReceived(
-		  this, dataProducer, std::move(message), subchannels, requiredSubchannel);
+		  this, dataProducer, std::move(message), subchannels, requiredSubchannel, ignoredSubchannel);
 	}
 
 	void Transport::OnDataProducerPaused(RTC::DataProducer* dataProducer)
@@ -2875,6 +2876,8 @@ namespace RTC
 	void Transport::OnDataConsumerNeedBufferedAmountLowThreshold(
 	  const RTC::DataConsumer* dataConsumer, uint32_t& bufferedAmountLowThreshold) const
 	{
+		MS_TRACE();
+
 		if (this->sctpAssociation)
 		{
 			bufferedAmountLowThreshold =
@@ -3150,15 +3153,18 @@ namespace RTC
 		{
 			std::vector<uint16_t> subchannels;
 			std::optional<uint16_t> requiredSubchannel;
+			std::optional<uint16_t> ignoredSubchannel;
 
-			// When this is a pipe transport, the subchannels and required subchannel
-			// may be encoded at the beginning of the message payload.
+			// When this is a pipe transport, the subchannels, required subchannel and
+			// ignored subchannel may be encoded at the beginning of the message payload.
 			if (this->IsPipe())
 			{
-				RTC::SubchannelsCodec::DecodeSubchannels(message, subchannels, requiredSubchannel);
+				RTC::SubchannelsCodec::DecodeSubchannels(
+				  message, subchannels, requiredSubchannel, ignoredSubchannel);
 			}
 
-			dataProducer->ReceiveMessage(std::move(message), subchannels, requiredSubchannel);
+			dataProducer->ReceiveMessage(
+			  std::move(message), subchannels, requiredSubchannel, ignoredSubchannel);
 		}
 		catch (std::exception& error)
 		{

package/worker/src/RTC/TransportCongestionControlClient.cpp

@@ -59,6 +59,8 @@ namespace RTC
 
 	void TransportCongestionControlClient::InitializeController()
 	{
+		MS_TRACE();
+
 		MS_ASSERT(this->rtpTransportControllerSend == nullptr, "transport controller already initialized");
 
 		webrtc::BitrateConstraints bitrateConfig;
@@ -88,6 +90,8 @@ namespace RTC
 
 	void TransportCongestionControlClient::DestroyController()
 	{
+		MS_TRACE();
+
 		delete this->rtpTransportControllerSend;
 		this->rtpTransportControllerSend = nullptr;
 
@@ -243,6 +247,8 @@ namespace RTC
 
 	void TransportCongestionControlClient::UpdatePacketLoss(double packetLoss)
 	{
+		MS_TRACE();
+
 		// Add the lost into the histogram.
 		if (this->packetLossHistory.size() == PacketLossHistogramLength)
 		{
@@ -282,6 +288,8 @@ namespace RTC
 
 	void TransportCongestionControlClient::SetMaxOutgoingBitrate(uint32_t maxBitrate)
 	{
+		MS_TRACE();
+
 		this->maxOutgoingBitrate = maxBitrate;
 
 		ApplyBitrateUpdates();
@@ -295,6 +303,8 @@ namespace RTC
 
 	void TransportCongestionControlClient::SetMinOutgoingBitrate(uint32_t minBitrate)
 	{
+		MS_TRACE();
+
 		this->minOutgoingBitrate = minBitrate;
 
 		ApplyBitrateUpdates();
@@ -344,6 +354,8 @@ namespace RTC
 
 	void TransportCongestionControlClient::ApplyBitrateUpdates()
 	{
+		MS_TRACE();
+
 		auto currentMaxBitrate = this->bitrates.maxBitrate;
 		uint32_t newMaxBitrate = 0;
 

package/worker/src/RTC/TransportCongestionControlServer.cpp

@@ -394,6 +394,8 @@ namespace RTC
 
 	void TransportCongestionControlServer::UpdatePacketLoss(double packetLoss)
 	{
+		MS_TRACE();
+
 		// Add the lost into the histogram.
 		if (this->packetLossHistory.size() == PacketLossHistogramLength)
 		{

package/worker/src/Utils/BitStream.cpp

@@ -98,6 +98,8 @@ namespace Utils
 	 */
 	std::optional<uint32_t> BitStream::ReadNs(uint32_t n)
 	{
+		MS_TRACE();
+
 		unsigned w = 0;
 		unsigned x = n;
 

package/worker/src/Worker.cpp

@@ -88,6 +88,8 @@ void Worker::Close()
 flatbuffers::Offset<FBS::Worker::DumpResponse> Worker::FillBuffer(
   flatbuffers::FlatBufferBuilder& builder) const
 {
+	MS_TRACE();
+
 	// Add webRtcServerIds.
 	std::vector<flatbuffers::Offset<flatbuffers::String>> webRtcServerIds;
 	webRtcServerIds.reserve(this->mapWebRtcServers.size());

package/worker/src/handles/SignalHandle.cpp

@@ -10,11 +10,15 @@
 
 inline static void onSignal(uv_signal_t* handle, int signum)
 {
+	MS_TRACE();
+
 	static_cast<SignalHandle*>(handle->data)->OnUvSignal(signum);
 }
 
 inline static void onCloseSignal(uv_handle_t* handle)
 {
+	MS_TRACE();
+
 	delete reinterpret_cast<uv_signal_t*>(handle);
 }