mvfst/quic/logging/QLogger.cpp

/*
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 */

#include <quic/logging/QLogger.h>

#include <folly/dynamic.h>
#include <quic/codec/Types.h>
#include <quic/logging/QLoggerConstants.h>
#include <quic/logging/QLoggerTypes.h>

namespace {
void addQuicSimpleFrameToEvent(
    quic::QLogPacketEvent* event,
    const quic::QuicSimpleFrame& simpleFrame) {
  folly::variant_match(
      simpleFrame,
      [&](const quic::StopSendingFrame& frame) {
        event->frames.push_back(std::make_unique<quic::StopSendingFrameLog>(
            frame.streamId, frame.errorCode));
      },
      [&](const quic::MinStreamDataFrame& frame) {
        event->frames.push_back(std::make_unique<quic::MinStreamDataFrameLog>(
            frame.streamId, frame.maximumData, frame.minimumStreamOffset));
      },
      [&](const quic::ExpiredStreamDataFrame& frame) {
        event->frames.push_back(
            std::make_unique<quic::ExpiredStreamDataFrameLog>(
                frame.streamId, frame.minimumStreamOffset));
      },
      [&](const quic::PathChallengeFrame& frame) {
        event->frames.push_back(
            std::make_unique<quic::PathChallengeFrameLog>(frame.pathData));
      },
      [&](const quic::PathResponseFrame& frame) {
        event->frames.push_back(
            std::make_unique<quic::PathResponseFrameLog>(frame.pathData));
      },
      [&](const quic::NewConnectionIdFrame& frame) {
        event->frames.push_back(std::make_unique<quic::NewConnectionIdFrameLog>(
            frame.sequenceNumber, frame.token));
      },
      [&](const quic::MaxStreamsFrame& frame) {
        event->frames.push_back(std::make_unique<quic::MaxStreamsFrameLog>(
            frame.maxStreams, frame.isForBidirectional));
      },
      [&](const quic::RetireConnectionIdFrame& frame) {
        event->frames.push_back(
            std::make_unique<quic::RetireConnectionIdFrameLog>(
                frame.sequenceNumber));
      });
}
} // namespace

namespace quic {
std::unique_ptr<QLogPacketEvent> QLogger::createPacketEvent(
    const RegularQuicPacket& regularPacket,
    uint64_t packetSize) {
  auto event = std::make_unique<QLogPacketEvent>();
  event->refTime = std::chrono::duration_cast<std::chrono::microseconds>(
      std::chrono::steady_clock::now() - refTimePoint);
  event->packetSize = packetSize;
  event->eventType = QLogEventType::PacketReceived;
  const ShortHeader* shortHeader = regularPacket.header.asShort();
  if (shortHeader) {
    event->packetType = kShortHeaderPacketType.toString();
  } else {
    event->packetType =
        toString(regularPacket.header.asLong()->getHeaderType());
  }
  if (event->packetType != toString(LongHeader::Types::Retry)) {
    // A Retry packet does not include a packet number.
    event->packetNum = regularPacket.header.getPacketSequenceNum();
  }

  uint64_t numPaddingFrames = 0;
  // looping through the packet to store logs created from frames in the packet
  for (const auto& quicFrame : regularPacket.frames) {
    switch (quicFrame.type()) {
      case QuicFrame::Type::PaddingFrame_E: {
        ++numPaddingFrames;
        break;
      }
      case QuicFrame::Type::RstStreamFrame_E: {
        const auto& frame = *quicFrame.asRstStreamFrame();
        event->frames.push_back(std::make_unique<RstStreamFrameLog>(
            frame.streamId, frame.errorCode, frame.offset));
        break;
      }
      case QuicFrame::Type::ConnectionCloseFrame_E: {
        const auto& frame = *quicFrame.asConnectionCloseFrame();
        event->frames.push_back(std::make_unique<ConnectionCloseFrameLog>(
            frame.errorCode, frame.reasonPhrase, frame.closingFrameType));
        break;
      }
      case QuicFrame::Type::ApplicationCloseFrame_E: {
        const auto& frame = *quicFrame.asApplicationCloseFrame();
        event->frames.push_back(std::make_unique<ApplicationCloseFrameLog>(
            frame.errorCode, frame.reasonPhrase));
        break;
      }
      case QuicFrame::Type::MaxDataFrame_E: {
        const auto& frame = *quicFrame.asMaxDataFrame();
        event->frames.push_back(
            std::make_unique<MaxDataFrameLog>(frame.maximumData));
        break;
      }
      case QuicFrame::Type::MaxStreamDataFrame_E: {
        const auto& frame = *quicFrame.asMaxStreamDataFrame();
        event->frames.push_back(std::make_unique<MaxStreamDataFrameLog>(
            frame.streamId, frame.maximumData));
        break;
      }
      case QuicFrame::Type::PingFrame_E: {
        event->frames.push_back(std::make_unique<PingFrameLog>());
        break;
      }
      case QuicFrame::Type::DataBlockedFrame_E: {
        const auto& frame = *quicFrame.asDataBlockedFrame();
        event->frames.push_back(
            std::make_unique<DataBlockedFrameLog>(frame.dataLimit));
        break;
      }
      case QuicFrame::Type::StreamDataBlockedFrame_E: {
        const auto& frame = *quicFrame.asStreamDataBlockedFrame();
        event->frames.push_back(std::make_unique<StreamDataBlockedFrameLog>(
            frame.streamId, frame.dataLimit));
        break;
      }
      case QuicFrame::Type::StreamsBlockedFrame_E: {
        const auto& frame = *quicFrame.asStreamsBlockedFrame();
        event->frames.push_back(std::make_unique<StreamsBlockedFrameLog>(
            frame.streamLimit, frame.isForBidirectional));
        break;
      }
      case QuicFrame::Type::ReadAckFrame_E: {
        const auto& frame = *quicFrame.asReadAckFrame();
        event->frames.push_back(
            std::make_unique<ReadAckFrameLog>(frame.ackBlocks, frame.ackDelay));
        break;
      }
      case QuicFrame::Type::ReadStreamFrame_E: {
        const auto& frame = *quicFrame.asReadStreamFrame();
        event->frames.push_back(std::make_unique<StreamFrameLog>(
            frame.streamId, frame.offset, frame.data->length(), frame.fin));
        break;
      }
      case QuicFrame::Type::ReadCryptoFrame_E: {
        const auto& frame = *quicFrame.asReadCryptoFrame();
        event->frames.push_back(std::make_unique<CryptoFrameLog>(
            frame.offset, frame.data->length()));
        break;
      }
      case QuicFrame::Type::ReadNewTokenFrame_E: {
        event->frames.push_back(std::make_unique<ReadNewTokenFrameLog>());
        break;
      }
      case QuicFrame::Type::QuicSimpleFrame_E: {
        const auto& simpleFrame = *quicFrame.asQuicSimpleFrame();
        addQuicSimpleFrameToEvent(event.get(), simpleFrame);
        break;
      }
      case QuicFrame::Type::NoopFrame_E: {
        break;
      }
    }
  }
  if (numPaddingFrames > 0) {
    event->frames.push_back(
        std::make_unique<PaddingFrameLog>(numPaddingFrames));
  }
  return event;
}

std::unique_ptr<QLogPacketEvent> QLogger::createPacketEvent(
    const RegularQuicWritePacket& writePacket,
    uint64_t packetSize) {
  auto event = std::make_unique<QLogPacketEvent>();
  event->refTime = std::chrono::duration_cast<std::chrono::microseconds>(
      std::chrono::steady_clock::now() - refTimePoint);
  event->packetNum = writePacket.header.getPacketSequenceNum();
  event->packetSize = packetSize;
  event->eventType = QLogEventType::PacketSent;
  const ShortHeader* shortHeader = writePacket.header.asShort();
  if (shortHeader) {
    event->packetType = kShortHeaderPacketType.toString();
  } else {
    event->packetType = toString(writePacket.header.asLong()->getHeaderType());
  }

  uint64_t numPaddingFrames = 0;
  // looping through the packet to store logs created from frames in the packet
  for (const auto& quicFrame : writePacket.frames) {
    switch (quicFrame.type()) {
      case QuicWriteFrame::Type::PaddingFrame_E:
        ++numPaddingFrames;
        break;
      case QuicWriteFrame::Type::RstStreamFrame_E: {
        const RstStreamFrame& frame = *quicFrame.asRstStreamFrame();
        event->frames.push_back(std::make_unique<RstStreamFrameLog>(
            frame.streamId, frame.errorCode, frame.offset));
        break;
      }
      case QuicWriteFrame::Type::ConnectionCloseFrame_E: {
        const ConnectionCloseFrame& frame = *quicFrame.asConnectionCloseFrame();
        event->frames.push_back(std::make_unique<ConnectionCloseFrameLog>(
            frame.errorCode, frame.reasonPhrase, frame.closingFrameType));
        break;
      }
      case QuicWriteFrame::Type::ApplicationCloseFrame_E: {
        const ApplicationCloseFrame& frame =
            *quicFrame.asApplicationCloseFrame();
        event->frames.push_back(std::make_unique<ApplicationCloseFrameLog>(
            frame.errorCode, frame.reasonPhrase));
        break;
      }
      case QuicWriteFrame::Type::MaxDataFrame_E: {
        const MaxDataFrame& frame = *quicFrame.asMaxDataFrame();
        event->frames.push_back(
            std::make_unique<MaxDataFrameLog>(frame.maximumData));
        break;
      }
      case QuicWriteFrame::Type::MaxStreamDataFrame_E: {
        const MaxStreamDataFrame& frame = *quicFrame.asMaxStreamDataFrame();
        event->frames.push_back(std::make_unique<MaxStreamDataFrameLog>(
            frame.streamId, frame.maximumData));
        break;
      }
      case QuicWriteFrame::Type::StreamsBlockedFrame_E: {
        const StreamsBlockedFrame& frame = *quicFrame.asStreamsBlockedFrame();
        event->frames.push_back(std::make_unique<StreamsBlockedFrameLog>(
            frame.streamLimit, frame.isForBidirectional));
        break;
      }
      case QuicWriteFrame::Type::PingFrame_E:
        event->frames.push_back(std::make_unique<PingFrameLog>());
        break;
      case QuicWriteFrame::Type::DataBlockedFrame_E: {
        const DataBlockedFrame& frame = *quicFrame.asDataBlockedFrame();
        event->frames.push_back(
            std::make_unique<DataBlockedFrameLog>(frame.dataLimit));
        break;
      }
      case QuicWriteFrame::Type::StreamDataBlockedFrame_E: {
        const StreamDataBlockedFrame& frame = *quicFrame.asStreamDataBlockedFrame();
        event->frames.push_back(std::make_unique<StreamDataBlockedFrameLog>(
            frame.streamId, frame.dataLimit));
        break;
      }
      case QuicWriteFrame::Type::WriteAckFrame_E: {
        const WriteAckFrame& frame = *quicFrame.asWriteAckFrame();
        event->frames.push_back(std::make_unique<WriteAckFrameLog>(
            frame.ackBlocks, frame.ackDelay));
        break;
      }
      case QuicWriteFrame::Type::WriteStreamFrame_E: {
        const WriteStreamFrame& frame = *quicFrame.asWriteStreamFrame();
        event->frames.push_back(std::make_unique<StreamFrameLog>(
            frame.streamId, frame.offset, frame.len, frame.fin));
        break;
      }
      case QuicWriteFrame::Type::WriteCryptoFrame_E: {
        const WriteCryptoFrame& frame = *quicFrame.asWriteCryptoFrame();
        event->frames.push_back(
            std::make_unique<CryptoFrameLog>(frame.offset, frame.len));
        break;
      }
      case QuicWriteFrame::Type::QuicSimpleFrame_E: {
        const QuicSimpleFrame& simpleFrame = *quicFrame.asQuicSimpleFrame();
        addQuicSimpleFrameToEvent(event.get(), simpleFrame);
        break;
      }
      default:
        break;
    }
  }
  if (numPaddingFrames > 0) {
    event->frames.push_back(
        std::make_unique<PaddingFrameLog>(numPaddingFrames));
  }
  return event;
}

std::unique_ptr<QLogVersionNegotiationEvent> QLogger::createPacketEvent(
    const VersionNegotiationPacket& versionPacket,
    uint64_t packetSize,
    bool isPacketRecvd) {
  auto event = std::make_unique<QLogVersionNegotiationEvent>();
  event->refTime = std::chrono::duration_cast<std::chrono::microseconds>(
      std::chrono::steady_clock::now() - refTimePoint);
  event->packetSize = packetSize;
  event->eventType =
      isPacketRecvd ? QLogEventType::PacketReceived : QLogEventType::PacketSent;
  event->packetType = kVersionNegotiationPacketType;
  event->versionLog = std::make_unique<VersionNegotiationLog>(
      VersionNegotiationLog(versionPacket.versions));
  return event;
}

std::string getFlowControlEvent(int offset) {
  return "flow control event, new offset: " + folly::to<std::string>(offset);
};

std::string
getRxStreamWU(StreamId streamId, PacketNum packetNum, uint64_t maximumData) {
  return "rx stream, streamId: " + folly::to<std::string>(streamId) +
      ", packetNum: " + folly::to<std::string>(packetNum) +
      ", maximumData: " + folly::to<std::string>(maximumData);
};

std::string getRxConnWU(PacketNum packetNum, uint64_t maximumData) {
  return "rx, packetNum: " + folly::to<std::string>(packetNum) +
      ", maximumData: " + folly::to<std::string>(maximumData);
};

std::string getPeerClose(const std::string& peerCloseReason) {
  return "error message: " + peerCloseReason;
};

std::string getFlowControlWindowAvailable(uint64_t windowAvailable) {
  return "on flow control, window available: " +
      folly::to<std::string>(windowAvailable);
};

std::string getClosingStream(const std::string& streamId) {
  return "closing stream, stream id: " + streamId;
};

} // namespace quic