grpc
diff --git a/‎metadata/metadata.go‎
Lines changed: 60 additions & 0 deletions b/‎metadata/metadata.go‎
Lines changed: 60 additions & 0 deletions
diff --git a/‎metadata/metadata_test.go‎
Lines changed: 153 additions & 0 deletions b/‎metadata/metadata_test.go‎
Lines changed: 153 additions & 0 deletions
@@ -360,6 +360,66 @@ func FromOutgoingContext(ctx context.Context) (MD, bool) {
 	return out, ok
 }
 
+// ValueFromOutgoingContext returns the metadata value corresponding to the
+// metadata key from the outgoing metadata if it exists. Keys are matched in a
+// case-insensitive manner.
+//
+// Unlike FromOutgoingContext, this does not copy the entire outgoing metadata.
+func ValueFromOutgoingContext(ctx context.Context, key string) []string {
+	raw, ok := ctx.Value(mdOutgoingKey{}).(rawMD)
+	if !ok {
+		return nil
+	}
+
+	key = strings.ToLower(key)
+	// Unlike ValueFromIncomingContext, this can't return as soon as raw.md is
+	// checked: raw.added still needs to be walked and accumulated regardless.
+	// The else below prevents that from overwriting an exact match with an
+	// unrelated case-insensitive one.
+	var matchedMD []string
+	if v, ok := raw.md[key]; ok {
+		matchedMD = v
+	} else {
+		for k, v := range raw.md {
+			// Case insensitive comparison: MD is a map, and there's no
+			// guarantee that the MD attached to the context is created using
+			// our helper functions.
+			if strings.EqualFold(k, key) {
+				matchedMD = v
+				break
+			}
+		}
+	}
+
+	// Defer allocating vals until raw.added actually has a match, so a match
+	// found only in raw.md doesn't pay for both a copyOf and a growing
+	// append.
+	var vals []string
+	for _, added := range raw.added {
+		if len(added)%2 == 1 {
+			panic(fmt.Sprintf("metadata: ValueFromOutgoingContext got an odd number of input pairs for metadata: %d", len(added)))
+		}
+
+		// Case insensitive, like FromOutgoingContext: added isn't guaranteed
+		// lowercase, though AppendToOutgoingContext already lowercases it in
+		// practice, so try the cheap exact match first.
+		for i := 0; i < len(added); i += 2 {
+			if added[i] == key || strings.EqualFold(added[i], key) {
+				if vals == nil {
+					vals = make([]string, 0, len(matchedMD)+1)
+					vals = append(vals, matchedMD...)
+				}
+				vals = append(vals, added[i+1])
+			}
+		}
+	}
+
+	if vals == nil && matchedMD != nil {
+		return copyOf(matchedMD)
+	}
+	return vals
+}
+
 type rawMD struct {
 	md    MD
 	added [][]string
 
@@ -20,11 +20,13 @@ package metadata
 
 import (
 	"context"
+	"fmt"
 	"reflect"
 	"strconv"
 	"testing"
 	"time"
 
+	"github.com/google/go-cmp/cmp"
 	"google.golang.org/grpc/internal/grpctest"
 )
 
@@ -342,6 +344,99 @@ func (s) TestAppendToOutgoingContext_FromKVSlice(t *testing.T) {
 	}
 }
 
+func (s) TestValueFromOutgoingContext(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
+	defer cancel()
+
+	md := Pairs(
+		"X-My-Header-1", "42",
+		"x-my-header-3", "44",
+		"k1", "v1",
+		"k2", "v2",
+	)
+	// Verify that we match case-insensitively even if callers directly
+	// modify md.
+	md["X-INCORRECT-UPPERCASE"] = []string{"foo"}
+	ctx = NewOutgoingContext(ctx, md)
+	ctx = AppendToOutgoingContext(ctx, "x-my-header-2", "43-1")
+	ctx = AppendToOutgoingContext(ctx, "X-My-Header-2", "43-2")
+	ctx = AppendToOutgoingContext(ctx, "k1", "v3")
+	ctx = AppendToOutgoingContext(ctx, "k1", "v4")
+
+	for _, test := range []struct {
+		key  string
+		want []string
+	}{
+		{
+			key:  "x-my-header-1",
+			want: []string{"42"},
+		},
+		{
+			// Split across two AppendToOutgoingContext calls (raw.added) —
+			// must accumulate across both, in call order.
+			key:  "x-my-header-2",
+			want: []string{"43-1", "43-2"},
+		},
+		{
+			key:  "x-my-header-3",
+			want: []string{"44"},
+		},
+		{
+			key:  "x-unknown",
+			want: nil,
+		},
+		{
+			key:  "x-incorrect-uppercase",
+			want: []string{"foo"},
+		},
+		{
+			// Present in both raw.md and two later AppendToOutgoingContext
+			// calls — must accumulate across all three, in order.
+			key:  "k1",
+			want: []string{"v1", "v3", "v4"},
+		},
+	} {
+		v := ValueFromOutgoingContext(ctx, test.key)
+		if diff := cmp.Diff(test.want, v); diff != "" {
+			t.Errorf("ValueFromOutgoingContext(ctx, %q) returned unexpected diff (-want +got):\n%s", test.key, diff)
+		}
+	}
+}
+
+func (s) TestValueFromOutgoingContext_NoMetadata(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
+	defer cancel()
+
+	if v := ValueFromOutgoingContext(ctx, "x-my-header-1"); v != nil {
+		t.Errorf("ValueFromOutgoingContext on context with no outgoing metadata = %v, want nil", v)
+	}
+}
+
+func (s) TestValueFromOutgoingContext_AddedCaseInsensitive(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
+	defer cancel()
+	ctx = context.WithValue(ctx, mdOutgoingKey{}, rawMD{added: [][]string{{"X-My-Header", "42"}}})
+
+	v := ValueFromOutgoingContext(ctx, "x-my-header")
+	if diff := cmp.Diff([]string{"42"}, v); diff != "" {
+		t.Errorf("ValueFromOutgoingContext(ctx, \"x-my-header\") returned unexpected diff (-want +got):\n%s", diff)
+	}
+}
+
+func (s) TestValueFromOutgoingContext_PanicsOnOddPairs(t *testing.T) {
+	defer func() {
+		if r := recover(); r == nil {
+			t.Fatal("ValueFromOutgoingContext did not panic on an odd number of pairs in added")
+		}
+	}()
+
+	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
+	defer cancel()
+	ctx = context.WithValue(ctx, mdOutgoingKey{}, rawMD{added: [][]string{{"key-without-a-value"}}})
+
+	ValueFromOutgoingContext(ctx, "key-without-a-value")
+}
+
 // Old/slow approach to adding metadata to context
 func Benchmark_AddingMetadata_ContextManipulationApproach(b *testing.B) {
 	// TODO: Add in N=1-100 tests once Go1.6 support is removed.
@@ -379,6 +474,32 @@ func BenchmarkFromOutgoingContext(b *testing.B) {
 	}
 }
 
+// Reading one key out of many staged headers
+func BenchmarkValueFromOutgoingContextVsFromOutgoingContext(b *testing.B) {
+	for _, numHeaders := range []int{1, 10, 50} {
+		ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
+		defer cancel()
+		md := MD{}
+		for i := 0; i < numHeaders; i++ {
+			md[strconv.Itoa(i)] = []string{strconv.Itoa(i)}
+		}
+		ctx = NewOutgoingContext(ctx, md)
+		ctx = AppendToOutgoingContext(ctx, "target-key", "target-value")
+
+		b.Run(fmt.Sprintf("FromOutgoingContext/n=%d", numHeaders), func(b *testing.B) {
+			for b.Loop() {
+				FromOutgoingContext(ctx)
+			}
+		})
+
+		b.Run(fmt.Sprintf("ValueFromOutgoingContext/n=%d", numHeaders), func(b *testing.B) {
+			for b.Loop() {
+				ValueFromOutgoingContext(ctx, "target-key")
+			}
+		})
+	}
+}
+
 func BenchmarkFromIncomingContext(b *testing.B) {
 	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
 	defer cancel()
@@ -416,6 +537,38 @@ func BenchmarkValueFromIncomingContext(b *testing.B) {
 	})
 }
 
+func BenchmarkValueFromOutgoingContext(b *testing.B) {
+	// Realistic-length gRPC metadata keys, not "k1"/"k2"/"k3": short keys
+	// understate the cost of strings.EqualFold relative to a cheap exact
+	// match, which matters for the key-found cases below.
+	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
+	defer cancel()
+	ctx = NewOutgoingContext(ctx, MD{"content-type": {"application/grpc"}})
+	ctx = AppendToOutgoingContext(ctx, "grpc-timeout", "10S", "x-request-id", "abc-def-123")
+
+	b.Run("key-found", func(b *testing.B) {
+		for b.Loop() {
+			ValueFromOutgoingContext(ctx, "grpc-timeout")
+		}
+	})
+
+	b.Run("key-not-found", func(b *testing.B) {
+		for b.Loop() {
+			ValueFromOutgoingContext(ctx, "x-does-not-exist")
+		}
+	})
+
+	// Key present in both raw.md ("content-type") and raw.added (appended
+	// below) — exercises the accumulate-across-both path, not just
+	// append-to-nil.
+	bothCtx := AppendToOutgoingContext(ctx, "content-type", "application/grpc+proto")
+	b.Run("key-found-in-md-and-added", func(b *testing.B) {
+		for b.Loop() {
+			ValueFromOutgoingContext(bothCtx, "content-type")
+		}
+	})
+}
+
 // TestString verifies that String shows keys and values only for keys known to
 // be safe to log, omits every other key (including its name) and reports only
 // the count of omitted keys, and never panics on nil/empty inputs.