Add access log handler for HTTP stream filter.

include/envoy/http/filter.h

@@ -292,6 +292,12 @@ class FilterChainFactoryCallbacks {
    * @param filter supplies the filter to add.
    */
   virtual void addStreamFilter(Http::StreamFilterPtr filter) PURE;
+
+  /**
+   * Add an access log handler that is called when the stream is destroyed.
+   * @param handler supplies the handler to add.
+   */
+  virtual void addAccessLogHandler(Http::AccessLog::InstancePtr handler) PURE;
 };
 
 /**

source/common/http/conn_manager_impl.cc

@@ -284,6 +284,9 @@ ConnectionManagerImpl::ActiveStream::~ActiveStream() {
   for (AccessLog::InstancePtr access_log : connection_manager_.config_.accessLogs()) {
     access_log->log(request_headers_.get(), response_headers_.get(), request_info_);
   }
+  for (const auto& log_handler : access_log_handlers_) {
+    log_handler->log(request_headers_.get(), response_headers_.get(), request_info_);
+  }
 
   if (active_span_ && !request_info_.healthCheck()) {
     Tracing::HttpTracerUtility::finalizeSpan(*active_span_, request_info_);
@@ -307,6 +310,11 @@ void ConnectionManagerImpl::ActiveStream::addStreamFilter(StreamFilterPtr filter
   addStreamEncoderFilter(filter);
 }
 
+void ConnectionManagerImpl::ActiveStream::addAccessLogHandler(
+    Http::AccessLog::InstancePtr handler) {
+  access_log_handlers_.push_back(handler);
+}
+
 void ConnectionManagerImpl::ActiveStream::chargeStats(HeaderMap& headers) {
   uint64_t response_code = Utility::getResponseStatus(headers);
   request_info_.response_code_.value(response_code);

source/common/http/conn_manager_impl.h

@@ -380,6 +380,7 @@ class ConnectionManagerImpl : Logger::Loggable<Logger::Id::http>,
     void addStreamDecoderFilter(StreamDecoderFilterPtr filter) override;
     void addStreamEncoderFilter(StreamEncoderFilterPtr filter) override;
     void addStreamFilter(StreamFilterPtr filter) override;
+    void addAccessLogHandler(Http::AccessLog::InstancePtr handler) override;
 
     // Tracing::TracingConfig
     virtual const std::string& operationName() const override;
@@ -406,6 +407,7 @@ class ConnectionManagerImpl : Logger::Loggable<Logger::Id::http>,
     HeaderMapPtr request_trailers_;
     std::list<ActiveStreamDecoderFilterPtr> decoder_filters_;
     std::list<ActiveStreamEncoderFilterPtr> encoder_filters_;
+    std::list<Http::AccessLog::InstancePtr> access_log_handlers_;
     Stats::TimespanPtr request_timer_;
     std::list<std::function<void()>> reset_callbacks_;
     State state_;

test/common/http/conn_manager_impl_test.cc

@@ -3,13 +3,13 @@
 #include "envoy/http/access_log.h"
 
 #include "common/buffer/buffer_impl.h"
-#include "common/http/access_log/access_log_impl.h"
 #include "common/http/access_log/access_log_formatter.h"
+#include "common/http/access_log/access_log_impl.h"
 #include "common/http/conn_manager_impl.h"
 #include "common/http/date_provider_impl.h"
 #include "common/http/exception.h"
-#include "common/http/headers.h"
 #include "common/http/header_map_impl.h"
+#include "common/http/headers.h"
 #include "common/stats/stats_impl.h"
 
 #include "test/mocks/access_log/mocks.h"
@@ -239,6 +239,49 @@ TEST_F(HttpConnectionManagerImplTest, StartAndFinishSpanNormalFlow) {
   conn_manager_->onData(fake_input);
 }
 
+TEST_F(HttpConnectionManagerImplTest, TestAccessLog) {
+  setup(false, "");
+
+  std::shared_ptr<Http::MockStreamDecoderFilter> filter(
+      new NiceMock<Http::MockStreamDecoderFilter>());
+  std::shared_ptr<Http::AccessLog::MockInstance> handler(
+      new NiceMock<Http::AccessLog::MockInstance>());
+
+  EXPECT_CALL(filter_factory_, createFilterChain(_))
+      .WillOnce(Invoke([&](Http::FilterChainFactoryCallbacks& callbacks) -> void {
+        callbacks.addStreamDecoderFilter(filter);
+        callbacks.addAccessLogHandler(handler);
+      }));
+
+  EXPECT_CALL(*handler, log(_, _, _))
+      .WillOnce(Invoke([](const Http::HeaderMap*, const Http::HeaderMap*,
+                          const Http::AccessLog::RequestInfo& request_info) {
+        EXPECT_TRUE(request_info.responseCode().valid());
+        EXPECT_EQ(request_info.responseCode().value(), uint32_t(200));
+      }));
+
+  Http::StreamDecoder* decoder = nullptr;
+  NiceMock<Http::MockStreamEncoder> encoder;
+  EXPECT_CALL(*codec_, dispatch(_))
+      .WillRepeatedly(Invoke([&](Buffer::Instance& data) -> void {
+        decoder = &conn_manager_->newStream(encoder);
+
+        Http::HeaderMapPtr headers{
+            new TestHeaderMapImpl{{":authority", "host"},
+                                  {":path", "/"},
+                                  {"x-request-id", "125a4afb-6f55-a4ba-ad80-413f09f48a28"}}};
+        decoder->decodeHeaders(std::move(headers), true);
+
+        Http::HeaderMapPtr response_headers{new TestHeaderMapImpl{{":status", "200"}}};
+        filter->callbacks_->encodeHeaders(std::move(response_headers), true);
+
+        data.drain(4);
+      }));
+
+  Buffer::OwnedImpl fake_input("1234");
+  conn_manager_->onData(fake_input);
+}
+
 TEST_F(HttpConnectionManagerImplTest, DoNotStartSpanIfTracingIsNotEnabled) {
   setup(false, "");