README

gRPC Configuration Settings

gRPC exposes a variety of settings. Several of these settings are available for configuration within individual receivers or exporters. In general, none of these settings should need to be adjusted.

Client Configuration

Exporters leverage client configuration.

Note that client configuration supports TLS configuration, however configuration parameters are not defined under tls_settings like server configuration. For more information, see configtls README.

Example:

exporters:
  otlp:
    endpoint: otelcol2:55690
    headers:
      test1: "value1"
      "test 2": "value 2"

Server Configuration

Receivers leverage server configuration.

Note that transport configuration can also be configured. For more information, see confignet README.

Expand ▾ Collapse ▴

Documentation

Overview

    Package configgrpc defines the gRPC configuration settings.

    Index

    Constants

    View Source
    const (
    	CompressionUnsupported = ""
    	CompressionGzip        = "gzip"
    
    	PerRPCAuthTypeBearer = "bearer"
    )

      Compression gRPC keys for supported compression types within collector

      Variables

      This section is empty.

      Functions

      func GetGRPCCompressionKey

      func GetGRPCCompressionKey(compressionType string) string

        GetGRPCCompressionKey returns the grpc registered compression key if the passed in compression key is supported, and CompressionUnsupported otherwise

        Types

        type GRPCClientSettings

        type GRPCClientSettings struct {
        	// The target to which the exporter is going to send traces or metrics,
        	// using the gRPC protocol. The valid syntax is described at
        	// https://github.com/grpc/grpc/blob/master/doc/naming.md.
        	Endpoint string `mapstructure:"endpoint"`
        
        	// The compression key for supported compression types within
        	// collector. Currently the only supported mode is `gzip`.
        	Compression string `mapstructure:"compression"`
        
        	// TLSSetting struct exposes TLS client configuration.
        	TLSSetting configtls.TLSClientSetting `mapstructure:",squash"`
        
        	// The keepalive parameters for gRPC client. See grpc.WithKeepaliveParams
        	// (https://godoc.org/google.golang.org/grpc#WithKeepaliveParams).
        	Keepalive *KeepaliveClientConfig `mapstructure:"keepalive"`
        
        	// ReadBufferSize for gRPC client. See grpc.WithReadBufferSize
        	// (https://godoc.org/google.golang.org/grpc#WithReadBufferSize).
        	ReadBufferSize int `mapstructure:"read_buffer_size"`
        
        	// WriteBufferSize for gRPC gRPC. See grpc.WithWriteBufferSize
        	// (https://godoc.org/google.golang.org/grpc#WithWriteBufferSize).
        	WriteBufferSize int `mapstructure:"write_buffer_size"`
        
        	// WaitForReady parameter configures client to wait for ready state before sending data.
        	// (https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md)
        	WaitForReady bool `mapstructure:"wait_for_ready"`
        
        	// The headers associated with gRPC requests.
        	Headers map[string]string `mapstructure:"headers"`
        
        	// PerRPCAuth parameter configures the client to send authentication data on a per-RPC basis.
        	PerRPCAuth *PerRPCAuthConfig `mapstructure:"per_rpc_auth"`
        
        	// Sets the balancer in grpclb_policy to discover the servers. Default is pick_first
        	// https://github.com/grpc/grpc-go/blob/master/examples/features/load_balancing/README.md
        	BalancerName string `mapstructure:"balancer_name"`
        }

          GRPCClientSettings defines common settings for a gRPC client configuration.

          func (*GRPCClientSettings) ToDialOptions

          func (gcs *GRPCClientSettings) ToDialOptions() ([]grpc.DialOption, error)

            ToDialOptions maps configgrpc.GRPCClientSettings to a slice of dial options for gRPC

            type GRPCServerSettings

            type GRPCServerSettings struct {
            	// Server net.Addr config. For transport only "tcp" and "unix" are valid options.
            	NetAddr confignet.NetAddr `mapstructure:",squash"`
            
            	// Configures the protocol to use TLS.
            	// The default value is nil, which will cause the protocol to not use TLS.
            	TLSSetting *configtls.TLSServerSetting `mapstructure:"tls_settings,omitempty"`
            
            	// MaxRecvMsgSizeMiB sets the maximum size (in MiB) of messages accepted by the server.
            	MaxRecvMsgSizeMiB uint64 `mapstructure:"max_recv_msg_size_mib"`
            
            	// MaxConcurrentStreams sets the limit on the number of concurrent streams to each ServerTransport.
            	// It has effect only for streaming RPCs.
            	MaxConcurrentStreams uint32 `mapstructure:"max_concurrent_streams"`
            
            	// ReadBufferSize for gRPC server. See grpc.ReadBufferSize
            	// (https://godoc.org/google.golang.org/grpc#ReadBufferSize).
            	ReadBufferSize int `mapstructure:"read_buffer_size"`
            
            	// WriteBufferSize for gRPC server. See grpc.WriteBufferSize
            	// (https://godoc.org/google.golang.org/grpc#WriteBufferSize).
            	WriteBufferSize int `mapstructure:"write_buffer_size"`
            
            	// Keepalive anchor for all the settings related to keepalive.
            	Keepalive *KeepaliveServerConfig `mapstructure:"keepalive,omitempty"`
            
            	// Auth for this receiver
            	Auth *configauth.Authentication `mapstructure:"auth,omitempty"`
            }

            func (*GRPCServerSettings) ToListener

            func (gss *GRPCServerSettings) ToListener() (net.Listener, error)

            func (*GRPCServerSettings) ToServerOption

            func (gss *GRPCServerSettings) ToServerOption() ([]grpc.ServerOption, error)

              ToServerOption maps configgrpc.GRPCServerSettings to a slice of server options for gRPC

              type KeepaliveClientConfig

              type KeepaliveClientConfig struct {
              	Time                time.Duration `mapstructure:"time,omitempty"`
              	Timeout             time.Duration `mapstructure:"timeout,omitempty"`
              	PermitWithoutStream bool          `mapstructure:"permit_without_stream,omitempty"`
              }

                KeepaliveClientConfig exposes the keepalive.ClientParameters to be used by the exporter. Refer to the original data-structure for the meaning of each parameter: https://godoc.org/google.golang.org/grpc/keepalive#ClientParameters

                type KeepaliveEnforcementPolicy

                type KeepaliveEnforcementPolicy struct {
                	MinTime             time.Duration `mapstructure:"min_time,omitempty"`
                	PermitWithoutStream bool          `mapstructure:"permit_without_stream,omitempty"`
                }

                  KeepaliveEnforcementPolicy allow configuration of the keepalive.EnforcementPolicy. The same default values as keepalive.EnforcementPolicy are applicable and get applied by the server. See https://godoc.org/google.golang.org/grpc/keepalive#EnforcementPolicy for details.

                  type KeepaliveServerConfig

                  type KeepaliveServerConfig struct {
                  	ServerParameters  *KeepaliveServerParameters  `mapstructure:"server_parameters,omitempty"`
                  	EnforcementPolicy *KeepaliveEnforcementPolicy `mapstructure:"enforcement_policy,omitempty"`
                  }

                  type KeepaliveServerParameters

                  type KeepaliveServerParameters struct {
                  	MaxConnectionIdle     time.Duration `mapstructure:"max_connection_idle,omitempty"`
                  	MaxConnectionAge      time.Duration `mapstructure:"max_connection_age,omitempty"`
                  	MaxConnectionAgeGrace time.Duration `mapstructure:"max_connection_age_grace,omitempty"`
                  	Time                  time.Duration `mapstructure:"time,omitempty"`
                  	Timeout               time.Duration `mapstructure:"timeout,omitempty"`
                  }

                    KeepaliveServerParameters allow configuration of the keepalive.ServerParameters. The same default values as keepalive.ServerParameters are applicable and get applied by the server. See https://godoc.org/google.golang.org/grpc/keepalive#ServerParameters for details.

                    type PerRPCAuth

                    type PerRPCAuth struct {
                    	// contains filtered or unexported fields
                    }

                      PerRPCAuth is a gRPC credentials.PerRPCCredentials implementation that returns an 'authorization' header.

                      func BearerToken

                      func BearerToken(t string) *PerRPCAuth

                        BearerToken returns a new PerRPCAuth based on the given token.

                        func (*PerRPCAuth) GetRequestMetadata

                        func (c *PerRPCAuth) GetRequestMetadata(context.Context, ...string) (map[string]string, error)

                          GetRequestMetadata returns the request metadata to be used with the RPC.

                          func (*PerRPCAuth) RequireTransportSecurity

                          func (c *PerRPCAuth) RequireTransportSecurity() bool

                            RequireTransportSecurity always returns true for this implementation. Passing bearer tokens in plain-text connections is a bad idea.

                            type PerRPCAuthConfig

                            type PerRPCAuthConfig struct {
                            	// AuthType represents the authentication type to use. Currently, only 'bearer' is supported.
                            	AuthType string `mapstructure:"type,omitempty"`
                            
                            	// BearerToken specifies the bearer token to use for every RPC.
                            	BearerToken string `mapstructure:"bearer_token,omitempty"`
                            }

                              PerRPCAuthConfig specifies how the Per-RPC authentication data should be obtained.