http_transport.h

Go to the documentation of this file.

#pragma once
 
// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
 
#include "../core/result_types.h"
#include "../core/error_codes.h"
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <chrono>
#include <memory>
#include <functional>
#include <iostream>
 
namespace kcenon { namespace monitoring {
 
struct http_request {
    std::string url;
    std::string method{"POST"};
    std::unordered_map<std::string, std::string> headers;
    std::vector<uint8_t> body;
    std::chrono::milliseconds timeout{30000};
    bool enable_compression{false};
};
 
struct http_response {
    int status_code{0};
    std::string status_message;
    std::unordered_map<std::string, std::string> headers;
    std::vector<uint8_t> body;
    std::chrono::milliseconds elapsed{0};
};
 
class http_transport {
public:
    virtual ~http_transport() = default;
 
    virtual common::Result<http_response> send(const http_request& request) = 0;
 
    virtual bool is_available() const = 0;
 
    virtual std::string name() const = 0;
};
 
class stub_http_transport : public http_transport {
private:
    std::function<http_response(const http_request&)> response_handler_;
    bool simulate_success_{true};
 
public:
    stub_http_transport() = default;
 
    void set_response_handler(std::function<http_response(const http_request&)> handler) {
        response_handler_ = std::move(handler);
    }
 
    void set_simulate_success(bool success) {
        simulate_success_ = success;
    }
 
    common::Result<http_response> send(const http_request& request) override {
        if (response_handler_) {
            return common::ok(response_handler_(request));
        }
 
        http_response response;
        if (simulate_success_) {
            response.status_code = 202; // Accepted
            response.status_message = "Accepted";
        } else {
            response.status_code = 503; // Service Unavailable
            response.status_message = "Service Unavailable";
        }
        response.elapsed = std::chrono::milliseconds(10);
 
        return common::ok(response);
    }
 
    bool is_available() const override {
        return true;
    }
 
    std::string name() const override {
        return "stub";
    }
};
 
class simple_http_client : public http_transport {
private:
    std::chrono::milliseconds default_timeout_{30000};
    bool use_tls_{false};
 
public:
    explicit simple_http_client(std::chrono::milliseconds timeout = std::chrono::milliseconds(30000))
        : default_timeout_(timeout) {}
 
    common::Result<http_response> send(const http_request& request) override {
        // Parse URL to extract host, port, and path
        auto url_parts = parse_url(request.url);
        if (!url_parts.valid) {
            error_info err(monitoring_error_code::invalid_configuration,
                          "Invalid URL: " + request.url);
            return common::Result<http_response>::err(err.to_common_error());
        }
 
        use_tls_ = url_parts.scheme == "https";
 
        // No real HTTP transport available. Return error instead of
        // fake 202 success, so callers know data was NOT sent.
        // Build with MONITORING_WITH_NETWORK_SYSTEM=ON for real transport.
        static bool warned = false;
        if (!warned)
        {
            std::cerr << "[monitoring_system] WARNING: Trace export configured but no HTTP "
                      << "transport available. Build with MONITORING_WITH_NETWORK_SYSTEM=ON "
                      << "or provide a real http_transport implementation. "
                      << "Trace data is NOT being exported.\n";
            warned = true;
        }
 
        error_info err(monitoring_error_code::invalid_configuration,
                      "No HTTP transport available (stub mode)");
        return common::Result<http_response>::err(err.to_common_error());
    }
 
    bool is_available() const override {
        // Stub transport cannot actually send data
        return false;
    }
 
    std::string name() const override {
        return "stub";
    }
 
private:
    struct url_parts {
        std::string scheme;
        std::string host;
        int port{80};
        std::string path;
        bool valid{false};
    };
 
    url_parts parse_url(const std::string& url) {
        url_parts parts;
 
        // Find scheme
        auto scheme_end = url.find("://");
        if (scheme_end == std::string::npos) {
            return parts;
        }
        parts.scheme = url.substr(0, scheme_end);
 
        // Find host and port
        auto host_start = scheme_end + 3;
        auto path_start = url.find('/', host_start);
        if (path_start == std::string::npos) {
            path_start = url.length();
        }
 
        auto host_port = url.substr(host_start, path_start - host_start);
        auto colon_pos = host_port.find(':');
        if (colon_pos != std::string::npos) {
            parts.host = host_port.substr(0, colon_pos);
            try {
                parts.port = std::stoi(host_port.substr(colon_pos + 1));
            } catch (...) {
                return parts;
            }
        } else {
            parts.host = host_port;
            parts.port = (parts.scheme == "https") ? 443 : 80;
        }
 
        // Extract path
        if (path_start < url.length()) {
            parts.path = url.substr(path_start);
        } else {
            parts.path = "/";
        }
 
        parts.valid = !parts.host.empty();
        return parts;
    }
};
 
#ifdef MONITORING_HAS_NETWORK_SYSTEM
#include <kcenon/network/core/http_client.h>
 
class network_http_transport : public http_transport {
private:
    std::shared_ptr<network_system::core::http_client> client_;
 
public:
    explicit network_http_transport(std::chrono::milliseconds timeout = std::chrono::milliseconds(30000))
        : client_(std::make_shared<network_system::core::http_client>(timeout)) {}
 
    common::Result<http_response> send(const http_request& request) override {
        // Convert headers from unordered_map to map
        std::map<std::string, std::string> headers(request.headers.begin(), request.headers.end());
 
        // Make the actual HTTP request using network_system
        network_system::core::Result<network_system::core::internal::http_response> net_result;
 
        if (request.method == "GET") {
            net_result = client_->get(request.url, {}, headers);
        } else if (request.method == "POST") {
            net_result = client_->post(request.url, request.body, headers);
        } else if (request.method == "PUT") {
            std::string body_str(request.body.begin(), request.body.end());
            net_result = client_->put(request.url, body_str, headers);
        } else if (request.method == "DELETE") {
            net_result = client_->del(request.url, headers);
        } else if (request.method == "HEAD") {
            net_result = client_->head(request.url, headers);
        } else if (request.method == "PATCH") {
            std::string body_str(request.body.begin(), request.body.end());
            net_result = client_->patch(request.url, body_str, headers);
        } else {
            return common::make_error<http_response>(static_cast<int>(monitoring_error_code::invalid_configuration),
                "Unsupported HTTP method: " + request.method);
        }
 
        if (!net_result) {
            return common::make_error<http_response>(static_cast<int>(monitoring_error_code::operation_failed),
                "HTTP request failed: " + net_result.error().message);
        }
 
        // Convert network_system response to monitoring response
        http_response response;
        response.status_code = net_result->status_code;
        response.status_message = net_result->status_text;
        response.body = net_result->body;
 
        // Convert headers
        for (const auto& [key, value] : net_result->headers) {
            response.headers[key] = value;
        }
 
        return common::ok(response);
    }
 
    bool is_available() const override {
        return true;
    }
 
    std::string name() const override {
        return "network_system";
    }
};
#endif // MONITORING_HAS_NETWORK_SYSTEM
 
inline std::unique_ptr<http_transport> create_default_transport() {
#ifdef MONITORING_HAS_NETWORK_SYSTEM
    return std::make_unique<network_http_transport>();
#else
    return std::make_unique<simple_http_client>();
#endif
}
 
inline std::unique_ptr<stub_http_transport> create_stub_transport() {
    return std::make_unique<stub_http_transport>();
}
 
#ifdef MONITORING_HAS_NETWORK_SYSTEM
inline std::unique_ptr<network_http_transport> create_network_transport(
    std::chrono::milliseconds timeout = std::chrono::milliseconds(30000)) {
    return std::make_unique<network_http_transport>(timeout);
}
#endif
 
} } // namespace kcenon::monitoring