diff --git a/api/include/opentelemetry/http/http_client.h b/api/include/opentelemetry/http/http_client.h index 82b7da6c1b..d658178936 100644 --- a/api/include/opentelemetry/http/http_client.h +++ b/api/include/opentelemetry/http/http_client.h @@ -1,68 +1,148 @@ #pragma once + +#include "opentelemetry/nostd/string_view.h" + OPENTELEMETRY_BEGIN_NAMESPACE namespace http { -enum class HttpMethod: uint8_t { - HTTP_GET, - HTTP_POST, - HTTP_DELETE, - HTTP_PUT, - HTTP_HEAD, - HTTP_PATCH -}; -enum class HttpResult: uint8_t { - HTTP_OK, - HTTP_ABORTED, - HTTP_LOCALFAILURE, - HTTP_REMOTEFAILURE +enum class HttpResult: uint8_t +{ + // Response has been received successfully from target server. + HttpResult_OK = 0, + + // Request has been aborted by the caller. The server might or + // might not have already received or processed the request. + HttpResult_Aborted = 1, + + // Local conditions have prevented the request from being sent + // (invalid request parameters, out of memory, internal error etc.) + HttpResult_LocalFailure = 2, + + // Network conditions somewhere between the local machine and + // the target server have caused the request to fail + // (connection failed, connection dropped abruptly etc.). + HttpResult_NetworkFailure = 3 + }; -class IHttpClient +// The HttpHeaders class contains a set of HTTP headers. +class HttpHeaders { public: - virtual IHttpRequest* CreateRequest() = 0; - virtual void SendRequest (IHttpRequest* request, IHttpResponse* response) = 0; - virtual void SendRequestAsync(IHttpRequest* request, IHttpResponseCallback* callback) = 0; - virtual void CancelRequestAsync(nostd::string_view const& id) = 0; - virtual void CancelAllRequests(); + // Inserts a name/value pair, and removes elements with the same name. + virtual void set(nostd::string_view const& name, nostd::string_view const& value) = 0; + + // Inserts a name/value pair + virtual void add(nostd::string_view const& name, nostd::string_view const& value) = 0; + + // Gets a string value given a name + virtual nostd::string_view const& get(nostd::string_view const& name) const = 0; + + // Tests whether the headers contains the specified name. + virtual bool has(nostd::string_view const& name) const = 0; }; -class IHttpRequest +// The HttpRequest class represents a Request object. +// Individual HTTP client implementations can implement the request object in +// the most efficient way. Either fill the request first, and then issue +// the underlying request, or create the real request immediately, and then forward +// the methods and set the individual parameters directly one by one. +class HttpRequest { public: - virtual nostd::string_view& GetId() = 0; + // Gets the request ID. + virtual const nostd::string_view& GetId() const = 0; + + // Sets the request Method virtual void SetMethod(nostd::string_view const& method) = 0; + + // Gets the request URI virtual void SetUrl(nostd::string_view const& url) = 0; - virtual HttpHeaders& GetHeaders() = 0; - virtual void SetBody(uint8_t* body, int len) = 0; - virtual void GetBody(uint8_t* body, int* len) = 0; + + // Gets the request Headers + virtual HttpHeaders* GetHeaders() const = 0; + + // Sets the request body + virtual void SetBody(const uint8_t* const body, const size_t len) = 0; + + // Gets the request body + virtual void GetBody(uint8_t* body, size_t& len) = 0; }; -class HttpHeaders +// The HttpResponse class represents a Response object. +// Individual HTTP client implementations can implement the response object +// in the most efficient way. Either copy all of the underlying data to a new +// structure, and provide it to the callback; or keep the real +// response data around, forward the methods, and retrieve the individual +// values directly one by one. +class HttpResponse { public: - virtual void set(nostd::string_view const& name, nostd::string_view const& value) = 0; - virtual void add(nostd::string_view const& name, nostd::string_view const& value) = 0; - virtual nostd::string_view const& get(nostd::string_view const& name) = 0; - virtual bool has(nostd::string_view const& name) = 0; + // Gets the response ID. + virtual const nostd::string_view& GetId() = 0; + + // Get the response result code. + virtual HttpResult GetResult() = 0; + + // Gets the response status code. + virtual unsigned GetStatusCode() = 0; + + // Gets the response headers. + virtual HttpHeaders* GetHeaders() = 0; + + // Gets the response body. + virtual void GetBody(uint8_t* body, size_t& len) = 0; }; -class IHttpResponse +// The HttpResponseCallback class receives HTTP client responses +class HttpResponseCallback { public: - virtual nostd::string_view& GetId() = 0; - virtual HttpResult GetResult() = 0; - virtual unsigned GetStatusCode() = 0; - virtual HttpHeaders& GetHeaders() = 0; - virtual void GetBody(uint8_t* body, int* len) = 0; + // Called when an HTTP request completes. + // The passed response object contains details about the exact way the + // request finished (HTTP status code, headers, content, error codes + // etc.). The ownership of the response object is transferred to the + // callback object. It can store it for later if necessary. Finally, it + // must be deleted using its virtual destructor. + virtual void OnHttpResponse(HttpResponse* response) = 0; }; -class IHttpResponseCallback +// The HttpClient class is the interface for HTTP client implementations. +class HttpClient { public: - virtual void OnHttpResponse(IHttpResponse* response) = 0; + + // Creates an empty HTTP request object. + // The created request object has only its ID prepopulated. Other fields + // must be set by the caller. The request object can then be sent + // using SendRequestAsync(). If you are not going to use the request object + // then you can delete it safely using its virtual destructor. + virtual HttpRequest* CreateRequest() = 0; + + // Begins an HTTP request. + // The method takes ownership of the passed request, and can destroy it before + // returning to the caller. Do not access the request object in any + // way after this invocation, and do not delete it. + // The callback object is always called, even if the request is + // cancelled, or if an error occurs immediately during sending. In the + // latter case, the OnHttpResponse() callback is called before this + // method returns. You must keep the callback object alive until its + // OnHttpResponse() callback is called. + virtual void SendRequestAsync(HttpRequest* request, HttpResponseCallback* callback) = 0; + + // Cancels an HTTP request. + // The caller must provide a string ID returned earlier by request->GetId(). + // The request is cancelled asynchronously. The caller must still + // wait for the relevant OnHttpResponse() callback (it can just come + // earlier with some "aborted" error status). + virtual void CancelRequestAsync(nostd::string_view const& id) = 0; + + virtual void CancelAllRequests() + { + } }; + } // namespace nostd OPENTELEMETRY_END_NAMESPACE diff --git a/sdk/include/opentelemetry/sdk/http/http_client.h b/sdk/include/opentelemetry/sdk/http/http_client.h index e47b9b4d07..d2b6218432 100644 --- a/sdk/include/opentelemetry/sdk/http/http_client.h +++ b/sdk/include/opentelemetry/sdk/http/http_client.h @@ -1,8 +1,10 @@ #pragma once #include "opentelemetry/http/http_client.h" - #include "opentelemetry/version.h" +#include +#include + OPENTELEMETRY_BEGIN_NAMESPACE namespace sdk { @@ -10,13 +12,14 @@ namespace http { namespace http_api = opentelemetry::http; +// HttpHeaders implementation class HttpHeaders: http_api::HttpHeaders, std::multimap { public: virtual void set(nostd::string_view const& name, nostd::string_view const& value) override { - auto range = equal_range(name); + auto range = equal_range(std::string(name.data())); auto hint = erase(range.first, range.second); insert(hint, std::make_pair(name, value)); } @@ -28,47 +31,55 @@ class HttpHeaders: http_api::HttpHeaders, std::multimapsecond : m_empty; } virtual bool has(nostd::string_view const& name) const override { - auto it = find(name); + auto it = find(std::string(name.data())); return (it != end()); } + private: - nostd::string_view m_empty; + + nostd::string_view m_empty{}; }; -class SimpleHttpRequest:: public http_api::IHttpRequest +class SimpleHttpRequest: public http_api::HttpRequest { public: - SimpleHttpRequest(std::string const& id): _id(id), method_("GET") + + SimpleHttpRequest(nostd::string_view const& id): id_(id), method_("GET") { } - - virtual nostd::string_view& GetId() const override + + // Gets the HTTP request ID. + virtual const nostd::string_view& GetId() const override { return id_; } + // Sets the request method virtual void SetMethod(nostd::string_view const& method) override { method_ = method; } - virtual void SetUrl(std::string const& url) override + // Sets the HTTP request URI. + virtual void SetUrl(nostd::string_view const& url) override { url_ = url; } - virtual HttpHeaders& GetHeaders() override + // Gets the HTTP request headers. + virtual http_api::HttpHeaders* GetHeaders() const override { return headers_; } - virtual void SetBody(const uint8_t* const body, int len) override + // Sets the request body. + virtual void SetBody(const uint8_t* const body, const size_t len) override { for (int i = 0; i < len; i++) { @@ -76,36 +87,37 @@ class SimpleHttpRequest:: public http_api::IHttpRequest } } - virtual void GetBody(uint8_t* body, int* len) override + virtual void GetBody(uint8_t* body, size_t& len) override { - int i = 0; + len = 0; for (auto &e: body_) { - body_[i++] = e; + body[len++] = e; } - return body_; + len = (len > 0 ) ? len - 1 : len ; } private: - + http_api::HttpHeaders* headers_; std::vector body_; - std::string method_; - std::string id_; - std::string url_; + nostd::string_view method_; + nostd::string_view id_; + nostd::string_view url_; + }; -class SimpleHttpResponse: public IHttpResponse +class SimpleHttpResponse: public http_api::HttpResponse { public: SimpleHttpResponse(nostd::string_view const& id): - id_(id), m - result_(HTTP_LOCALFAULURE), + id_(id), + result_(http_api::HttpResult::HttpResult_LocalFailure), statusCode_(0) { } - virtual HttpResult GetResult() override + virtual http_api::HttpResult GetResult() override { return result_; } @@ -115,33 +127,27 @@ class SimpleHttpResponse: public IHttpResponse return statusCode_; } - virtual HttpHeaders& GetHeaders() override + virtual http_api::HttpHeaders* GetHeaders() override { return headers_; } - virtual void GetBody(uint8_t* body, int& len) override + virtual void GetBody(uint8_t* body, size_t& len) override { int i = 0; for (auto &e: body_) { body_[i++] = e; } - return body_; } private: nostd::string_view id_; unsigned statusCode_; - HttpHeaders headers_; + http_api::HttpHeaders* headers_; + http_api::HttpResult result_; std::vector body_; }; } //http } //sdk OPENTELEMETRY_END_NAMESPACE - - - - - -