#include <Server/PrometheusRequestHandler.h>

#include <IO/HTTPCommon.h>

#include <IO/ReadBuffer.h>

#include <Server/HTTP/WriteBufferFromHTTPServerResponse.h>

#include <Server/HTTP/sendExceptionToHTTPClient.h>

#include <Server/HTTPHandler.h>

#include <Server/IServer.h>

#include <Server/PrometheusMetricsWriter.h>

#include <base/scope_guard.h>

#include <Poco/Net/HTTPRequest.h>

#include <Poco/Net/HTTPResponse.h>

#include <Poco/URI.h>

#include <Common/logger_useful.h>

#include <Common/maskSensitiveQueryParameters.h>

#include <Common/setThreadName.h>

#include "config.h"

#include <Access/Credentials.h>

#include <Common/CurrentThread.h>

#include <Common/StringUtils.h>

#include <Common/QueryScope.h>

#include <IO/SnappyBasicReadBuffer.h>

#include <IO/SnappyBasicWriteBuffer.h>

#include <IO/ZstdInflatingReadBuffer.h>

#include <IO/Protobuf/ProtobufZeroCopyInputStreamFromReadBuffer.h>

#include <IO/Protobuf/ProtobufZeroCopyOutputStreamFromWriteBuffer.h>

#include <Interpreters/Context.h>

#include <Interpreters/DatabaseCatalog.h>

#include <Interpreters/Session.h>

#include <Server/HTTP/HTMLForm.h>

#include <Server/HTTP/authenticateUserByHTTP.h>

#include <Server/HTTP/checkHTTPHeader.h>

#include <Server/HTTP/setReadOnlyIfHTTPMethodIdempotent.h>

#include <IO/WriteBufferFromString.h>

#include <IO/WriteHelpers.h>

#include <Core/Settings.h>

#include <Parsers/Prometheus/PrometheusQueryTree.h>

#include <Storages/TimeSeries/PrometheusRemoteReadProtocol.h>

#include <Storages/TimeSeries/PrometheusRemoteWriteProtocol.h>

#include <Storages/TimeSeries/PrometheusHTTPProtocolAPI.h>

namespace DB

{

namespace Setting

{

extern const SettingsUInt64 http_response_buffer_size;

}

namespace ErrorCodes

{

extern const int BAD_ARGUMENTS;

extern const int CANNOT_WRITE_TO_OSTREAM;

extern const int INCOMPATIBLE_SCHEMA;

extern const int SUPPORT_IS_DISABLED;

extern const int NOT_IMPLEMENTED;

extern const int UNSUPPORTED_MEDIA_TYPE;

}

class PrometheusRequestHandler::Impl

{

explicit Impl(PrometheusRequestHandler & parent) : parent_ref(parent) {}

virtual ~Impl() = default;

virtual void beforeHandlingRequest(HTTPServerRequest & /* request */) {}

virtual bool isSettingLikeParameter(const String & /* name */) { return false; }

virtual void handleRequest(HTTPServerRequest & request, HTTPServerResponse & response) = 0;

virtual void onException() {}

PrometheusRequestHandler & parent() { return parent_ref; }

IServer & server() { return parent().server; }

const PrometheusRequestHandlerConfig & config() { return parent().config; }

PrometheusMetricsWriter & metrics_writer() { return *parent().metrics_writer; }

LoggerPtr log() { return parent().log; }

WriteBuffer & getOutputStream(HTTPServerResponse & response) { return parent().getOutputStream(response); }

PrometheusRequestHandler & parent_ref;

};

class PrometheusRequestHandler::MetricsImpl : public Impl

{

explicit MetricsImpl(PrometheusRequestHandler & parent) : Impl(parent) {}

void beforeHandlingRequest(HTTPServerRequest & request) override

}

void handleRequest(HTTPServerRequest & /* request */, HTTPServerResponse & response) override

}

};

class PrometheusRequestHandler::ImplWithContext : public Impl

{

explicit ImplWithContext(PrometheusRequestHandler & parent) : Impl(parent), default_settings(server().context()->getSettingsRef()) { }

virtual void handlingRequestWithContext(HTTPServerRequest & request, HTTPServerResponse & response) = 0;

/// When true, `handleRequest` parses `application/x-www-form-urlencoded` (and multipart) bodies for POST/PUT.

/// Must stay false for Write/Read so the raw body stream stays available for protobuf.

virtual bool shouldParseFormFromRequestBody(const HTTPServerRequest & /* request */) const { return false; }

void handleRequest(HTTPServerRequest & request, HTTPServerResponse & response) override

}

bool authenticateUserAndMakeContext(HTTPServerRequest & request, HTTPServerResponse & response)

}

bool authenticateUser(HTTPServerRequest & request, HTTPServerResponse & response)

{

return authenticateUserByHTTP(request, *params, response, *session, request_credentials, config().connection_config, server().context(), log());

}

bool isSettingLikeParameter(const String & name) override

}

void makeContext(HTTPServerRequest & request)

}

/// Resolves the time series table for the current request. Each of the database and table names comes

/// either from the configuration or from the URL query parameter 'database' and 'table'.

/// A query parameter can't override a value set in the configuration.

/// If the database isn't set, the table name is treated as a possibly-qualified `database.table` name,

/// and if the table name is not a qualified name then the database name falls back to "default".

StorageID getTimeSeriesTableID()

}

void onException() override

}

const Settings & default_settings;

std::unique_ptr<HTMLForm> params;

std::unique_ptr<Session> session;

std::unique_ptr<Credentials> request_credentials;

ContextMutablePtr context;

};

class PrometheusRequestHandler::WriteImpl : public ImplWithContext

{

using ImplWithContext::ImplWithContext;

void beforeHandlingRequest(HTTPServerRequest & request) override

}

void handlingRequestWithContext([[maybe_unused]] HTTPServerRequest & request, [[maybe_unused]] HTTPServerResponse & response) override

}

};

class PrometheusRequestHandler::ReadImpl : public ImplWithContext

{

using ImplWithContext::ImplWithContext;

void beforeHandlingRequest(HTTPServerRequest & request) override

}

void handlingRequestWithContext([[maybe_unused]] HTTPServerRequest & request, [[maybe_unused]] HTTPServerResponse & response) override

}

};

class PrometheusRequestHandler::QueryImpl : public ImplWithContext

{

using ImplWithContext::ImplWithContext;

bool shouldParseFormFromRequestBody(const HTTPServerRequest & /* request */) const override { return true; }

void beforeHandlingRequest(HTTPServerRequest & request) override

}

bool isSettingLikeParameter(const String & name) override

}

/// Parses the optional `limit` parameter of the metadata endpoints: the maximum number of returned items,

/// with 0 (the default) meaning no limit.

UInt64 getLimitParam() const

}

void handlingRequestWithContext(HTTPServerRequest & request, HTTPServerResponse & response) override

}

/// Handles the format_query endpoint: parses the PromQL expression given in the 'query' parameter

/// and writes it back serialized from the parsed tree, i.e. with the whitespace normalized,

/// the comments removed, and the redundant parentheses dropped.

static void formatQuery(WriteBuffer & out, const String & query)

}

/// Parses an optional integer parameter of the metadata endpoint; an absent parameter defaults to -1 (no limit).

Int64 getMetadataLimitParam(const String & name) const

}

/// Extracts the label name from a label-values endpoint path ".../label/<name>/values".

/// Returns std::nullopt when `uri_path` isn't a valid label-values endpoint.

static std::optional<String> extractLabelValuesName(std::string_view uri_path)

}

};

class PrometheusRequestHandler::APIv1Impl : public Impl

{

explicit APIv1Impl(PrometheusRequestHandler & parent)

}

void beforeHandlingRequest(HTTPServerRequest & request) override

}

void handleRequest(HTTPServerRequest & request, HTTPServerResponse & response) override

}

void onException() override

}

/// Selects the implementation for a request based on the trailing segment of its path,

/// so the same endpoint works both bare ("/api/v1/write") and behind a configured prefix

/// ("/prefix/api/v1/write").

Impl & getImpl(const HTTPServerRequest & request)

{

/// Get the decoded URL path (without the query string).

const String path = Poco::URI(request.getURI()).getPath();

if (path.ends_with("/write"))

return write_impl;

if (path.ends_with("/read"))

return read_impl;

/// All other /api/v1/* endpoints (query, query_range, series, labels, label/<name>/values, metadata)

/// are served by the Query implementation, which itself returns 404 for unknown paths.

return query_impl;

}

WriteImpl write_impl;

ReadImpl read_impl;

QueryImpl query_impl;

Impl * current_impl = nullptr;

};

PrometheusRequestHandler::PrometheusRequestHandler(

}

PrometheusRequestHandler::~PrometheusRequestHandler() = default;

void PrometheusRequestHandler::createImpl()

}

void PrometheusRequestHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse & response, const ProfileEvents::Event & write_event_)

}

WriteBufferFromHTTPServerResponse & PrometheusRequestHandler::getOutputStream(HTTPServerResponse & response)

{

if (write_buffer_from_response)

return *write_buffer_from_response;

write_buffer_from_response = std::make_unique<WriteBufferFromHTTPServerResponse>(

response, http_method == HTTPRequest::HTTP_HEAD, write_event, http_response_buffer_size);

return *write_buffer_from_response;

}

void PrometheusRequestHandler::tryCallOnException()

}

}