Add FIELD accessor support for peer metadata in tracing

source/extensions/filters/http/peer_metadata/filter.cc

@@ -292,12 +292,13 @@ void FilterConfig::setFilterState(StreamInfo::StreamInfo& info, bool downstream,
   const absl::string_view key =
       downstream ? Istio::Common::DownstreamPeer : Istio::Common::UpstreamPeer;
   if (!info.filterState()->hasDataWithName(key)) {
-    // Use CelState to allow operation filter_state.upstream_peer.labels['role']
-    auto pb = value.serializeAsProto();
-    auto peer_info = std::make_unique<CelState>(FilterConfig::peerInfoPrototype());
-    peer_info->setValue(absl::string_view(pb->SerializeAsString()));
+    // Store WorkloadMetadataObject directly for both FIELD accessor and CEL support.
+    // WorkloadMetadataObject implements:
+    // - hasFieldSupport() + getField() for FIELD accessor in formatters
+    // - serializeAsProto() for CEL expressions
+    auto workload_metadata = std::make_unique<PeerInfo>(value);
     info.filterState()->setData(
-        key, std::move(peer_info), StreamInfo::FilterState::StateType::Mutable,
+        key, std::move(workload_metadata), StreamInfo::FilterState::StateType::Mutable,
         StreamInfo::FilterState::LifeSpan::FilterChain, sharedWithUpstream());
   } else {
     ENVOY_LOG(debug, "Duplicate peer metadata, skipping");

source/extensions/filters/http/peer_metadata/filter_test.cc

@@ -79,13 +79,12 @@ class PeerMetadataTest : public testing::Test {
         downstream ? Istio::Common::DownstreamPeer : Istio::Common::UpstreamPeer));
   }
   void checkPeerNamespace(bool downstream, const std::string& expected) {
-    const auto* cel_state =
+    const auto* peer_info =
         stream_info_.filterState()
-            ->getDataReadOnly<Envoy::Extensions::Filters::Common::Expr::CelState>(
+            ->getDataReadOnly<PeerInfo>(
                 downstream ? Istio::Common::DownstreamPeer : Istio::Common::UpstreamPeer);
-    Protobuf::Struct obj;
-    ASSERT_TRUE(obj.ParseFromString(cel_state->value().data()));
-    EXPECT_EQ(expected, extractString(obj, "namespace"));
+    ASSERT_NE(peer_info, nullptr);
+    EXPECT_EQ(expected, peer_info->namespace_name_);
   }
 
   absl::string_view extractString(const Protobuf::Struct& metadata, absl::string_view key) {
@@ -488,6 +487,76 @@ TEST_F(PeerMetadataTest, UpstreamMXPropagationSkipPassthrough) {
   checkNoPeer(false);
 }
 
+TEST_F(PeerMetadataTest, FieldAccessorSupport) {
+  const WorkloadMetadataObject pod("pod-foo-1234", "my-cluster", "default", "foo", "foo-service",
+                                   "v1alpha3", "myapp", "v1", Istio::Common::WorkloadType::Pod, "");
+  EXPECT_CALL(*metadata_provider_, GetMetadata(_))
+      .WillRepeatedly(Invoke([&](const Network::Address::InstanceConstSharedPtr& address)
+                                 -> std::optional<WorkloadMetadataObject> {
+        if (absl::StartsWith(address->asStringView(), "127.0.0.1")) {
+          return {pod};
+        }
+        return {};
+      }));
+  initialize(R"EOF(
+    downstream_discovery:
+      - workload_discovery: {}
+  )EOF");
+
+  const auto* peer_info =
+      stream_info_.filterState()
+          ->getDataReadOnly<PeerInfo>(Istio::Common::DownstreamPeer);
+  ASSERT_NE(peer_info, nullptr);
+
+  // Test hasFieldSupport
+  EXPECT_TRUE(peer_info->hasFieldSupport());
+
+  // Test getField() for all 9 fields
+  EXPECT_EQ("foo", std::get<std::string>(peer_info->getField("workload")));
+  EXPECT_EQ("default", std::get<std::string>(peer_info->getField("namespace")));
+  EXPECT_EQ("my-cluster", std::get<std::string>(peer_info->getField("cluster")));
+  EXPECT_EQ("foo-service", std::get<std::string>(peer_info->getField("service")));
+  EXPECT_EQ("v1alpha3", std::get<std::string>(peer_info->getField("revision")));
+  EXPECT_EQ("myapp", std::get<std::string>(peer_info->getField("app")));
+  EXPECT_EQ("v1", std::get<std::string>(peer_info->getField("version")));
+  EXPECT_EQ("pod", std::get<std::string>(peer_info->getField("type")));
+  EXPECT_EQ("pod-foo-1234", std::get<std::string>(peer_info->getField("name")));
+}
+
+TEST_F(PeerMetadataTest, CelExpressionCompatibility) {
+  const WorkloadMetadataObject pod("pod-bar-5678", "test-cluster", "production", "bar",
+                                   "bar-service", "v2", "barapp", "v2",
+                                   Istio::Common::WorkloadType::Pod, "");
+  EXPECT_CALL(*metadata_provider_, GetMetadata(_))
+      .WillRepeatedly(Invoke([&](const Network::Address::InstanceConstSharedPtr& address)
+                                 -> std::optional<WorkloadMetadataObject> {
+        if (absl::StartsWith(address->asStringView(), "127.0.0.1")) {
+          return {pod};
+        }
+        return {};
+      }));
+  initialize(R"EOF(
+    downstream_discovery:
+      - workload_discovery: {}
+  )EOF");
+
+  const auto* peer_info =
+      stream_info_.filterState()
+          ->getDataReadOnly<PeerInfo>(Istio::Common::DownstreamPeer);
+  ASSERT_NE(peer_info, nullptr);
+
+  // Test that serializeAsProto still works for CEL compatibility
+  auto proto = peer_info->serializeAsProto();
+  ASSERT_NE(proto, nullptr);
+
+  // Verify the protobuf contains expected data
+  const auto* struct_proto = dynamic_cast<const google::protobuf::Struct*>(proto.get());
+  ASSERT_NE(struct_proto, nullptr);
+  EXPECT_EQ("production", extractString(*struct_proto, "namespace"));
+  EXPECT_EQ("bar", extractString(*struct_proto, "workload"));
+  EXPECT_EQ("test-cluster", extractString(*struct_proto, "cluster"));
+}
+
 } // namespace
 } // namespace PeerMetadata
 } // namespace HttpFilters