Revision control
++ /// Copyright (C) 2026 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
++
++ #include "interceptors.h"
++ #include "clientguide.qpb.h"
++
++ #include <QtProtobuf/QAbstractProtobufSerializer>
++
++ #include <QtGrpc/QAbstractGrpcChannel>
++ #include <QtGrpc/QGrpcCallOptions>
++ #include <QtGrpc/QGrpcStatus>
++
++ #include <QtCore/QDebug>
++ #include <QtCore/QDateTime>
++ #include <QtCore/QUuid>
++ #include <QtCore/QMultiHash>
++
++ using namespace Qt::Literals::StringLiterals;
++
++ //! [metrics-2]
++ MetricsInterceptor::~MetricsInterceptor()
++ {
++ Q_ASSERT(m_activeRPCs.isEmpty());
++ const auto keys = m_metrics.keys();
++ for (const auto &k : keys) {
++ qInfo() << "Metrics for:" << k;
++ const auto &m = m_metrics[k];
++ qInfo() << " Bytes received :" << m.bytesReceived;
++ qInfo() << " Failed RPCs :" << m.failed;
++ qInfo() << " Completed RPCs :" << m.completed;
++ qInfo() << " Completed Durations (ms):" << m.durations;
++ }
++ }
++ //! [metrics-2]
++
++ //! [metrics-1]
++ QGrpcStartInterceptor::Continuation
++ MetricsInterceptor::onStart(QGrpcInterceptionContext &context,
++ QProtobufMessage & /*message*/,
++ QGrpcCallOptions &callOptions)
++ {
++ m_activeRPCs.insert(context.operationId(), std::chrono::steady_clock::now());
++ callOptions.addMetadata("x-trace-id"_L1, QUuid::createUuid().toByteArray());
++
++ return Continuation::Proceed;
++ }
++
++ void MetricsInterceptor::onMessageReceived(QGrpcInterceptionContext &context,
++ QByteArray &messageData)
++ {
++ m_metrics[context.descriptor()].bytesReceived += messageData.size();
++ }
++
++ void MetricsInterceptor::onFinished(QGrpcInterceptionContext &context,
++ QGrpcStatus &status)
++ {
++ const auto it = m_activeRPCs.find(context.operationId());
++ Q_ASSERT(it != m_activeRPCs.cend());
++
++ const auto duration = Ms(Clock::now() - it.value()).count();
++ m_activeRPCs.erase(it);
++
++ auto &metrics = m_metrics[context.descriptor()];
++ if (!status.isOk()) {
++ ++metrics.failed;
++ return;
++ }
++ ++metrics.completed;
++ metrics.durations.append(duration);
++ }
++ //! [metrics-1]
++
++ //! [auth-1]
++ TokenProvider::TokenProvider() { refresh(); }
++ QByteArray TokenProvider::token() { return m_token; }
++ void TokenProvider::refresh()
++ {
++ // NOTE: This is NOT a real JWT or secure token.
++ // It only mimics the structure: header.payload.signature
++ // The payload is just a timestamp used for expiry checks.
++ auto header = R"({"alg":"none","typ":"JWT"})"_ba; // fake header
++ auto payload = QByteArray::number(now()); // fake "iat"
++ auto signature = "no_signature"_ba; // fake signing
++
++ m_token = header + '.' + payload + '.' + signature;
++ }
++ //! [auth-1]
++
++ //! [auth-2]
++ QGrpcStartInterceptor::Continuation
++ AuthInterceptor::onStart(QGrpcInterceptionContext & /*context*/,
++ QProtobufMessage & /*messasge*/,
++ QGrpcCallOptions &callOptions)
++ {
++ constexpr QByteArrayView AuthKey("authorization");
++
++ if (!callOptions.metadata(QtGrpc::MultiValue).contains(AuthKey))
++ callOptions.addMetadata(AuthKey, "Bearer " + m_tokenProvider.token());
++
++ return Continuation::Proceed;
++ }
++
++ void AuthInterceptor::onTrailingMetadata(QGrpcInterceptionContext & /*context*/,
++ QMultiHash<QByteArray, QByteArray> &metadata)
++ {
++ constexpr QByteArrayView AuthErrorKey("www-authenticate");
++ const auto it = metadata.constFind(AuthErrorKey);
++ if (it == metadata.cend())
++ return;
++ m_serverAuthHint = it.value();
++ }
++
++ void AuthInterceptor::onFinished(QGrpcInterceptionContext & /*context*/, QGrpcStatus &status)
++ {
++ // Only handle Unauthenticated status codes.
++ if (status.code() != QtGrpc::StatusCode::Unauthenticated)
++ return;
++
++ qDebug("[AuthInterceptor] Refreshing token for next call");
++ // NOTE: Simplified for example. Real tokens are obtained via proper auth flow.
++ m_tokenProvider.refresh();
++ if (!m_serverAuthHint.isEmpty()) {
++ status = QGrpcStatus{ status.code(), status.message() + u", Hint: "_s + m_serverAuthHint };
++ m_serverAuthHint.clear();
++ }
++ }
++ //! [auth-2]
++
++ namespace {
++
++ //! [sanitizing-1]
++ qsizetype getTotalBytes(const QMultiHash<QByteArray, QByteArray> &md)
++ {
++ qsizetype total = 0;
++ for (const auto &[k, v] : md.asKeyValueRange())
++ total += k.size() + v.size();
++ return total;
++ }
++
++ template <typename T>
++ void sanitizeMessage(T &request)
++ {
++ const auto num = request.num();
++ if (num < 0 || num > 5)
++ request.setNum(qBound(0, num, 5));
++
++ const auto time = request.time();
++ const auto currentTime = now();
++ if (time < 0 || time > currentTime)
++ request.setTime(qMax(0, currentTime));
++ }
++ //! [sanitizing-1]
++
++ } // namespace
++
++ //! [sanitizing-2]
++ QGrpcStartInterceptor::Continuation
++ SanitizingInterceptor::onStart(QGrpcInterceptionContext &context, QProtobufMessage &message,
++ QGrpcCallOptions &callOptions)
++ {
++ constexpr quint16 MaxMetadata = 1024 * 8; // 8 KiB
++ auto totalMdBytes = getTotalBytes(callOptions.metadata(QtGrpc::MultiValue));
++ if (totalMdBytes > MaxMetadata) {
++ qDebug() << "[Sanitizing] Aborting call with metadata size of" << totalMdBytes << "bytes";
++ return Continuation::Drop;
++ }
++
++ onWriteMessage(context, message);
++
++ return Continuation::Proceed;
++ }
++
++ void SanitizingInterceptor::onWriteMessage(QGrpcInterceptionContext & /*context*/,
++ QProtobufMessage &message)
++ {
++ // For handling more complex scenarios with various Request message types,
++ // it would make sense to branch on the context.descriptor() appropriately.
++ if (auto *request = qprotobufmessage_cast<client::guide::Request *>(&message))
++ sanitizeMessage(*request);
++ }
++
++ void SanitizingInterceptor::onMessageReceived(QGrpcInterceptionContext &context,
++ QByteArray &messageData)
++ {
++ // messageData can only be of type client::guide::Response. For more
++ // complex handling add appropriate handling with context.descriptor().
++ // Note that the deserialization and serialization introduces overhead.
++ client::guide::Response response;
++ auto serializer = context.channel().serializer();
++ if (serializer->deserialize(&response, messageData))
++ return;
++ sanitizeMessage(response);
++ messageData = serializer->serialize(&response);
++ }
++ //! [sanitizing-2]