env_config.go

Documentation: google.golang.org/grpc/internal/binarylog

     1  /*
     2   *
     3   * Copyright 2018 gRPC authors.
     4   *
     5   * Licensed under the Apache License, Version 2.0 (the "License");
     6   * you may not use this file except in compliance with the License.
     7   * You may obtain a copy of the License at
     8   *
     9   *     http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   *
    17   */
    18  
    19  package binarylog
    20  
    21  import (
    22  	"errors"
    23  	"fmt"
    24  	"regexp"
    25  	"strconv"
    26  	"strings"
    27  )
    28  
    29  // NewLoggerFromConfigString reads the string and build a logger. It can be used
    30  // to build a new logger and assign it to binarylog.Logger.
    31  //
    32  // Example filter config strings:
    33  //   - "" Nothing will be logged
    34  //   - "*" All headers and messages will be fully logged.
    35  //   - "*{h}" Only headers will be logged.
    36  //   - "*{m:256}" Only the first 256 bytes of each message will be logged.
    37  //   - "Foo/*" Logs every method in service Foo
    38  //   - "Foo/*,-Foo/Bar" Logs every method in service Foo except method /Foo/Bar
    39  //   - "Foo/*,Foo/Bar{m:256}" Logs the first 256 bytes of each message in method
    40  //     /Foo/Bar, logs all headers and messages in every other method in service
    41  //     Foo.
    42  //
    43  // If two configs exist for one certain method or service, the one specified
    44  // later overrides the previous config.
    45  func NewLoggerFromConfigString(s string) Logger {
    46  	if s == "" {
    47  		return nil
    48  	}
    49  	l := newEmptyLogger()
    50  	methods := strings.Split(s, ",")
    51  	for _, method := range methods {
    52  		if err := l.fillMethodLoggerWithConfigString(method); err != nil {
    53  			grpclogLogger.Warningf("failed to parse binary log config: %v", err)
    54  			return nil
    55  		}
    56  	}
    57  	return l
    58  }
    59  
    60  // fillMethodLoggerWithConfigString parses config, creates TruncatingMethodLogger and adds
    61  // it to the right map in the logger.
    62  func (l *logger) fillMethodLoggerWithConfigString(config string) error {
    63  	// "" is invalid.
    64  	if config == "" {
    65  		return errors.New("empty string is not a valid method binary logging config")
    66  	}
    67  
    68  	// "-service/method", blacklist, no * or {} allowed.
    69  	if config[0] == '-' {
    70  		s, m, suffix, err := parseMethodConfigAndSuffix(config[1:])
    71  		if err != nil {
    72  			return fmt.Errorf("invalid config: %q, %v", config, err)
    73  		}
    74  		if m == "*" {
    75  			return fmt.Errorf("invalid config: %q, %v", config, "* not allowed in blacklist config")
    76  		}
    77  		if suffix != "" {
    78  			return fmt.Errorf("invalid config: %q, %v", config, "header/message limit not allowed in blacklist config")
    79  		}
    80  		if err := l.setBlacklist(s + "/" + m); err != nil {
    81  			return fmt.Errorf("invalid config: %v", err)
    82  		}
    83  		return nil
    84  	}
    85  
    86  	// "*{h:256;m:256}"
    87  	if config[0] == '*' {
    88  		hdr, msg, err := parseHeaderMessageLengthConfig(config[1:])
    89  		if err != nil {
    90  			return fmt.Errorf("invalid config: %q, %v", config, err)
    91  		}
    92  		if err := l.setDefaultMethodLogger(&MethodLoggerConfig{Header: hdr, Message: msg}); err != nil {
    93  			return fmt.Errorf("invalid config: %v", err)
    94  		}
    95  		return nil
    96  	}
    97  
    98  	s, m, suffix, err := parseMethodConfigAndSuffix(config)
    99  	if err != nil {
   100  		return fmt.Errorf("invalid config: %q, %v", config, err)
   101  	}
   102  	hdr, msg, err := parseHeaderMessageLengthConfig(suffix)
   103  	if err != nil {
   104  		return fmt.Errorf("invalid header/message length config: %q, %v", suffix, err)
   105  	}
   106  	if m == "*" {
   107  		if err := l.setServiceMethodLogger(s, &MethodLoggerConfig{Header: hdr, Message: msg}); err != nil {
   108  			return fmt.Errorf("invalid config: %v", err)
   109  		}
   110  	} else {
   111  		if err := l.setMethodMethodLogger(s+"/"+m, &MethodLoggerConfig{Header: hdr, Message: msg}); err != nil {
   112  			return fmt.Errorf("invalid config: %v", err)
   113  		}
   114  	}
   115  	return nil
   116  }
   117  
   118  const (
   119  	// TODO: this const is only used by env_config now. But could be useful for
   120  	// other config. Move to binarylog.go if necessary.
   121  	maxUInt = ^uint64(0)
   122  
   123  	// For "p.s/m" plus any suffix. Suffix will be parsed again. See test for
   124  	// expected output.
   125  	longMethodConfigRegexpStr = `^([\w./]+)/((?:\w+)|[*])(.+)?$`
   126  
   127  	// For suffix from above, "{h:123,m:123}". See test for expected output.
   128  	optionalLengthRegexpStr      = `(?::(\d+))?` // Optional ":123".
   129  	headerConfigRegexpStr        = `^{h` + optionalLengthRegexpStr + `}$`
   130  	messageConfigRegexpStr       = `^{m` + optionalLengthRegexpStr + `}$`
   131  	headerMessageConfigRegexpStr = `^{h` + optionalLengthRegexpStr + `;m` + optionalLengthRegexpStr + `}$`
   132  )
   133  
   134  var (
   135  	longMethodConfigRegexp    = regexp.MustCompile(longMethodConfigRegexpStr)
   136  	headerConfigRegexp        = regexp.MustCompile(headerConfigRegexpStr)
   137  	messageConfigRegexp       = regexp.MustCompile(messageConfigRegexpStr)
   138  	headerMessageConfigRegexp = regexp.MustCompile(headerMessageConfigRegexpStr)
   139  )
   140  
   141  // Turn "service/method{h;m}" into "service", "method", "{h;m}".
   142  func parseMethodConfigAndSuffix(c string) (service, method, suffix string, _ error) {
   143  	// Regexp result:
   144  	//
   145  	// in:  "p.s/m{h:123,m:123}",
   146  	// out: []string{"p.s/m{h:123,m:123}", "p.s", "m", "{h:123,m:123}"},
   147  	match := longMethodConfigRegexp.FindStringSubmatch(c)
   148  	if match == nil {
   149  		return "", "", "", fmt.Errorf("%q contains invalid substring", c)
   150  	}
   151  	service = match[1]
   152  	method = match[2]
   153  	suffix = match[3]
   154  	return
   155  }
   156  
   157  // Turn "{h:123;m:345}" into 123, 345.
   158  //
   159  // Return maxUInt if length is unspecified.
   160  func parseHeaderMessageLengthConfig(c string) (hdrLenStr, msgLenStr uint64, err error) {
   161  	if c == "" {
   162  		return maxUInt, maxUInt, nil
   163  	}
   164  	// Header config only.
   165  	if match := headerConfigRegexp.FindStringSubmatch(c); match != nil {
   166  		if s := match[1]; s != "" {
   167  			hdrLenStr, err = strconv.ParseUint(s, 10, 64)
   168  			if err != nil {
   169  				return 0, 0, fmt.Errorf("failed to convert %q to uint", s)
   170  			}
   171  			return hdrLenStr, 0, nil
   172  		}
   173  		return maxUInt, 0, nil
   174  	}
   175  
   176  	// Message config only.
   177  	if match := messageConfigRegexp.FindStringSubmatch(c); match != nil {
   178  		if s := match[1]; s != "" {
   179  			msgLenStr, err = strconv.ParseUint(s, 10, 64)
   180  			if err != nil {
   181  				return 0, 0, fmt.Errorf("failed to convert %q to uint", s)
   182  			}
   183  			return 0, msgLenStr, nil
   184  		}
   185  		return 0, maxUInt, nil
   186  	}
   187  
   188  	// Header and message config both.
   189  	if match := headerMessageConfigRegexp.FindStringSubmatch(c); match != nil {
   190  		// Both hdr and msg are specified, but one or two of them might be empty.
   191  		hdrLenStr = maxUInt
   192  		msgLenStr = maxUInt
   193  		if s := match[1]; s != "" {
   194  			hdrLenStr, err = strconv.ParseUint(s, 10, 64)
   195  			if err != nil {
   196  				return 0, 0, fmt.Errorf("failed to convert %q to uint", s)
   197  			}
   198  		}
   199  		if s := match[2]; s != "" {
   200  			msgLenStr, err = strconv.ParseUint(s, 10, 64)
   201  			if err != nil {
   202  				return 0, 0, fmt.Errorf("failed to convert %q to uint", s)
   203  			}
   204  		}
   205  		return hdrLenStr, msgLenStr, nil
   206  	}
   207  	return 0, 0, fmt.Errorf("%q contains invalid substring", c)
   208  }
   209
View as plain text