Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include "envoy/data/accesslog/v3/accesslog.pb.h"
       4             : #include "envoy/http/header_map.h"
       5             : 
       6             : namespace Envoy {
       7             : namespace Formatter {
       8             : 
       9             : using AccessLogType = envoy::data::accesslog::v3::AccessLogType;
      10             : 
      11             : /**
      12             :  * HTTP specific substitution formatter context for HTTP access logs or formatters.
      13             :  * TODO(wbpcode): maybe we should move this class to envoy/http folder and rename it
      14             :  * for more general usage.
      15             :  */
      16             : class HttpFormatterContext {
      17             : public:
      18             :   /**
      19             :    * Constructor that uses the provided request/response headers, response trailers, local reply
      20             :    * body, and access log type. Any of the parameters can be nullptr/empty.
      21             :    *
      22             :    * @param request_headers supplies the request headers.
      23             :    * @param response_headers supplies the response headers.
      24             :    * @param response_trailers supplies the response trailers.
      25             :    * @param local_reply_body supplies the local reply body.
      26             :    * @param log_type supplies the access log type.
      27             :    */
      28             :   HttpFormatterContext(const Http::RequestHeaderMap* request_headers = nullptr,
      29             :                        const Http::ResponseHeaderMap* response_headers = nullptr,
      30             :                        const Http::ResponseTrailerMap* response_trailers = nullptr,
      31             :                        absl::string_view local_reply_body = {},
      32             :                        AccessLogType log_type = AccessLogType::NotSet);
      33             :   /**
      34             :    * Set or overwrite the request headers.
      35             :    * @param request_headers supplies the request headers.
      36             :    */
      37           0 :   HttpFormatterContext& setRequestHeaders(const Http::RequestHeaderMap& request_headers) {
      38           0 :     request_headers_ = &request_headers;
      39           0 :     return *this;
      40           0 :   }
      41             :   /**
      42             :    * Set or overwrite the response headers.
      43             :    * @param response_headers supplies the response headers.
      44             :    */
      45           0 :   HttpFormatterContext& setResponseHeaders(const Http::ResponseHeaderMap& response_headers) {
      46           0 :     response_headers_ = &response_headers;
      47           0 :     return *this;
      48           0 :   }
      49             : 
      50             :   /**
      51             :    * Set or overwrite the response trailers.
      52             :    * @param response_trailers supplies the response trailers.
      53             :    */
      54           0 :   HttpFormatterContext& setResponseTrailers(const Http::ResponseTrailerMap& response_trailers) {
      55           0 :     response_trailers_ = &response_trailers;
      56           0 :     return *this;
      57           0 :   }
      58             : 
      59             :   /**
      60             :    * Set or overwrite the local reply body.
      61             :    * @param local_reply_body supplies the local reply body.
      62             :    */
      63           0 :   HttpFormatterContext& setLocalReplyBody(absl::string_view local_reply_body) {
      64           0 :     local_reply_body_ = local_reply_body;
      65           0 :     return *this;
      66           0 :   }
      67             : 
      68             :   /**
      69             :    * Set or overwrite the access log type.
      70             :    * @param log_type supplies the access log type.
      71             :    */
      72           0 :   HttpFormatterContext& setAccessLogType(AccessLogType log_type) {
      73           0 :     log_type_ = log_type;
      74           0 :     return *this;
      75           0 :   }
      76             : 
      77             :   /**
      78             :    * @return const Http::RequestHeaderMap& the request headers. Empty request header map if no
      79             :    * request headers are available.
      80             :    */
      81             :   const Http::RequestHeaderMap& requestHeaders() const;
      82             : 
      83             :   /**
      84             :    * @return false if no request headers are available.
      85             :    */
      86           0 :   bool hasRequestHeaders() const { return request_headers_ != nullptr; }
      87             : 
      88             :   /**
      89             :    * @return const Http::ResponseHeaderMap& the response headers. Empty respnose header map if
      90             :    * no response headers are available.
      91             :    */
      92             :   const Http::ResponseHeaderMap& responseHeaders() const;
      93             : 
      94             :   /**
      95             :    * @return false if no response headers are available.
      96             :    */
      97           0 :   bool hasResponseHeaders() const { return response_headers_ != nullptr; }
      98             : 
      99             :   /**
     100             :    * @return const Http::ResponseTrailerMap& the response trailers. Empty response trailer map
     101             :    * if no response trailers are available.
     102             :    */
     103             :   const Http::ResponseTrailerMap& responseTrailers() const;
     104             : 
     105             :   /**
     106             :    * @return false if no response trailers are available.
     107             :    */
     108           0 :   bool hasResponseTrailers() const { return response_trailers_ != nullptr; }
     109             : 
     110             :   /**
     111             :    * @return absl::string_view the local reply body. Empty if no local reply body.
     112             :    */
     113             :   absl::string_view localReplyBody() const;
     114             : 
     115             :   /**
     116             :    * @return AccessLog::AccessLogType the type of access log. NotSet if this is not used for
     117             :    * access logging.
     118             :    */
     119             :   AccessLogType accessLogType() const;
     120             : 
     121             : private:
     122             :   const Http::RequestHeaderMap* request_headers_{};
     123             :   const Http::ResponseHeaderMap* response_headers_{};
     124             :   const Http::ResponseTrailerMap* response_trailers_{};
     125             :   absl::string_view local_reply_body_{};
     126             :   AccessLogType log_type_{AccessLogType::NotSet};
     127             : };
     128             : 
     129             : } // namespace Formatter
     130             : } // namespace Envoy