Documentation

Overview

    Package stats is for collecting and reporting various network and RPC stats. This package is for monitoring purpose only. All fields are read-only. All APIs are experimental.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func OutgoingTags

    func OutgoingTags(ctx context.Context) []byte

      OutgoingTags returns the tags from the context for the outbound RPC.

      This is intended for gRPC-internal use ONLY.

      func OutgoingTrace

      func OutgoingTrace(ctx context.Context) []byte

        OutgoingTrace returns the trace from the context for the outbound RPC. It is intended for gRPC-internal use.

        func SetIncomingTags

        func SetIncomingTags(ctx context.Context, b []byte) context.Context

          SetIncomingTags attaches stats tagging data to the context, to be read by the application (not sent in outgoing RPCs).

          This is intended for gRPC-internal use ONLY.

          func SetIncomingTrace

          func SetIncomingTrace(ctx context.Context, b []byte) context.Context

            SetIncomingTrace attaches stats tagging data to the context, to be read by the application (not sent in outgoing RPCs). It is intended for gRPC-internal use.

            func SetTags

            func SetTags(ctx context.Context, b []byte) context.Context

              SetTags attaches stats tagging data to the context, which will be sent in the outgoing RPC with the header grpc-tags-bin. Subsequent calls to SetTags will overwrite the values from earlier calls.

              NOTE: this is provided only for backward compatibility with existing clients and will likely be removed in an upcoming release. New uses should transmit this type of data using metadata with a different, non-reserved (i.e. does not begin with "grpc-") header name.

              func SetTrace

              func SetTrace(ctx context.Context, b []byte) context.Context

                SetTrace attaches stats tagging data to the context, which will be sent in the outgoing RPC with the header grpc-trace-bin. Subsequent calls to SetTrace will overwrite the values from earlier calls.

                NOTE: this is provided only for backward compatibility with existing clients and will likely be removed in an upcoming release. New uses should transmit this type of data using metadata with a different, non-reserved (i.e. does not begin with "grpc-") header name.

                func Tags

                func Tags(ctx context.Context) []byte

                  Tags returns the tags from the context for the inbound RPC.

                  NOTE: this is provided only for backward compatibility with existing clients and will likely be removed in an upcoming release. New uses should transmit this type of data using metadata with a different, non-reserved (i.e. does not begin with "grpc-") header name.

                  func Trace

                  func Trace(ctx context.Context) []byte

                    Trace returns the trace from the context for the inbound RPC.

                    NOTE: this is provided only for backward compatibility with existing clients and will likely be removed in an upcoming release. New uses should transmit this type of data using metadata with a different, non-reserved (i.e. does not begin with "grpc-") header name.

                    Types

                    type Begin

                    type Begin struct {
                    	// Client is true if this Begin is from client side.
                    	Client bool
                    	// BeginTime is the time when the RPC begins.
                    	BeginTime time.Time
                    	// FailFast indicates if this RPC is failfast.
                    	FailFast bool
                    }

                      Begin contains stats when an RPC begins. FailFast is only valid if this Begin is from client side.

                      func (*Begin) IsClient

                      func (s *Begin) IsClient() bool

                        IsClient indicates if the stats information is from client side.

                        type ConnBegin

                        type ConnBegin struct {
                        	// Client is true if this ConnBegin is from client side.
                        	Client bool
                        }

                          ConnBegin contains the stats of a connection when it is established.

                          func (*ConnBegin) IsClient

                          func (s *ConnBegin) IsClient() bool

                            IsClient indicates if this is from client side.

                            type ConnEnd

                            type ConnEnd struct {
                            	// Client is true if this ConnEnd is from client side.
                            	Client bool
                            }

                              ConnEnd contains the stats of a connection when it ends.

                              func (*ConnEnd) IsClient

                              func (s *ConnEnd) IsClient() bool

                                IsClient indicates if this is from client side.

                                type ConnStats

                                type ConnStats interface {
                                
                                	// IsClient returns true if this ConnStats is from client side.
                                	IsClient() bool
                                	// contains filtered or unexported methods
                                }

                                  ConnStats contains stats information about connections.

                                  type ConnTagInfo

                                  type ConnTagInfo struct {
                                  	// RemoteAddr is the remote address of the corresponding connection.
                                  	RemoteAddr net.Addr
                                  	// LocalAddr is the local address of the corresponding connection.
                                  	LocalAddr net.Addr
                                  }

                                    ConnTagInfo defines the relevant information needed by connection context tagger.

                                    type End

                                    type End struct {
                                    	// Client is true if this End is from client side.
                                    	Client bool
                                    	// BeginTime is the time when the RPC began.
                                    	BeginTime time.Time
                                    	// EndTime is the time when the RPC ends.
                                    	EndTime time.Time
                                    	// Trailer contains the trailer metadata received from the server. This
                                    	// field is only valid if this End is from the client side.
                                    	// Deprecated: use Trailer in InTrailer instead.
                                    	Trailer metadata.MD
                                    	// Error is the error the RPC ended with. It is an error generated from
                                    	// status.Status and can be converted back to status.Status using
                                    	// status.FromError if non-nil.
                                    	Error error
                                    }

                                      End contains stats when an RPC ends.

                                      func (*End) IsClient

                                      func (s *End) IsClient() bool

                                        IsClient indicates if this is from client side.

                                        type Handler

                                        type Handler interface {
                                        	// TagRPC can attach some information to the given context.
                                        	// The context used for the rest lifetime of the RPC will be derived from
                                        	// the returned context.
                                        	TagRPC(context.Context, *RPCTagInfo) context.Context
                                        	// HandleRPC processes the RPC stats.
                                        	HandleRPC(context.Context, RPCStats)
                                        
                                        	// TagConn can attach some information to the given context.
                                        	// The returned context will be used for stats handling.
                                        	// For conn stats handling, the context used in HandleConn for this
                                        	// connection will be derived from the context returned.
                                        	// For RPC stats handling,
                                        	//  - On server side, the context used in HandleRPC for all RPCs on this
                                        	// connection will be derived from the context returned.
                                        	//  - On client side, the context is not derived from the context returned.
                                        	TagConn(context.Context, *ConnTagInfo) context.Context
                                        	// HandleConn processes the Conn stats.
                                        	HandleConn(context.Context, ConnStats)
                                        }

                                          Handler defines the interface for the related stats handling (e.g., RPCs, connections).

                                          type InHeader

                                          type InHeader struct {
                                          	// Client is true if this InHeader is from client side.
                                          	Client bool
                                          	// WireLength is the wire length of header.
                                          	WireLength int
                                          	// Compression is the compression algorithm used for the RPC.
                                          	Compression string
                                          	// Header contains the header metadata received.
                                          	Header metadata.MD
                                          
                                          	// The following fields are valid only if Client is false.
                                          	// FullMethod is the full RPC method string, i.e., /package.service/method.
                                          	FullMethod string
                                          	// RemoteAddr is the remote address of the corresponding connection.
                                          	RemoteAddr net.Addr
                                          	// LocalAddr is the local address of the corresponding connection.
                                          	LocalAddr net.Addr
                                          }

                                            InHeader contains stats when a header is received.

                                            func (*InHeader) IsClient

                                            func (s *InHeader) IsClient() bool

                                              IsClient indicates if the stats information is from client side.

                                              type InPayload

                                              type InPayload struct {
                                              	// Client is true if this InPayload is from client side.
                                              	Client bool
                                              	// Payload is the payload with original type.
                                              	Payload interface{}
                                              	// Data is the serialized message payload.
                                              	Data []byte
                                              	// Length is the length of uncompressed data.
                                              	Length int
                                              	// WireLength is the length of data on wire (compressed, signed, encrypted).
                                              	WireLength int
                                              	// RecvTime is the time when the payload is received.
                                              	RecvTime time.Time
                                              }

                                                InPayload contains the information for an incoming payload.

                                                func (*InPayload) IsClient

                                                func (s *InPayload) IsClient() bool

                                                  IsClient indicates if the stats information is from client side.

                                                  type InTrailer

                                                  type InTrailer struct {
                                                  	// Client is true if this InTrailer is from client side.
                                                  	Client bool
                                                  	// WireLength is the wire length of trailer.
                                                  	WireLength int
                                                  	// Trailer contains the trailer metadata received from the server. This
                                                  	// field is only valid if this InTrailer is from the client side.
                                                  	Trailer metadata.MD
                                                  }

                                                    InTrailer contains stats when a trailer is received.

                                                    func (*InTrailer) IsClient

                                                    func (s *InTrailer) IsClient() bool

                                                      IsClient indicates if the stats information is from client side.

                                                      type OutHeader

                                                      type OutHeader struct {
                                                      	// Client is true if this OutHeader is from client side.
                                                      	Client bool
                                                      	// Compression is the compression algorithm used for the RPC.
                                                      	Compression string
                                                      	// Header contains the header metadata sent.
                                                      	Header metadata.MD
                                                      
                                                      	// The following fields are valid only if Client is true.
                                                      	// FullMethod is the full RPC method string, i.e., /package.service/method.
                                                      	FullMethod string
                                                      	// RemoteAddr is the remote address of the corresponding connection.
                                                      	RemoteAddr net.Addr
                                                      	// LocalAddr is the local address of the corresponding connection.
                                                      	LocalAddr net.Addr
                                                      }

                                                        OutHeader contains stats when a header is sent.

                                                        func (*OutHeader) IsClient

                                                        func (s *OutHeader) IsClient() bool

                                                          IsClient indicates if this stats information is from client side.

                                                          type OutPayload

                                                          type OutPayload struct {
                                                          	// Client is true if this OutPayload is from client side.
                                                          	Client bool
                                                          	// Payload is the payload with original type.
                                                          	Payload interface{}
                                                          	// Data is the serialized message payload.
                                                          	Data []byte
                                                          	// Length is the length of uncompressed data.
                                                          	Length int
                                                          	// WireLength is the length of data on wire (compressed, signed, encrypted).
                                                          	WireLength int
                                                          	// SentTime is the time when the payload is sent.
                                                          	SentTime time.Time
                                                          }

                                                            OutPayload contains the information for an outgoing payload.

                                                            func (*OutPayload) IsClient

                                                            func (s *OutPayload) IsClient() bool

                                                              IsClient indicates if this stats information is from client side.

                                                              type OutTrailer

                                                              type OutTrailer struct {
                                                              	// Client is true if this OutTrailer is from client side.
                                                              	Client bool
                                                              	// WireLength is the wire length of trailer.
                                                              	//
                                                              	// Deprecated: This field is never set. The length is not known when this message is
                                                              	// emitted because the trailer fields are compressed with hpack after that.
                                                              	WireLength int
                                                              	// Trailer contains the trailer metadata sent to the client. This
                                                              	// field is only valid if this OutTrailer is from the server side.
                                                              	Trailer metadata.MD
                                                              }

                                                                OutTrailer contains stats when a trailer is sent.

                                                                func (*OutTrailer) IsClient

                                                                func (s *OutTrailer) IsClient() bool

                                                                  IsClient indicates if this stats information is from client side.

                                                                  type RPCStats

                                                                  type RPCStats interface {
                                                                  
                                                                  	// IsClient returns true if this RPCStats is from client side.
                                                                  	IsClient() bool
                                                                  	// contains filtered or unexported methods
                                                                  }

                                                                    RPCStats contains stats information about RPCs.

                                                                    type RPCTagInfo

                                                                    type RPCTagInfo struct {
                                                                    	// FullMethodName is the RPC method in the format of /package.service/method.
                                                                    	FullMethodName string
                                                                    	// FailFast indicates if this RPC is failfast.
                                                                    	// This field is only valid on client side, it's always false on server side.
                                                                    	FailFast bool
                                                                    }

                                                                      RPCTagInfo defines the relevant information needed by RPC context tagger.