@@ -247,10 +247,78 @@ func (p properties) String() string {
247247 return strings .Join (props , propertyDelimiter )
248248}
249249
250+ // validateMetadata validates non-empty W3C property elements without decoding
251+ // or materializing Property values. Empty elements are accepted to preserve
252+ // existing parsing behavior.
253+ func validateMetadata (raw string ) (string , bool ) {
254+ start := 0
255+ for end := 0 ; end <= len (raw ); end ++ {
256+ if end != len (raw ) && raw [end ] != propertyDelimiter [0 ] {
257+ continue
258+ }
259+
260+ if start != end {
261+ if _ , ok := parsePropertyFields (raw [start :end ]); ! ok {
262+ return raw [start :end ], false
263+ }
264+ }
265+ start = end + 1
266+ }
267+ return "" , true
268+ }
269+
270+ // normalizeMetadata removes empty property elements while preserving the raw
271+ // representation of all non-empty elements.
272+ func normalizeMetadata (metadata string ) string {
273+ if metadata == "" ||
274+ (metadata [0 ] != propertyDelimiter [0 ] &&
275+ metadata [len (metadata )- 1 ] != propertyDelimiter [0 ] &&
276+ ! strings .Contains (metadata , propertyDelimiter + propertyDelimiter )) {
277+ return metadata
278+ }
279+
280+ var normalized strings.Builder
281+ normalized .Grow (len (metadata ))
282+ for property := range strings .SplitSeq (metadata , propertyDelimiter ) {
283+ if property == "" {
284+ continue
285+ }
286+ if normalized .Len () > 0 {
287+ _ , _ = normalized .WriteString (propertyDelimiter )
288+ }
289+ _ , _ = normalized .WriteString (property )
290+ }
291+ return normalized .String ()
292+ }
293+
294+ func propertiesFromMetadata (metadata string ) properties {
295+ if metadata == "" {
296+ return nil
297+ }
298+
299+ props := make (properties , 0 , strings .Count (metadata , propertyDelimiter )+ 1 )
300+ for pStr := range strings .SplitSeq (metadata , propertyDelimiter ) {
301+ if pStr == "" {
302+ continue
303+ }
304+ p , err := parseProperty (pStr )
305+ if err != nil {
306+ return nil
307+ }
308+ props = append (props , p )
309+ }
310+ return props
311+ }
312+
250313// Member is a list-member of a baggage-string as defined by the W3C Baggage
251314// specification.
252315type Member struct {
253316 key , value string
317+
318+ // metadata contains the opaque W3C property suffix extracted from the wire
319+ // without the leading semicolon. properties contains API-created
320+ // properties. The fields are mutually exclusive.
321+ metadata string
254322 properties properties
255323
256324 // hasData indicates whether the created property contains data or not.
@@ -307,21 +375,16 @@ func newInvalidMember() Member {
307375 return Member {}
308376}
309377
310- // parseMember attempts to decode a Member from the passed string. It returns
311- // an error if the input is invalid according to the W3C Baggage
312- // specification.
378+ // parseMember attempts to decode a Member from the passed string. Property
379+ // metadata grammar is validated without decoding or materializing properties.
313380func parseMember (member string ) (Member , error ) {
314- var props properties
315- keyValue , properties , found := strings .Cut (member , propertyDelimiter )
381+ var metadata string
382+ keyValue , rawMetadata , found := strings .Cut (member , propertyDelimiter )
316383 if found {
317- // Parse the member properties.
318- for pStr := range strings .SplitSeq (properties , propertyDelimiter ) {
319- p , err := parseProperty (pStr )
320- if err != nil {
321- return newInvalidMember (), err
322- }
323- props = append (props , p )
384+ if invalid , ok := validateMetadata (rawMetadata ); ! ok {
385+ return newInvalidMember (), fmt .Errorf ("%w: %q" , errInvalidProperty , invalid )
324386 }
387+ metadata = normalizeMetadata (rawMetadata )
325388 }
326389 // Parse the member key/value pair.
327390
@@ -349,7 +412,7 @@ func parseMember(member string) (Member, error) {
349412 }
350413
351414 value := replaceInvalidUTF8Sequences (len (rawVal ), unescapeVal )
352- return Member {key : key , value : value , properties : props , hasData : true }, nil
415+ return Member {key : key , value : value , metadata : metadata , hasData : true }, nil
353416}
354417
355418// replaceInvalidUTF8Sequences replaces invalid UTF-8 sequences with '�'.
@@ -399,10 +462,14 @@ func (m Member) Key() string { return m.key }
399462func (m Member ) Value () string { return m .value }
400463
401464// Properties returns a copy of the Member properties.
402- func (m Member ) Properties () []Property { return m .properties .Copy () }
465+ func (m Member ) Properties () []Property {
466+ if m .metadata != "" {
467+ return propertiesFromMetadata (m .metadata )
468+ }
469+ return m .properties .Copy ()
470+ }
403471
404- // String encodes Member into a header string compliant with the W3C Baggage
405- // specification.
472+ // String encodes Member into a baggage header string.
406473// It would return empty string if the key is invalid with the W3C Baggage
407474// specification. This could happen for a UTF-8 key, as it may contain
408475// invalid characters.
@@ -413,12 +480,31 @@ func (m Member) String() string {
413480 }
414481
415482 s := m .key + keyValueDelimiter + valueEscape (m .value )
416- if len (m .properties ) > 0 {
483+ if m .metadata != "" {
484+ s += propertyDelimiter + m .metadata
485+ } else if len (m .properties ) > 0 {
417486 s += propertyDelimiter + m .properties .String ()
418487 }
419488 return s
420489}
421490
491+ func memberFromItem (key string , item baggage.Item ) Member {
492+ return Member {
493+ key : key ,
494+ value : item .Value (),
495+ metadata : item .Metadata (),
496+ properties : fromInternalProperties (item .Properties ()),
497+ hasData : true ,
498+ }
499+ }
500+
501+ func itemFromMember (member Member ) baggage.Item {
502+ if member .metadata != "" {
503+ return baggage .NewItemWithMetadata (member .value , member .metadata )
504+ }
505+ return baggage .NewItemWithProperties (member .value , member .properties .asInternal ())
506+ }
507+
422508// Baggage is a list of baggage members representing the baggage-string as
423509// defined by the W3C Baggage specification.
424510type Baggage struct { //nolint:golint
@@ -444,10 +530,7 @@ func New(members ...Member) (Baggage, error) {
444530 return Baggage {}, errInvalidMember
445531 }
446532 // OpenTelemetry resolves duplicates by last-one-wins.
447- b [m .key ] = baggage.Item {
448- Value : m .value ,
449- Properties : m .properties .asInternal (),
450- }
533+ b [m .key ] = itemFromMember (m )
451534 }
452535
453536 var truncateErr error
@@ -467,11 +550,7 @@ func New(members ...Member) (Baggage, error) {
467550 totalBytes := 0
468551 first := true
469552 for k := range b {
470- m := Member {
471- key : k ,
472- value : b [k ].Value ,
473- properties : fromInternalProperties (b [k ].Properties ),
474- }
553+ m := memberFromItem (k , b [k ])
475554 memberSize := len (m .String ())
476555 if ! first {
477556 memberSize ++ // comma separator
@@ -563,10 +642,7 @@ func Parse(bStr string) (Baggage, error) {
563642 }
564643
565644 // OpenTelemetry resolves duplicates by last-one-wins.
566- b [m .key ] = baggage.Item {
567- Value : m .value ,
568- Properties : m .properties .asInternal (),
569- }
645+ b [m .key ] = itemFromMember (m )
570646 sizes [m .key ] = memberBytes
571647 totalBytes = newTotalBytes
572648 }
@@ -597,12 +673,7 @@ func (b Baggage) Member(key string) Member {
597673 return newInvalidMember ()
598674 }
599675
600- return Member {
601- key : key ,
602- value : v .Value ,
603- properties : fromInternalProperties (v .Properties ),
604- hasData : true ,
605- }
676+ return memberFromItem (key , v )
606677}
607678
608679// Members returns all the baggage list-members.
@@ -617,12 +688,7 @@ func (b Baggage) Members() []Member {
617688
618689 members := make ([]Member , 0 , len (b .list ))
619690 for k , v := range b .list {
620- members = append (members , Member {
621- key : k ,
622- value : v .Value ,
623- properties : fromInternalProperties (v .Properties ),
624- hasData : true ,
625- })
691+ members = append (members , memberFromItem (k , v ))
626692 }
627693 return members
628694}
@@ -652,10 +718,7 @@ func (b Baggage) SetMember(member Member) (Baggage, error) {
652718 list [k ] = v
653719 }
654720
655- list [member .key ] = baggage.Item {
656- Value : member .value ,
657- Properties : member .properties .asInternal (),
658- }
721+ list [member .key ] = itemFromMember (member )
659722
660723 return Baggage {list : list }, nil
661724}
@@ -692,11 +755,7 @@ func (b Baggage) Len() int {
692755func (b Baggage ) String () string {
693756 members := make ([]string , 0 , len (b .list ))
694757 for k , v := range b .list {
695- s := Member {
696- key : k ,
697- value : v .Value ,
698- properties : fromInternalProperties (v .Properties ),
699- }.String ()
758+ s := memberFromItem (k , v ).String ()
700759
701760 // Ignored empty members.
702761 if s != "" {
@@ -706,9 +765,14 @@ func (b Baggage) String() string {
706765 return strings .Join (members , listDelimiter )
707766}
708767
709- // parsePropertyInternal attempts to decode a Property from the passed string.
710- // It follows the spec at https://www.w3.org/TR/baggage/#definition.
711- func parsePropertyInternal (s string ) (p Property , ok bool ) {
768+ type propertyFields struct {
769+ key , rawValue string
770+ hasValue bool
771+ }
772+
773+ // parsePropertyFields validates and locates a property's fields without
774+ // decoding or allocating them.
775+ func parsePropertyFields (s string ) (fields propertyFields , ok bool ) {
712776 // For the entire function we will use " key = value " as an example.
713777 // Attempting to parse the key.
714778 // First skip spaces at the beginning "< >key = value " (they could be empty).
@@ -727,23 +791,22 @@ func parsePropertyInternal(s string) (p Property, ok bool) {
727791 // If we couldn't find any valid key character,
728792 // it means the key is either empty or invalid.
729793 if keyStart == keyEnd {
730- return p , ok
794+ return fields , ok
731795 }
732796
733797 // Skip spaces after the key: " key< >= value ".
734798 index = skipSpace (s , keyEnd )
735799
736800 if index == len (s ) {
737801 // A key can have no value, like: " key ".
738- ok = true
739- p .key = s [keyStart :keyEnd ]
740- return p , ok
802+ fields .key = s [keyStart :keyEnd ]
803+ return fields , true
741804 }
742805
743806 // If we have not reached the end and we can't find the '=' delimiter,
744807 // it means the property is invalid.
745808 if s [index ] != keyValueDelimiter [0 ] {
746- return p , ok
809+ return fields , ok
747810 }
748811
749812 // Attempting to parse the value.
@@ -769,23 +832,59 @@ func parsePropertyInternal(s string) (p Property, ok bool) {
769832 // we have not reached the end, it means the property is
770833 // invalid, something like: " key = value value1".
771834 if index != len (s ) {
772- return p , ok
835+ return fields , ok
836+ }
837+ rawVal := s [valueStart :valueEnd ]
838+ if ! validPercentEncoding (rawVal ) {
839+ return fields , ok
840+ }
841+
842+ fields .key = s [keyStart :keyEnd ]
843+ fields .rawValue = rawVal
844+ fields .hasValue = true
845+ return fields , true
846+ }
847+
848+ func validPercentEncoding (s string ) bool {
849+ for i := 0 ; i < len (s ); i ++ {
850+ if s [i ] != '%' {
851+ continue
852+ }
853+ if i + 2 >= len (s ) || ! isHex (s [i + 1 ]) || ! isHex (s [i + 2 ]) {
854+ return false
855+ }
856+ i += 2
857+ }
858+ return true
859+ }
860+
861+ func isHex (c byte ) bool {
862+ return '0' <= c && c <= '9' || 'a' <= c && c <= 'f' || 'A' <= c && c <= 'F'
863+ }
864+
865+ // parsePropertyInternal attempts to decode a Property from the passed string.
866+ // It follows the spec at https://www.w3.org/TR/baggage/#definition.
867+ func parsePropertyInternal (s string ) (p Property , ok bool ) {
868+ fields , ok := parsePropertyFields (s )
869+ if ! ok {
870+ return p , false
871+ }
872+ if ! fields .hasValue {
873+ p .key = fields .key
874+ return p , true
773875 }
774876
775877 // Decode a percent-encoded value.
776- rawVal := s [valueStart :valueEnd ]
777- unescapeVal , err := url .PathUnescape (rawVal )
878+ unescapeVal , err := url .PathUnescape (fields .rawValue )
778879 if err != nil {
779- return p , ok
880+ return p , false
780881 }
781- value := replaceInvalidUTF8Sequences (len (rawVal ), unescapeVal )
882+ value := replaceInvalidUTF8Sequences (len (fields . rawValue ), unescapeVal )
782883
783- ok = true
784- p .key = s [keyStart :keyEnd ]
884+ p .key = fields .key
785885 p .hasValue = true
786-
787886 p .value = value
788- return p , ok
887+ return p , true
789888}
790889
791890func skipSpace (s string , offset int ) int {
0 commit comments