Class HTTPSTraceClient

performance/https_trace_client.cpp:30–88

std::atomic<uint64_t> total_messages(0);

class HTTPSTraceClient : public HTTPSClient
{
public:
    HTTPSTraceClient(const std::shared_ptr<Service>& service, std::shared_ptr<SSLContext> context, const std::string& address, int port, int messages)
        : HTTPSClient(service, context, address, port),
          _messages(messages)
    {
    }

    void SendMessage() { SendRequestAsync(request().MakeTraceRequest("/")); }

protected:
    void onHandshaked() override
    {
        for (size_t i = _messages; i > 0; --i)
            SendMessage();
    }

    void onSent(size_t sent, size_t pending) override
    {
        _sent += sent;
        HTTPSClient::onSent(sent, pending);
    }

    void onReceived(const void* buffer, size_t size) override
    {
        _received += size;
        timestamp_stop = Timestamp::nano();
        total_bytes += size;
        HTTPSClient::onReceived(buffer, size);
    }

    void onReceivedResponse(const HTTPResponse& response) override
    {
        if (response.status() == 200)
            ++total_messages;
        else
            ++total_errors;
        SendMessage();
    }

    void onReceivedResponseError(const HTTPResponse& response, const std::string& error) override
    {
        std::cout << "Response error: " << error << std::endl;
        ++total_errors;
        SendMessage();
    }

    void onError(int error, const std::string& category, const std::string& message) override
    {
        std::cout << "HTTPS Trace client caught an error with code " << error << " and category '" << category << "': " << message << std::endl;
        ++total_errors;
    }

private:
    size_t _sent{0};
    size_t _received{0};
    size_t _messages{0};