type client … var _ … // NewClient creates a new gRPC trace client. func NewClient(opts ...Option) otlptrace.Client { … } func newClient(opts ...Option) *client { … } // Start establishes a gRPC connection to the collector. func (c *client) Start(context.Context) error { … } var errAlreadyStopped … // Stop shuts down the client. // // Any active connections to a remote endpoint are closed if they were created // by the client. Any gRPC connection passed during creation using // WithGRPCConn will not be closed. It is the caller's responsibility to // handle cleanup of that resource. // // This method synchronizes with the UploadTraces method of the client. It // will wait for any active calls to that method to complete unimpeded, or it // will cancel any active calls if ctx expires. If ctx expires, the context // error will be forwarded as the returned error. All client held resources // will still be released in this situation. // // If the client has already stopped, an error will be returned describing // this. func (c *client) Stop(ctx context.Context) error { … } var errShutdown … // UploadTraces sends a batch of spans. // // Retryable errors from the server will be handled according to any // RetryConfig the client was created with. func (c *client) UploadTraces(ctx context.Context, protoSpans []*tracepb.ResourceSpans) error { … } // exportContext returns a copy of parent with an appropriate deadline and // cancellation function. // // It is the callers responsibility to cancel the returned context once its // use is complete, via the parent or directly with the returned CancelFunc, to // ensure all resources are correctly released. func (c *client) exportContext(parent context.Context) (context.Context, context.CancelFunc) { … } // retryable returns if err identifies a request that can be retried and a // duration to wait for if an explicit throttle time is included in err. func retryable(err error) (bool, time.Duration) { … } func retryableGRPCStatus(s *status.Status) (bool, time.Duration) { … } // throttleDelay returns of the status is RetryInfo // and the its duration to wait for if an explicit throttle time. func throttleDelay(s *status.Status) (bool, time.Duration) { … } // MarshalLog is the marshaling function used by the logging system to represent this Client. func (c *client) MarshalLog() interface{ … }