add response code details to stream info

include/envoy/stream_info/BUILD

@@ -20,6 +20,7 @@ envoy_cc_library(
         "//include/envoy/upstream:host_description_interface",
         "//source/common/common:assert_lib",
         "//source/common/protobuf",
+        "//source/common/singleton:const_singleton",
     ],
 )
 

include/envoy/stream_info/stream_info.h

@@ -14,6 +14,7 @@
 
 #include "common/common/assert.h"
 #include "common/protobuf/protobuf.h"
+#include "common/singleton/const_singleton.h"
 
 #include "absl/types/optional.h"
 
@@ -64,6 +65,20 @@ enum ResponseFlag {
   LastFlag = StreamIdleTimeout
 };
 
+/**
+ * Constants for the response code details field of StreamInfo.
+ *
+ * These provide details about the stream state such as whether the
+ * response is from the upstream or from envoy (in case of a local reply).
+ * Custom extensions can define additional values provided they are appropriately
+ * scoped to avoid collisions.
+ */
+struct ResponseCodeDetailValues {
+  const std::string RC_SET_BY_UPSTREAM = "response_code_set_by_upstream";
+};
+
+typedef ConstSingleton<ResponseCodeDetailValues> ResponseCodeDetails;
+
 struct UpstreamTiming {
   /**
    * Sets the time when the first byte of the request was sent upstream.
@@ -116,6 +131,12 @@ class StreamInfo {
    */
   virtual void setResponseFlag(ResponseFlag response_flag) PURE;
 
+  /**
+   * @param rc_details the response code details string to set for this request.
+   * See ResponseCodeDetailValues above for well-known constants.
+   */
+  virtual void setResponseCodeDetails(absl::string_view rc_details) PURE;
+
   /**
    * @param response_flags the response_flags to intersect with.
    * @return true if the intersection of the response_flags argument and the currently set response
@@ -153,6 +174,11 @@ class StreamInfo {
    */
   virtual absl::optional<uint32_t> responseCode() const PURE;
 
+  /**
+   * @return the response code details.
+   */
+  virtual const absl::optional<std::string>& responseCodeDetails() const PURE;
+
   /**
    * @return the time that the first byte of the request was received.
    */

source/common/http/async_client_impl.h

@@ -321,6 +321,8 @@ class AsyncStreamImpl : public AsyncClient::Stream,
   void sendLocalReply(Code code, absl::string_view body,
                       std::function<void(HeaderMap& headers)> modify_headers,
                       const absl::optional<Grpc::Status::GrpcStatus> grpc_status) override {
+    // TODO(eziskind): add an extra parameter for setting rc details
+    stream_info_.setResponseCodeDetails("");
     Utility::sendLocalReply(
         is_grpc_request_,
         [this, modify_headers](HeaderMapPtr&& headers, bool end_stream) -> void {

source/common/http/conn_manager_impl.h

@@ -222,6 +222,8 @@ class ConnectionManagerImpl : Logger::Loggable<Logger::Id::http>,
     void sendLocalReply(Code code, absl::string_view body,
                         std::function<void(HeaderMap& headers)> modify_headers,
                         const absl::optional<Grpc::Status::GrpcStatus> grpc_status) override {
+      // TODO(eziskind): add an extra parameter for setting rc details
+      parent_.stream_info_.setResponseCodeDetails("");
       parent_.sendLocalReply(is_grpc_request_, code, body, modify_headers, parent_.is_head_request_,
                              grpc_status);
     }

source/common/router/router.cc

@@ -792,6 +792,8 @@ void Filter::onUpstreamHeaders(uint64_t response_code, Http::HeaderMapPtr&& head
     onUpstreamComplete();
   }
 
+  callbacks_->streamInfo().setResponseCodeDetails(
+      StreamInfo::ResponseCodeDetails::get().RC_SET_BY_UPSTREAM);
   callbacks_->encodeHeaders(std::move(headers), end_stream);
 }
 

source/common/stream_info/stream_info_impl.h

@@ -100,6 +100,14 @@ struct StreamInfoImpl : public StreamInfo {
 
   absl::optional<uint32_t> responseCode() const override { return response_code_; }
 
+  const absl::optional<std::string>& responseCodeDetails() const override {
+    return response_code_details_;
+  }
+
+  void setResponseCodeDetails(absl::string_view rc_details) override {
+    response_code_details_.emplace(rc_details);
+  }
+
   void addBytesSent(uint64_t bytes_sent) override { bytes_sent_ += bytes_sent; }
 
   uint64_t bytesSent() const override { return bytes_sent_; }
@@ -205,6 +213,7 @@ struct StreamInfoImpl : public StreamInfo {
 
   absl::optional<Http::Protocol> protocol_;
   absl::optional<uint32_t> response_code_;
+  absl::optional<std::string> response_code_details_;
   uint64_t response_flags_{};
   Upstream::HostDescriptionConstSharedPtr upstream_host_{};
   bool health_check_request_{};

test/common/http/conn_manager_impl_test.cc

@@ -3119,6 +3119,9 @@ TEST_F(HttpConnectionManagerImplTest, HitRequestBufferLimits) {
   EXPECT_CALL(*encoder_filters_[1], encodeComplete());
   Buffer::OwnedImpl data("A longer string");
   decoder_filters_[0]->callbacks_->addDecodedData(data, false);
+  const auto rc_details = encoder_filters_[1]->callbacks_->streamInfo().responseCodeDetails();
+  EXPECT_TRUE(rc_details.has_value());
+  EXPECT_EQ("", rc_details.value());
 }
 
 // Return 413 from an intermediate filter and make sure we don't continue the filter chain.

test/common/router/router_test.cc

@@ -738,6 +738,29 @@ TEST_F(RouterTestSuppressEnvoyHeaders, MaintenanceMode) {
   router_.decodeHeaders(headers, true);
 }
 
+TEST_F(RouterTest, ResponseCodeDetailsSetByUpstream) {
+  NiceMock<Http::MockStreamEncoder> encoder1;
+  Http::StreamDecoder* response_decoder = nullptr;
+  EXPECT_CALL(cm_.conn_pool_, newStream(_, _))
+      .WillOnce(Invoke([&](Http::StreamDecoder& decoder, Http::ConnectionPool::Callbacks& callbacks)
+                           -> Http::ConnectionPool::Cancellable* {
+        response_decoder = &decoder;
+        callbacks.onPoolReady(encoder1, cm_.conn_pool_.host_);
+        return nullptr;
+      }));
+  expectResponseTimerCreate();
+
+  Http::TestHeaderMapImpl headers;
+  HttpTestUtility::addDefaultHeaders(headers);
+  router_.decodeHeaders(headers, true);
+
+  Http::HeaderMapPtr response_headers(new Http::TestHeaderMapImpl{{":status", "200"}});
+  absl::string_view rc_details = StreamInfo::ResponseCodeDetails::get().RC_SET_BY_UPSTREAM;
+  EXPECT_CALL(callbacks_.stream_info_, setResponseCodeDetails(rc_details));
+  response_decoder->decodeHeaders(std::move(response_headers), true);
+  EXPECT_TRUE(verifyHostUpstreamStats(1, 0));
+}
+
 // Validate that x-envoy-upstream-service-time is added on a regular
 // request/response path.
 TEST_F(RouterTest, EnvoyUpstreamServiceTime) {

test/common/stream_info/stream_info_impl_test.cc

@@ -142,6 +142,12 @@ TEST_F(StreamInfoImplTest, MiscSettersAndGetters) {
     ASSERT_TRUE(stream_info.responseCode());
     EXPECT_EQ(200, stream_info.responseCode().value());
 
+    EXPECT_FALSE(stream_info.responseCodeDetails().has_value());
+    stream_info.setResponseCodeDetails(ResponseCodeDetails::get().RC_SET_BY_UPSTREAM);
+    ASSERT_TRUE(stream_info.responseCodeDetails().has_value());
+    EXPECT_EQ(ResponseCodeDetails::get().RC_SET_BY_UPSTREAM,
+              stream_info.responseCodeDetails().value());
+
     EXPECT_EQ(nullptr, stream_info.upstreamHost());
     Upstream::HostDescriptionConstSharedPtr host(new NiceMock<Upstream::MockHostDescription>());
     stream_info.onUpstreamHostSelected(host);

test/common/stream_info/test_util.h

@@ -31,6 +31,12 @@ class TestStreamInfo : public StreamInfo::StreamInfo {
   absl::optional<Http::Protocol> protocol() const override { return protocol_; }
   void protocol(Http::Protocol protocol) override { protocol_ = protocol; }
   absl::optional<uint32_t> responseCode() const override { return response_code_; }
+  const absl::optional<std::string>& responseCodeDetails() const override {
+    return response_code_details_;
+  }
+  void setResponseCodeDetails(absl::string_view rc_details) override {
+    response_code_details_.emplace(rc_details);
+  }
   void addBytesSent(uint64_t) override { NOT_IMPLEMENTED_GCOVR_EXCL_LINE; }
   uint64_t bytesSent() const override { return 2; }
   bool intersectResponseFlags(uint64_t response_flags) const override {
@@ -188,6 +194,7 @@ class TestStreamInfo : public StreamInfo::StreamInfo {
 
   absl::optional<Http::Protocol> protocol_{Http::Protocol::Http11};
   absl::optional<uint32_t> response_code_;
+  absl::optional<std::string> response_code_details_;
   uint64_t response_flags_{};
   Upstream::HostDescriptionConstSharedPtr upstream_host_{};
   bool health_check_request_{};

test/mocks/stream_info/mocks.cc

@@ -70,6 +70,7 @@ MockStreamInfo::MockStreamInfo()
   }));
   ON_CALL(*this, protocol()).WillByDefault(ReturnPointee(&protocol_));
   ON_CALL(*this, responseCode()).WillByDefault(ReturnPointee(&response_code_));
+  ON_CALL(*this, responseCodeDetails()).WillByDefault(ReturnPointee(&response_code_details_));
   ON_CALL(*this, addBytesReceived(_)).WillByDefault(Invoke([this](uint64_t bytes_received) {
     bytes_received_ += bytes_received;
   }));

test/mocks/stream_info/mocks.h

@@ -18,6 +18,7 @@ class MockStreamInfo : public StreamInfo {
 
   // StreamInfo::StreamInfo
   MOCK_METHOD1(setResponseFlag, void(ResponseFlag response_flag));
+  MOCK_METHOD1(setResponseCodeDetails, void(absl::string_view));
   MOCK_CONST_METHOD1(intersectResponseFlags, bool(uint64_t));
   MOCK_METHOD1(onUpstreamHostSelected, void(Upstream::HostDescriptionConstSharedPtr host));
   MOCK_CONST_METHOD0(startTime, SystemTime());
@@ -44,6 +45,7 @@ class MockStreamInfo : public StreamInfo {
   MOCK_CONST_METHOD0(protocol, absl::optional<Http::Protocol>());
   MOCK_METHOD1(protocol, void(Http::Protocol protocol));
   MOCK_CONST_METHOD0(responseCode, absl::optional<uint32_t>());
+  MOCK_CONST_METHOD0(responseCodeDetails, const absl::optional<std::string>&());
   MOCK_METHOD1(addBytesSent, void(uint64_t));
   MOCK_CONST_METHOD0(bytesSent, uint64_t());
   MOCK_CONST_METHOD1(hasResponseFlag, bool(ResponseFlag));
@@ -90,6 +92,7 @@ class MockStreamInfo : public StreamInfo {
   absl::optional<std::chrono::nanoseconds> end_time_;
   absl::optional<Http::Protocol> protocol_;
   absl::optional<uint32_t> response_code_;
+  absl::optional<std::string> response_code_details_;
   envoy::api::v2::core::Metadata metadata_;
   FilterStateImpl filter_state_;
   uint64_t bytes_received_{};