преобразовать HTTP-запрос boost beast в строку и записать в ostringstream

Ваш код выглядит нормально. Фактически он работает со стандартными строковыми потоками:

Live On Coliru

#include <boost/beast/http.hpp>
#include <iostream>
#include <sstream>

namespace http = boost::beast::http;

#define PBLOG_INFO(a) do { std::clog << (a) << std::endl; } while(0);

int main() {
    std::string verb = "POST", req_str = "payload";
    using http::field;
    http::request<http::string_body> request;
    request.method_string(verb);
    request.target("server_endpoint");
    request.version(11);
    request.set(field::host, "hostname");
    request.set(field::accept, "*/*");
    request.set(field::authorization, "authorization_token");
    request.set(field::user_agent, "client_name");
    request.set(field::content_length, req_str.length());
    request.set(field::content_type, "application/x-www-form-urlencoded");
    request.set(field::connection, field::close);
    request.body() = req_str;
    request.prepare_payload();

    {
        std::ostringstream oss;
        oss <<"Request message " << request;
        PBLOG_INFO(oss.str());
        oss.clear();
    }
}

Печать

Request message POST server_endpoint HTTP/1.1
Host: hostname
Accept: */*
Authorization: authorization_token
User-Agent: client_name
Content-Type: application/x-www-form-urlencoded
Connection: Close
Content-Length: 7
payload

В чем проблема?

Проблема, по-видимому, в том, что перегрузки операторов потоковой передачи Beast не применяются к любому типу fast_ostringstream. Это по замыслу:

  no known conversion from 'framework::string_::fast_ostringstream'
  to 'std::ostream &' (aka 'basic_ostream<char> &')

Авторы fast_ostringstream явно жульничали в том смысле, что это могло быть быстро, но определенно не ostream& :).

Я попытался получить аналогичную ошибку, создав свой чит-поток:

struct my_cheat_stream {
    using Device = boost::iostreams::back_insert_device<std::string>;
    using Stream = boost::iostreams::stream<Device>;

    std::string buf;
    Stream _impl { buf };

    template <typename T> my_cheat_stream& operator<<(T&& rhs) {
        _impl << std::forward<T>(rhs);
        return *this;
    }

    std::string&&    str()&& { _impl.flush(); return std::move(buf); }
    std::string_view str()&  { _impl.flush(); return buf; }

    void clear() {
        buf.clear();
        _impl.clear(std::ios::failbit|std::ios::badbit);
    }
};

Однако просто компилируется, потому что, очевидно, operator<< <T>() просто применяется. Возможно, вы сможете исправить свой fast_ostringstream соответствующим образом или использовать что-нибудь еще.

Грязный обходной путь:

Вы можете использовать приведенный выше контрпример в качестве кредитного плеча:

template <typename Stream> struct wrap_non_std_stream {
    Stream& _wrapped;
    explicit wrap_non_std_stream(Stream& ref) : _wrapped(ref) {}

    template <typename T> auto& operator<<(T const& rhs) {
        _wrapped << rhs;
        return *this;
    }

    auto& operator<<(std::ostream&(*manip)(std::ostream&)) {
        _wrapped << manip;
        return *this;
    }
};

Теперь вы сможете

    fast_ostringstream oss;
    wrap_non_std_stream woss{oss};
    woss << "Request message " << request;

Если базовый поток поддерживает, он также будет поддерживать манипуляторы:

    woss << std::endl << std::fixed << std::boolalpha << std::flush;