diff --git a/quic/api/IoBufQuicBatch.cpp b/quic/api/IoBufQuicBatch.cpp index a4ad0074d..542b1936b 100644 --- a/quic/api/IoBufQuicBatch.cpp +++ b/quic/api/IoBufQuicBatch.cpp @@ -124,7 +124,7 @@ bool IOBufQuicBatch::flushInternal() { if (!written) { errnoCopy = errno; QUIC_STATS( - conn_.infoCallback, + conn_.statsCallback, onUDPSocketWriteError, QuicTransportStatsCallback::errnoToSocketErrorType(errnoCopy)); } diff --git a/quic/api/QuicTransportBase.cpp b/quic/api/QuicTransportBase.cpp index f6eacd151..78d069739 100644 --- a/quic/api/QuicTransportBase.cpp +++ b/quic/api/QuicTransportBase.cpp @@ -363,7 +363,7 @@ void QuicTransportBase::closeImpl( QUIC_STATS_FOR_EACH( conn_->streamManager->streams().cbegin(), conn_->streamManager->streams().cend(), - conn_->infoCallback, + conn_->statsCallback, onQuicStreamClosed); conn_->streamManager->clearOpenStreams(); @@ -2009,7 +2009,7 @@ folly::Expected QuicTransportBase::resetStream( cancelDeliveryCallbacksForStream(pendingResetIt->first); } pendingWriteCallbacks_.erase(id); - QUIC_STATS(conn_->infoCallback, onQuicStreamReset); + QUIC_STATS(conn_->statsCallback, onQuicStreamReset); } catch (const QuicTransportException& ex) { VLOG(4) << __func__ << " streamId=" << id << " " << ex.what() << " " << *this; diff --git a/quic/api/QuicTransportFunctions.cpp b/quic/api/QuicTransportFunctions.cpp index 71a49b18c..13fc81d37 100644 --- a/quic/api/QuicTransportFunctions.cpp +++ b/quic/api/QuicTransportFunctions.cpp @@ -224,8 +224,8 @@ DataPathResult iobufChainBasedBuildScheduleEncrypt( bool ret = ioBufBatch.write(std::move(packetBuf), encodedSize); if (ret) { // update stats and connection - QUIC_STATS(connection.infoCallback, onWrite, encodedSize); - QUIC_STATS(connection.infoCallback, onPacketSent); + QUIC_STATS(connection.statsCallback, onWrite, encodedSize); + QUIC_STATS(connection.statsCallback, onPacketSent); } return DataPathResult::makeWriteResult(ret, std::move(result), encodedSize); } @@ -326,7 +326,7 @@ bool handleStreamWritten( frameFin, packetNum, lossBufferIter); - QUIC_STATS(conn.infoCallback, onPacketRetransmission); + QUIC_STATS(conn.statsCallback, onPacketRetransmission); return false; } @@ -869,7 +869,7 @@ void writeCloseCommon( VLOG(4) << "Error writing connection close " << folly::errnoStr(errno) << " " << connection; } else { - QUIC_STATS(connection.infoCallback, onWrite, ret); + QUIC_STATS(connection.statsCallback, onWrite, ret); } } @@ -1036,6 +1036,7 @@ uint64_t writeConnectionDataToSocket( if (!ret.buildSuccess) { return ioBufBatch.getPktSent(); } + // If we build a packet, we updateConnection(), even if write might have // been failed. Because if it builds, a lot of states need to be updated no // matter the write result. We are basically treating this case as if we @@ -1110,7 +1111,7 @@ WriteDataReason shouldWriteData(const QuicConnectionStateBase& conn) { } if (!congestionControlWritableBytes(conn)) { - QUIC_STATS(conn.infoCallback, onCwndBlocked); + QUIC_STATS(conn.statsCallback, onCwndBlocked); return WriteDataReason::NO_WRITE; } return hasNonAckDataToWrite(conn); diff --git a/quic/api/test/Mocks.h b/quic/api/test/Mocks.h index 43de05d6c..9bf0f4589 100644 --- a/quic/api/test/Mocks.h +++ b/quic/api/test/Mocks.h @@ -257,7 +257,7 @@ class MockQuicTransport : public QuicServerTransport { , noexcept, , - setTransportInfoCallback, + setTransportStatsCallback, void(QuicTransportStatsCallback*)); GMOCK_METHOD1_(, noexcept, , setConnectionIdAlgo, void(ConnectionIdAlgo*)); diff --git a/quic/api/test/QuicTransportFunctionsTest.cpp b/quic/api/test/QuicTransportFunctionsTest.cpp index b48600c4a..3d71974c8 100644 --- a/quic/api/test/QuicTransportFunctionsTest.cpp +++ b/quic/api/test/QuicTransportFunctionsTest.cpp @@ -158,7 +158,7 @@ class QuicTransportFunctionsTest : public Test { kDefaultStreamWindowSize; conn->flowControlState.peerAdvertisedMaxOffset = kDefaultConnectionWindowSize; - conn->infoCallback = transportInfoCb_.get(); + conn->statsCallback = transportInfoCb_.get(); conn->initialWriteCipher = createNoOpAead(); conn->initialHeaderCipher = createNoOpHeaderCipher(); conn->streamManager->setMaxLocalBidirectionalStreams( diff --git a/quic/flowcontrol/QuicFlowController.cpp b/quic/flowcontrol/QuicFlowController.cpp index 062cfff13..4152c71c4 100644 --- a/quic/flowcontrol/QuicFlowController.cpp +++ b/quic/flowcontrol/QuicFlowController.cpp @@ -79,7 +79,7 @@ bool maybeSendConnWindowUpdate( updateTime); if (newAdvertisedOffset) { conn.pendingEvents.connWindowUpdate = true; - QUIC_STATS(conn.infoCallback, onConnFlowControlUpdate); + QUIC_STATS(conn.statsCallback, onConnFlowControlUpdate); if (conn.qLogger) { conn.qLogger->addTransportStateUpdate( getFlowControlEvent(newAdvertisedOffset.value())); @@ -112,7 +112,7 @@ bool maybeSendStreamWindowUpdate( VLOG(10) << "Queued flow control update for stream=" << stream.id << " offset=" << *newAdvertisedOffset; stream.conn.streamManager->queueWindowUpdate(stream.id); - QUIC_STATS(stream.conn.infoCallback, onStreamFlowControlUpdate); + QUIC_STATS(stream.conn.statsCallback, onStreamFlowControlUpdate); return true; } return false; @@ -185,7 +185,7 @@ void updateFlowControlOnWriteToSocket( "conn_blocked", stream.id, stream.conn.flowControlState.sumCurWriteOffset); - QUIC_STATS(stream.conn.infoCallback, onConnFlowControlBlocked); + QUIC_STATS(stream.conn.statsCallback, onConnFlowControlBlocked); } } @@ -212,7 +212,7 @@ void maybeWriteBlockAfterAPIWrite(QuicStreamState& stream) { "stream_blocked", stream.id, stream.flowControlState.peerAdvertisedMaxOffset); - QUIC_STATS(stream.conn.infoCallback, onStreamFlowControlBlocked); + QUIC_STATS(stream.conn.statsCallback, onStreamFlowControlBlocked); } } @@ -237,7 +237,7 @@ void maybeWriteBlockAfterSocketWrite(QuicStreamState& stream) { "stream_blocked", stream.id, stream.flowControlState.peerAdvertisedMaxOffset); - QUIC_STATS(stream.conn.infoCallback, onStreamFlowControlBlocked); + QUIC_STATS(stream.conn.statsCallback, onStreamFlowControlBlocked); } } diff --git a/quic/flowcontrol/test/QuicFlowControlTest.cpp b/quic/flowcontrol/test/QuicFlowControlTest.cpp index 1a87dbe45..3bbcb69a6 100644 --- a/quic/flowcontrol/test/QuicFlowControlTest.cpp +++ b/quic/flowcontrol/test/QuicFlowControlTest.cpp @@ -26,7 +26,7 @@ class QuicFlowControlTest : public Test { transportInfoCb_ = std::make_unique(); conn_.streamManager = std::make_unique( conn_, conn_.nodeType, conn_.transportSettings); - conn_.infoCallback = transportInfoCb_.get(); + conn_.statsCallback = transportInfoCb_.get(); } std::unique_ptr transportInfoCb_; QuicConnectionStateBase conn_{QuicNodeType::Client}; diff --git a/quic/loss/QuicLossFunctions.cpp b/quic/loss/QuicLossFunctions.cpp index b33349c5c..dd6b905a7 100644 --- a/quic/loss/QuicLossFunctions.cpp +++ b/quic/loss/QuicLossFunctions.cpp @@ -39,7 +39,7 @@ void onPTOAlarm(QuicConnectionStateBase& conn) { conn.lossState.largestSent, conn.lossState.ptoCount, (uint64_t)conn.outstandingPackets.size()); - QUIC_STATS(conn.infoCallback, onPTO); + QUIC_STATS(conn.statsCallback, onPTO); conn.lossState.ptoCount++; conn.lossState.totalPTOCount++; if (conn.qLogger) { diff --git a/quic/loss/test/QuicLossFunctionsTest.cpp b/quic/loss/test/QuicLossFunctionsTest.cpp index 8c8a3f900..48a2ce588 100644 --- a/quic/loss/test/QuicLossFunctionsTest.cpp +++ b/quic/loss/test/QuicLossFunctionsTest.cpp @@ -77,7 +77,7 @@ class QuicLossFunctionsTest : public TestWithParam { kDefaultMaxStreamsBidirectional); conn->streamManager->setMaxLocalUnidirectionalStreams( kDefaultMaxStreamsUnidirectional); - conn->infoCallback = transportInfoCb_.get(); + conn->statsCallback = transportInfoCb_.get(); // create a serverConnectionId that is different from the client connId // with bits for processId and workerId set to 0 ServerConnectionIdParams params(0, 0, 0); @@ -104,7 +104,7 @@ class QuicLossFunctionsTest : public TestWithParam { kDefaultStreamWindowSize; conn->flowControlState.peerAdvertisedMaxOffset = kDefaultConnectionWindowSize; - conn->infoCallback = transportInfoCb_.get(); + conn->statsCallback = transportInfoCb_.get(); // create a serverConnectionId that is different from the client connId // with bits for processId and workerId set to 0 ServerConnectionIdParams params(0, 0, 0); diff --git a/quic/server/QuicServer.cpp b/quic/server/QuicServer.cpp index 942033ceb..270958e0e 100644 --- a/quic/server/QuicServer.cpp +++ b/quic/server/QuicServer.cpp @@ -157,7 +157,7 @@ void QuicServer::initializeWorkers( } auto statsCallback = transportStatsFactory->make(); CHECK(statsCallback); - workerPtr->setTransportInfoCallback(std::move(statsCallback)); + workerPtr->setTransportStatsCallback(std::move(statsCallback)); }); } worker->setConnectionIdAlgo(connIdAlgoFactory_->make()); @@ -331,7 +331,7 @@ void QuicServer::routeDataToWorker( VLOG(4) << "Dropping data since quic-server is not initialized"; if (workerPtr_) { QUIC_STATS( - workerPtr_->getTransportInfoCallback(), + workerPtr_->getTransportStatsCallback(), onPacketDropped, QuicTransportStatsCallback::PacketDropReason::WORKER_NOT_INITIALIZED); } @@ -342,7 +342,7 @@ void QuicServer::routeDataToWorker( VLOG(4) << "Dropping data since quic server is shutdown"; if (workerPtr_) { QUIC_STATS( - workerPtr_->getTransportInfoCallback(), + workerPtr_->getTransportStatsCallback(), onPacketDropped, QuicTransportStatsCallback::PacketDropReason::SERVER_SHUTDOWN); } diff --git a/quic/server/QuicServerPacketRouter.cpp b/quic/server/QuicServerPacketRouter.cpp index 0daab9630..ab558bc69 100644 --- a/quic/server/QuicServerPacketRouter.cpp +++ b/quic/server/QuicServerPacketRouter.cpp @@ -95,7 +95,7 @@ void TakeoverHandlerCallback::onDataAvailable( // of it immediately so that if we return early, // we've flushed it. Buf data = std::move(readBuffer_); - QUIC_STATS(worker_->getInfoCallback(), onForwardedPacketReceived); + QUIC_STATS(worker_->getStatsCallback(), onForwardedPacketReceived); if (truncated) { // This is an error, drop the packet. return; @@ -241,7 +241,7 @@ void TakeoverPacketHandler::processForwardedPacket( Clock::duration tick(pktReceiveEpoch); TimePoint clientPacketReceiveTime(tick); data->trimStart(cursor - data.get()); - QUIC_STATS(worker_->getInfoCallback(), onForwardedPacketProcessed); + QUIC_STATS(worker_->getStatsCallback(), onForwardedPacketProcessed); worker_->handleNetworkData( peerAddress, std::move(data), diff --git a/quic/server/QuicServerTransport.cpp b/quic/server/QuicServerTransport.cpp index 1828975ef..ed93c8118 100644 --- a/quic/server/QuicServerTransport.cpp +++ b/quic/server/QuicServerTransport.cpp @@ -71,10 +71,10 @@ void QuicServerTransport::setServerConnectionIdParams( serverConn_->serverConnIdParams.assign(std::move(params)); } -void QuicServerTransport::setTransportInfoCallback( - QuicTransportStatsCallback* infoCallback) noexcept { +void QuicServerTransport::setTransportStatsCallback( + QuicTransportStatsCallback* statsCallback) noexcept { if (conn_) { - conn_->infoCallback = infoCallback; + conn_->statsCallback = statsCallback; } } diff --git a/quic/server/QuicServerTransport.h b/quic/server/QuicServerTransport.h index 231744b27..ca8091505 100644 --- a/quic/server/QuicServerTransport.h +++ b/quic/server/QuicServerTransport.h @@ -72,8 +72,8 @@ class QuicServerTransport * Set callback for various transport stats (such as packet received, dropped * etc). */ - virtual void setTransportInfoCallback( - QuicTransportStatsCallback* infoCallback) noexcept; + virtual void setTransportStatsCallback( + QuicTransportStatsCallback* statsCallback) noexcept; /** * Set ConnectionIdAlgo implementation to encode and decode ConnectionId with diff --git a/quic/server/QuicServerWorker.cpp b/quic/server/QuicServerWorker.cpp index addc3b1de..884cbdd4b 100644 --- a/quic/server/QuicServerWorker.cpp +++ b/quic/server/QuicServerWorker.cpp @@ -74,15 +74,15 @@ void QuicServerWorker::setTransportSettingsOverrideFn( transportSettingsOverrideFn_ = std::move(fn); } -void QuicServerWorker::setTransportInfoCallback( - std::unique_ptr infoCallback) noexcept { - CHECK(infoCallback); - infoCallback_ = std::move(infoCallback); +void QuicServerWorker::setTransportStatsCallback( + std::unique_ptr statsCallback) noexcept { + CHECK(statsCallback); + statsCallback_ = std::move(statsCallback); } -QuicTransportStatsCallback* QuicServerWorker::getTransportInfoCallback() const +QuicTransportStatsCallback* QuicServerWorker::getTransportStatsCallback() const noexcept { - return infoCallback_.get(); + return statsCallback_.get(); } void QuicServerWorker::setConnectionIdAlgo( @@ -155,7 +155,7 @@ bool QuicServerWorker::maybeSendVersionNegotiationPacketOrDrop( if (negotiationNeeded && !isInitial) { VLOG(3) << "Dropping non-initial packet due to invalid version"; QUIC_STATS( - infoCallback_, onPacketDropped, PacketDropReason::INVALID_PACKET); + statsCallback_, onPacketDropped, PacketDropReason::INVALID_PACKET); return true; } if (negotiationNeeded) { @@ -168,9 +168,9 @@ bool QuicServerWorker::maybeSendVersionNegotiationPacketOrDrop( if (versionNegotiationPacket) { VLOG(4) << "Version negotiation sent to client=" << client; auto len = versionNegotiationPacket->second->computeChainDataLength(); - QUIC_STATS(infoCallback_, onWrite, len); - QUIC_STATS(infoCallback_, onPacketProcessed); - QUIC_STATS(infoCallback_, onPacketSent); + QUIC_STATS(statsCallback_, onWrite, len); + QUIC_STATS(statsCallback_, onPacketProcessed); + QUIC_STATS(statsCallback_, onPacketSent); socket_->write(client, versionNegotiationPacket->second); return true; } @@ -197,8 +197,8 @@ void QuicServerWorker::onDataAvailable( return; } data->append(len); - QUIC_STATS(infoCallback_, onPacketReceived); - QUIC_STATS(infoCallback_, onRead, len); + QUIC_STATS(statsCallback_, onPacketReceived); + QUIC_STATS(statsCallback_, onRead, len); handleNetworkData(client, std::move(data), packetReceiveTime); } @@ -211,14 +211,14 @@ void QuicServerWorker::handleNetworkData( if (shutdown_) { VLOG(4) << "Packet received after shutdown, dropping"; QUIC_STATS( - infoCallback_, onPacketDropped, PacketDropReason::SERVER_SHUTDOWN); + statsCallback_, onPacketDropped, PacketDropReason::SERVER_SHUTDOWN); return; } if (!callback_) { VLOG(0) << "Worker callback is null. Dropping packet."; QUIC_STATS( - infoCallback_, + statsCallback_, onPacketDropped, PacketDropReason::WORKER_NOT_INITIALIZED); return; @@ -227,7 +227,7 @@ void QuicServerWorker::handleNetworkData( if (!cursor.canAdvance(sizeof(uint8_t))) { VLOG(4) << "Dropping packet too small"; QUIC_STATS( - infoCallback_, onPacketDropped, PacketDropReason::INVALID_PACKET); + statsCallback_, onPacketDropped, PacketDropReason::INVALID_PACKET); return; } uint8_t initialByte = cursor.readBE(); @@ -239,7 +239,7 @@ void QuicServerWorker::handleNetworkData( if (!parsedShortHeader) { if (!tryHandlingAsHealthCheck(client, *data)) { QUIC_STATS( - infoCallback_, onPacketDropped, PacketDropReason::PARSE_ERROR); + statsCallback_, onPacketDropped, PacketDropReason::PARSE_ERROR); VLOG(6) << "Failed to parse short header"; } return; @@ -262,7 +262,7 @@ void QuicServerWorker::handleNetworkData( if (!parsedLongHeader) { if (!tryHandlingAsHealthCheck(client, *data)) { QUIC_STATS( - infoCallback_, onPacketDropped, PacketDropReason::PARSE_ERROR); + statsCallback_, onPacketDropped, PacketDropReason::PARSE_ERROR); VLOG(6) << "Failed to parse long header"; } return; @@ -276,7 +276,7 @@ void QuicServerWorker::handleNetworkData( if (isInitial) { // This stats gets updated even if the client initial will be dropped. - QUIC_STATS(infoCallback_, onClientInitialReceived); + QUIC_STATS(statsCallback_, onClientInitialReceived); } if (maybeSendVersionNegotiationPacketOrDrop( @@ -290,7 +290,7 @@ void QuicServerWorker::handleNetworkData( // drop packet if connId is present but is not valid. VLOG(3) << "Dropping packet due to invalid connectionId"; QUIC_STATS( - infoCallback_, onPacketDropped, PacketDropReason::INVALID_PACKET); + statsCallback_, onPacketDropped, PacketDropReason::INVALID_PACKET); return; } RoutingData routingData( @@ -306,7 +306,7 @@ void QuicServerWorker::handleNetworkData( isForwardedData); } catch (const std::exception& ex) { // Drop the packet. - QUIC_STATS(infoCallback_, onPacketDropped, PacketDropReason::PARSE_ERROR); + QUIC_STATS(statsCallback_, onPacketDropped, PacketDropReason::PARSE_ERROR); VLOG(6) << "Failed to parse packet header " << ex.what(); } } @@ -350,13 +350,13 @@ void QuicServerWorker::forwardNetworkData( auto recvTime = networkData.receiveTimePoint; takeoverPktHandler_.forwardPacketToAnotherServer( client, std::move(networkData).moveAllData(), recvTime); - QUIC_STATS(infoCallback_, onPacketForwarded); + QUIC_STATS(statsCallback_, onPacketForwarded); return; } else { VLOG(3) << "Dropping packet due to unknown connectionId version connId=" << routingData.destinationConnId.hex(); QUIC_STATS( - infoCallback_, + statsCallback_, onPacketDropped, PacketDropReason::CONNECTION_NOT_FOUND); } @@ -425,7 +425,9 @@ void QuicServerWorker::dispatchPacketData( // Don't even attempt to forward the packet, just drop it. VLOG(3) << "Dropping small initial packet from client=" << client; QUIC_STATS( - infoCallback_, onPacketDropped, PacketDropReason::INVALID_PACKET); + statsCallback_, + onPacketDropped, + PacketDropReason::INVALID_PACKET); return; } // create 'accepting' transport @@ -464,8 +466,8 @@ void QuicServerWorker::dispatchPacketData( ServerConnectionIdParams serverConnIdParams( hostId_, static_cast(processId_), workerId_); trans->setServerConnectionIdParams(std::move(serverConnIdParams)); - if (infoCallback_) { - trans->setTransportInfoCallback(infoCallback_.get()); + if (statsCallback_) { + trans->setTransportStatsCallback(statsCallback_.get()); } trans->accept(); auto result = sourceAddressMap_.emplace(std::make_pair( @@ -493,7 +495,7 @@ void QuicServerWorker::dispatchPacketData( VLOG(3) << "Dropping packet due to transport factory did not make transport"; QUIC_STATS( - infoCallback_, + statsCallback_, onPacketDropped, PacketDropReason::CANNOT_MAKE_TRANSPORT); return; @@ -503,7 +505,7 @@ void QuicServerWorker::dispatchPacketData( << routingData.destinationConnId.hex() << ", workerId=" << (uint32_t)workerId_ << ", hostId=" << (uint32_t)hostId_; - QUIC_STATS(infoCallback_, onPacketDropped, PacketDropReason::PARSE_ERROR); + QUIC_STATS(statsCallback_, onPacketDropped, PacketDropReason::PARSE_ERROR); // TODO do we need to reset? return; } @@ -516,7 +518,7 @@ void QuicServerWorker::dispatchPacketData( << ", DCID=" << routingData.destinationConnId.hex() << ", workerId=" << (uint32_t)workerId_ << ", hostId=" << (uint32_t)hostId_; - QUIC_STATS(infoCallback_, onPacketDropped, PacketDropReason::PARSE_ERROR); + QUIC_STATS(statsCallback_, onPacketDropped, PacketDropReason::PARSE_ERROR); // TODO do we need to reset? return; } @@ -527,7 +529,7 @@ void QuicServerWorker::dispatchPacketData( << ", hostId=" << (uint32_t)hostId_ << ", received hostId=" << (uint32_t)connIdParam->hostId; QUIC_STATS( - infoCallback_, + statsCallback_, onPacketDropped, PacketDropReason::ROUTING_ERROR_WRONG_HOST); return sendResetPacket( @@ -539,7 +541,9 @@ void QuicServerWorker::dispatchPacketData( if (!packetForwardingEnabled_ || isForwardedData) { QUIC_STATS( - infoCallback_, onPacketDropped, PacketDropReason::CONNECTION_NOT_FOUND); + statsCallback_, + onPacketDropped, + PacketDropReason::CONNECTION_NOT_FOUND); return sendResetPacket( routingData.headerForm, client, @@ -551,7 +555,9 @@ void QuicServerWorker::dispatchPacketData( // addr, and doesn't belong to the old server. Send a Reset. if (connIdParam->processId == static_cast(processId_)) { QUIC_STATS( - infoCallback_, onPacketDropped, PacketDropReason::CONNECTION_NOT_FOUND); + statsCallback_, + onPacketDropped, + PacketDropReason::CONNECTION_NOT_FOUND); return sendResetPacket( routingData.headerForm, client, @@ -568,7 +574,7 @@ void QuicServerWorker::dispatchPacketData( auto recvTime = networkData.receiveTimePoint; takeoverPktHandler_.forwardPacketToAnotherServer( client, std::move(networkData).moveAllData(), recvTime); - QUIC_STATS(infoCallback_, onPacketForwarded); + QUIC_STATS(statsCallback_, onPacketForwarded); } void QuicServerWorker::sendResetPacket( @@ -591,10 +597,11 @@ void QuicServerWorker::sendResetPacket( StatelessResetToken token = generator.generateToken(connId); StatelessResetPacketBuilder builder(maxResetPacketSize, token); auto resetData = std::move(builder).buildPacket(); + auto resetDataLen = resetData->computeChainDataLength(); socket_->write(client, std::move(resetData)); - QUIC_STATS(infoCallback_, onWrite, resetData->computeChainDataLength()); - QUIC_STATS(infoCallback_, onPacketSent); - QUIC_STATS(infoCallback_, onStatelessReset); + QUIC_STATS(statsCallback_, onWrite, resetDataLen); + QUIC_STATS(statsCallback_, onPacketSent); + QUIC_STATS(statsCallback_, onStatelessReset); } void QuicServerWorker::allowBeingTakenOver( @@ -750,7 +757,7 @@ void QuicServerWorker::onConnectionIdAvailable( << (existingTransportPtr == transportPtr); } else if (boundServerTransports_.emplace(transportPtr, weakTransport) .second) { - QUIC_STATS(infoCallback_, onNewConnection); + QUIC_STATS(statsCallback_, onNewConnection); } } @@ -779,7 +786,7 @@ void QuicServerWorker::onConnectionUnbound( boundServerTransports_.erase(transport); if (connectionIdData.size()) { - QUIC_STATS(infoCallback_, onConnectionClose, folly::none); + QUIC_STATS(statsCallback_, onConnectionClose, folly::none); } for (auto& connId : connectionIdData) { @@ -836,7 +843,7 @@ void QuicServerWorker::shutdownAllConnections(LocalErrorCode error) { for (auto& it : sourceAddressMap_) { auto transport = it.second; transport->setRoutingCallback(nullptr); - transport->setTransportInfoCallback(nullptr); + transport->setTransportStatsCallback(nullptr); transport->closeNow( std::make_pair(QuicErrorCode(error), std::string("shutting down"))); } @@ -845,17 +852,17 @@ void QuicServerWorker::shutdownAllConnections(LocalErrorCode error) { for (auto transport : boundServerTransports_) { if (auto t = transport.second.lock()) { t->setRoutingCallback(nullptr); - t->setTransportInfoCallback(nullptr); + t->setTransportStatsCallback(nullptr); t->closeNow( std::make_pair(QuicErrorCode(error), std::string("shutting down"))); - QUIC_STATS(infoCallback_, onConnectionClose, folly::none); + QUIC_STATS(statsCallback_, onConnectionClose, folly::none); } } sourceAddressMap_.clear(); connectionIdMap_.clear(); takeoverPktHandler_.stop(); - if (infoCallback_) { - infoCallback_.reset(); + if (statsCallback_) { + statsCallback_.reset(); } socket_.reset(); takeoverCB_.reset(); diff --git a/quic/server/QuicServerWorker.h b/quic/server/QuicServerWorker.h index b91d99264..1ce60ed64 100644 --- a/quic/server/QuicServerWorker.h +++ b/quic/server/QuicServerWorker.h @@ -202,13 +202,13 @@ class QuicServerWorker : public folly::AsyncUDPSocket::ReadCallback, * important that the implementation is efficient. * NOTE: Quic does not synchronize across threads before calling it. */ - void setTransportInfoCallback( - std::unique_ptr infoCallback) noexcept; + void setTransportStatsCallback( + std::unique_ptr statsCallback) noexcept; /** * Return callback for recording various transport stats info. */ - QuicTransportStatsCallback* getTransportInfoCallback() const noexcept; + QuicTransportStatsCallback* getTransportStatsCallback() const noexcept; /** * Set ConnectionIdAlgo implementation to encode and decode ConnectionId with @@ -328,8 +328,8 @@ class QuicServerWorker : public folly::AsyncUDPSocket::ReadCallback, * per thread, it is important that the implementation is efficient. * NOTE: QuicServer does not synchronize across threads before calling it */ - QuicTransportStatsCallback* getInfoCallback() { - return infoCallback_.get(); + QuicTransportStatsCallback* getStatsCallback() { + return statsCallback_.get(); } private: @@ -390,7 +390,7 @@ class QuicServerWorker : public folly::AsyncUDPSocket::ReadCallback, std::unique_ptr connIdAlgo_; uint16_t hostId_{0}; // QuicServerWorker maintains ownership of the info stats callback - std::unique_ptr infoCallback_; + std::unique_ptr statsCallback_; // Handle takeover between processes std::unique_ptr takeoverCB_; diff --git a/quic/server/state/ServerStateMachine.cpp b/quic/server/state/ServerStateMachine.cpp index 511a0f01d..b74b660b5 100644 --- a/quic/server/state/ServerStateMachine.cpp +++ b/quic/server/state/ServerStateMachine.cpp @@ -365,7 +365,7 @@ void onConnectionMigration( PacketDropReason::PEER_ADDRESS_CHANGE)); } QUIC_STATS( - conn.infoCallback, + conn.statsCallback, onPacketDropped, PacketDropReason::PEER_ADDRESS_CHANGE); throw QuicTransportException( @@ -533,7 +533,7 @@ void onServerReadDataFromOpen( PacketDropReason::PARSE_ERROR)); } QUIC_STATS( - conn.infoCallback, onPacketDropped, PacketDropReason::PARSE_ERROR); + conn.statsCallback, onPacketDropped, PacketDropReason::PARSE_ERROR); return; } QuicVersion version = parsedLongHeader->invariant.version; @@ -546,7 +546,9 @@ void onServerReadDataFromOpen( PacketDropReason::INVALID_PACKET)); } QUIC_STATS( - conn.infoCallback, onPacketDropped, PacketDropReason::INVALID_PACKET); + conn.statsCallback, + onPacketDropped, + PacketDropReason::INVALID_PACKET); return; } @@ -563,7 +565,7 @@ void onServerReadDataFromOpen( PacketDropReason::INITIAL_CONNID_SMALL)); } QUIC_STATS( - conn.infoCallback, + conn.statsCallback, onPacketDropped, PacketDropReason::INITIAL_CONNID_SMALL); return; @@ -578,7 +580,7 @@ void onServerReadDataFromOpen( CHECK(newServerConnIdData.has_value()); conn.serverConnectionId = newServerConnIdData->connId; - QUIC_STATS(conn.infoCallback, onStatelessReset); + QUIC_STATS(conn.statsCallback, onStatelessReset); conn.serverHandshakeLayer->accept( std::make_shared( version, @@ -667,7 +669,7 @@ void onServerReadDataFromOpen( // previous switch-case block. We just need to update QUIC_STATS here. VLOG(10) << "Not able to parse QUIC packet " << conn; QUIC_STATS( - conn.infoCallback, onPacketDropped, PacketDropReason::PARSE_ERROR); + conn.statsCallback, onPacketDropped, PacketDropReason::PARSE_ERROR); continue; } @@ -695,7 +697,7 @@ void onServerReadDataFromOpen( // TODO: add path challenge and response if (!isPadding && !isAck && !isClose && !isCrypto && !isPing) { QUIC_STATS( - conn.infoCallback, + conn.statsCallback, onPacketDropped, PacketDropReason::PROTOCOL_VIOLATION); if (conn.qLogger) { @@ -736,7 +738,7 @@ void onServerReadDataFromOpen( PacketDropReason::PEER_ADDRESS_CHANGE)); } QUIC_STATS( - conn.infoCallback, + conn.statsCallback, onPacketDropped, PacketDropReason::PEER_ADDRESS_CHANGE); throw QuicTransportException( @@ -752,7 +754,7 @@ void onServerReadDataFromOpen( PacketDropReason::PEER_ADDRESS_CHANGE)); } QUIC_STATS( - conn.infoCallback, + conn.statsCallback, onPacketDropped, PacketDropReason::PEER_ADDRESS_CHANGE); throw QuicTransportException( @@ -1012,7 +1014,7 @@ void onServerReadDataFromOpen( PacketDropReason::PEER_ADDRESS_CHANGE)); } QUIC_STATS( - conn.infoCallback, + conn.statsCallback, onPacketDropped, PacketDropReason::PEER_ADDRESS_CHANGE); throw QuicTransportException( @@ -1036,7 +1038,7 @@ void onServerReadDataFromOpen( PacketDropReason::TRANSPORT_PARAMETER_ERROR)); } QUIC_STATS( - conn.infoCallback, + conn.statsCallback, onPacketDropped, QuicTransportStatsCallback::PacketDropReason:: TRANSPORT_PARAMETER_ERROR); @@ -1049,7 +1051,7 @@ void onServerReadDataFromOpen( outOfOrder, pktHasRetransmittableData, pktHasCryptoData); - QUIC_STATS(conn.infoCallback, onPacketProcessed); + QUIC_STATS(conn.statsCallback, onPacketProcessed); } VLOG_IF(4, !udpData.empty()) << "Leaving " << udpData.chainLength() @@ -1074,7 +1076,7 @@ void onServerReadDataFromClosed( PacketDropReason::SERVER_STATE_CLOSED)); } QUIC_STATS( - conn.infoCallback, + conn.statsCallback, onPacketDropped, PacketDropReason::SERVER_STATE_CLOSED); return; @@ -1090,7 +1092,7 @@ void onServerReadDataFromClosed( } QUIC_TRACE(packet_drop, conn, "ignoring peer close"); QUIC_STATS( - conn.infoCallback, + conn.statsCallback, onPacketDropped, PacketDropReason::SERVER_STATE_CLOSED); return; @@ -1143,7 +1145,7 @@ void onServerReadDataFromClosed( QuicTransportStatsCallback::toString(PacketDropReason::PARSE_ERROR)); } QUIC_STATS( - conn.infoCallback, onPacketDropped, PacketDropReason::PARSE_ERROR); + conn.statsCallback, onPacketDropped, PacketDropReason::PARSE_ERROR); return; } diff --git a/quic/server/test/QuicServerTest.cpp b/quic/server/test/QuicServerTest.cpp index a9794cd87..b894bc83d 100644 --- a/quic/server/test/QuicServerTest.cpp +++ b/quic/server/test/QuicServerTest.cpp @@ -148,11 +148,11 @@ class QuicServerWorkerTest : public Test { worker_->setWorkerId(42); worker_->setProcessId(ProcessId::ONE); worker_->setHostId(hostId_); - worker_->setTransportInfoCallback(std::move(transportInfoCb)); + worker_->setTransportStatsCallback(std::move(transportInfoCb)); worker_->setConnectionIdAlgo(std::make_unique()); worker_->setCongestionControllerFactory( std::make_shared()); - transportInfoCb_ = (MockQuicStats*)worker_->getTransportInfoCallback(); + transportInfoCb_ = (MockQuicStats*)worker_->getTransportStatsCallback(); auto cb = [&](const folly::SocketAddress& addr, std::unique_ptr& routingData, @@ -245,7 +245,7 @@ void QuicServerWorkerTest::expectConnectionCreation( })); EXPECT_CALL(*transport, setTransportSettings(_)); EXPECT_CALL(*transport, accept()); - EXPECT_CALL(*transport, setTransportInfoCallback(transportInfoCb_)); + EXPECT_CALL(*transport, setTransportStatsCallback(transportInfoCb_)); } void QuicServerWorkerTest::expectConnCreateRefused() { @@ -258,7 +258,7 @@ void QuicServerWorkerTest::expectConnCreateRefused() { EXPECT_CALL(*transport, setServerConnectionIdParams(_)).Times(0); EXPECT_CALL(*transport, setTransportSettings(_)).Times(0); EXPECT_CALL(*transport, accept()).Times(0); - EXPECT_CALL(*transport, setTransportInfoCallback(transportInfoCb_)).Times(0); + EXPECT_CALL(*transport, setTransportStatsCallback(transportInfoCb_)).Times(0); EXPECT_CALL(*transport, onNetworkData(_, _)).Times(0); } @@ -807,7 +807,7 @@ TEST_F(QuicServerWorkerTest, ShutdownQuicServer) { EXPECT_CALL(*transportInfoCb_, onConnectionClose(_)); EXPECT_CALL(*transport_, setRoutingCallback(nullptr)).Times(2); - EXPECT_CALL(*transport_, setTransportInfoCallback(nullptr)).Times(2); + EXPECT_CALL(*transport_, setTransportStatsCallback(nullptr)).Times(2); EXPECT_CALL(*transport_, close(_)).WillRepeatedly(Invoke([this](auto) { hasShutdown_ = true; })); @@ -846,7 +846,7 @@ TEST_F(QuicServerWorkerTest, DestroyQuicServer) { EXPECT_CALL(*transportInfoCb_, onConnectionClose(_)); EXPECT_CALL(*transport_, setRoutingCallback(nullptr)).Times(2); - EXPECT_CALL(*transport_, setTransportInfoCallback(nullptr)).Times(2); + EXPECT_CALL(*transport_, setTransportStatsCallback(nullptr)).Times(2); EXPECT_CALL(*transport_, close(_)).WillRepeatedly(Invoke([this](auto) { hasShutdown_ = true; })); @@ -953,9 +953,9 @@ class QuicServerWorkerTakeoverTest : public Test { auto transportInfoCb = std::make_unique>(); takeoverWorker_->setConnectionIdAlgo( std::make_unique()); - takeoverWorker_->setTransportInfoCallback(std::move(transportInfoCb)); + takeoverWorker_->setTransportStatsCallback(std::move(transportInfoCb)); transportInfoCb_ = - (MockQuicStats*)takeoverWorker_->getTransportInfoCallback(); + (MockQuicStats*)takeoverWorker_->getTransportStatsCallback(); auto takeoverSock = std::make_unique>(&evb_); @@ -1390,9 +1390,9 @@ class QuicServerTest : public Test { std::shared_ptr) noexcept { // set proper expectations for the transport after its creation EXPECT_CALL(*transport, getEventBase()).WillRepeatedly(Return(evb)); - EXPECT_CALL(*transport, setTransportInfoCallback(_)) - .WillOnce(Invoke([&](QuicTransportStatsCallback* infoCallback) { - CHECK(infoCallback); + EXPECT_CALL(*transport, setTransportStatsCallback(_)) + .WillOnce(Invoke([&](QuicTransportStatsCallback* statsCallback) { + CHECK(statsCallback); })); EXPECT_CALL(*transport, setTransportSettings(_)) .WillRepeatedly(Invoke([&](auto transportSettings) { @@ -1459,7 +1459,7 @@ class QuicServerTest : public Test { auto client = makeUdpClient(); folly::EventBase* evb = server_->getWorkerEvbs().back(); auto transport = createNewTransport(evb, *client, serverAddr); - EXPECT_CALL(*transport, setTransportInfoCallback(nullptr)); + EXPECT_CALL(*transport, setTransportStatsCallback(nullptr)); EXPECT_CALL(*transport, setRoutingCallback(nullptr)); EXPECT_CALL(*transport, closeNow(_)); mockStats_.reset(); @@ -1502,7 +1502,7 @@ TEST_F(QuicServerTest, DontRouteDataAfterShutdown) { auto client = makeUdpClient(); auto transport = createNewTransport(evbThread.getEventBase(), *client, serverAddr); - EXPECT_CALL(*transport, setTransportInfoCallback(nullptr)); + EXPECT_CALL(*transport, setTransportStatsCallback(nullptr)); EXPECT_CALL(*transport, closeNow(_)).WillOnce(InvokeWithoutArgs([&] { PacketNum packetNum = 1; @@ -1544,7 +1544,7 @@ TEST_F(QuicServerTest, RouteDataFromDifferentThread) { auto client = makeUdpClient(); auto transport = createNewTransport(evbThread.getEventBase(), *client, serverAddr); - EXPECT_CALL(*transport, setTransportInfoCallback(nullptr)); + EXPECT_CALL(*transport, setTransportStatsCallback(nullptr)); EXPECT_CALL(*stats, onPacketDropped(PacketDropReason::SERVER_SHUTDOWN)) .Times(0); auto clientConnId = getTestConnectionId(clientHostId_), @@ -1656,7 +1656,7 @@ class QuicServerTakeoverTest : public Test { EXPECT_CALL(*transport, setSupportedVersions(_)); EXPECT_CALL(*transport, setRoutingCallback(_)); EXPECT_CALL(*transport, setOriginalPeerAddress(_)); - EXPECT_CALL(*transport, setTransportInfoCallback(_)); + EXPECT_CALL(*transport, setTransportStatsCallback(_)); EXPECT_CALL(*transport, setServerConnectionIdParams(_)) .WillOnce(Invoke([&](ServerConnectionIdParams params) { EXPECT_EQ(params.processId, 0); @@ -1819,7 +1819,7 @@ class QuicServerTakeoverTest : public Test { b1.wait(); - EXPECT_CALL(*transportCbForOldServer, setTransportInfoCallback(nullptr)); + EXPECT_CALL(*transportCbForOldServer, setTransportStatsCallback(nullptr)); oldServer_->shutdown(); // 'transport' never gets created for the newServer_ // so no callback on closeNow() diff --git a/quic/server/test/QuicServerTransportTest.cpp b/quic/server/test/QuicServerTransportTest.cpp index fe3b04b41..8d57d186d 100644 --- a/quic/server/test/QuicServerTransportTest.cpp +++ b/quic/server/test/QuicServerTransportTest.cpp @@ -311,7 +311,7 @@ class QuicServerTransportTest : public Test { server->getNonConstConn().transportSettings.statelessResetTokenSecret = getRandSecret(); transportInfoCb_ = std::make_unique>(); - server->setTransportInfoCallback(transportInfoCb_.get()); + server->setTransportStatsCallback(transportInfoCb_.get()); initializeServerHandshake(); server->getNonConstConn().handshakeLayer.reset(fakeHandshake); server->getNonConstConn().serverHandshakeLayer = fakeHandshake; @@ -457,7 +457,7 @@ class QuicServerTransportTest : public Test { virtual void setupConnection() { EXPECT_EQ(server->getConn().readCodec, nullptr); - EXPECT_EQ(server->getConn().infoCallback, transportInfoCb_.get()); + EXPECT_EQ(server->getConn().statsCallback, transportInfoCb_.get()); setupClientReadCodec(); recvClientHello(); diff --git a/quic/state/QuicStreamManager.cpp b/quic/state/QuicStreamManager.cpp index 11a0618e7..97cdcc861 100644 --- a/quic/state/QuicStreamManager.cpp +++ b/quic/state/QuicStreamManager.cpp @@ -235,7 +235,7 @@ QuicStreamManager::getOrCreateOpenedLocalStream(StreamId streamId) { std::piecewise_construct, std::forward_as_tuple(streamId), std::forward_as_tuple(streamId, conn_)); - QUIC_STATS(conn_.infoCallback, onNewQuicStream); + QUIC_STATS(conn_.statsCallback, onNewQuicStream); return &it.first->second; } return nullptr; @@ -321,7 +321,7 @@ QuicStreamManager::getOrCreatePeerStream(StreamId streamId) { std::piecewise_construct, std::forward_as_tuple(streamId), std::forward_as_tuple(streamId, conn_)); - QUIC_STATS(conn_.infoCallback, onNewQuicStream); + QUIC_STATS(conn_.statsCallback, onNewQuicStream); return &it.first->second; } @@ -349,7 +349,7 @@ QuicStreamManager::getOrCreatePeerStream(StreamId streamId) { std::piecewise_construct, std::forward_as_tuple(streamId), std::forward_as_tuple(streamId, conn_)); - QUIC_STATS(conn_.infoCallback, onNewQuicStream); + QUIC_STATS(conn_.statsCallback, onNewQuicStream); return &it.first->second; } @@ -391,7 +391,7 @@ QuicStreamManager::createStream(StreamId streamId) { std::piecewise_construct, std::forward_as_tuple(streamId), std::forward_as_tuple(streamId, conn_)); - QUIC_STATS(conn_.infoCallback, onNewQuicStream); + QUIC_STATS(conn_.statsCallback, onNewQuicStream); updateAppIdleState(); return &it.first->second; } @@ -418,7 +418,7 @@ void QuicStreamManager::removeClosedStream(StreamId streamId) { numControlStreams_--; } streams_.erase(it); - QUIC_STATS(conn_.infoCallback, onQuicStreamClosed); + QUIC_STATS(conn_.statsCallback, onQuicStreamClosed); if (isRemoteStream(nodeType_, streamId)) { auto& openPeerStreams = isUnidirectionalStream(streamId) ? openUnidirectionalPeerStreams_ diff --git a/quic/state/QuicTransportStatsCallback.h b/quic/state/QuicTransportStatsCallback.h index ece707e0f..f0b36879b 100644 --- a/quic/state/QuicTransportStatsCallback.h +++ b/quic/state/QuicTransportStatsCallback.h @@ -227,17 +227,17 @@ class QuicTransportStatsCallbackFactory { virtual std::unique_ptr make() = 0; }; -#define QUIC_STATS(infoCallback, method, ...) \ - if (infoCallback) { \ - folly::invoke( \ - &QuicTransportStatsCallback::method, infoCallback, ##__VA_ARGS__); \ +#define QUIC_STATS(statsCallback, method, ...) \ + if (statsCallback) { \ + folly::invoke( \ + &QuicTransportStatsCallback::method, statsCallback, ##__VA_ARGS__); \ } -#define QUIC_STATS_FOR_EACH(iterBegin, iterEnd, infoCallback, method, ...) \ - if (infoCallback) { \ - std::for_each(iterBegin, iterEnd, [&](const auto&) { \ - folly::invoke( \ - &QuicTransportStatsCallback::method, infoCallback, ##__VA_ARGS__); \ - }); \ +#define QUIC_STATS_FOR_EACH(iterBegin, iterEnd, statsCallback, method, ...) \ + if (statsCallback) { \ + std::for_each(iterBegin, iterEnd, [&](const auto&) { \ + folly::invoke( \ + &QuicTransportStatsCallback::method, statsCallback, ##__VA_ARGS__); \ + }); \ } } // namespace quic diff --git a/quic/state/StateData.h b/quic/state/StateData.h index f49014373..653d6889d 100644 --- a/quic/state/StateData.h +++ b/quic/state/StateData.h @@ -747,7 +747,7 @@ struct QuicConnectionStateBase : public folly::DelayedDestruction { std::shared_ptr qLogger; // Track stats for various server events - QuicTransportStatsCallback* infoCallback{nullptr}; + QuicTransportStatsCallback* statsCallback{nullptr}; struct HappyEyeballsState { // Delay timer diff --git a/quic/state/stream/StreamStateFunctions.cpp b/quic/state/stream/StreamStateFunctions.cpp index 6788da352..ebc3b7d55 100644 --- a/quic/state/stream/StreamStateFunctions.cpp +++ b/quic/state/stream/StreamStateFunctions.cpp @@ -58,7 +58,7 @@ void onResetQuicStream(QuicStreamState& stream, RstStreamFrame&& frame) { stream.conn.streamManager->updateReadableStreams(stream); stream.conn.streamManager->updateWritableStreams(stream); stream.conn.streamManager->updateLossStreams(stream); - QUIC_STATS(stream.conn.infoCallback, onQuicStreamReset); + QUIC_STATS(stream.conn.statsCallback, onQuicStreamReset); } bool isAllDataReceived(const QuicStreamState& stream) {