Documentation

Overview

Package cloudtrace provides access to the Cloud Trace API.

For product documentation, see: https://cloud.google.com/trace

Creating a client

Usage example:

import "google.golang.org/api/cloudtrace/v2"
...
ctx := context.Background()
cloudtraceService, err := cloudtrace.NewService(ctx)

In this example, Google Application Default Credentials are used for authentication.

For information on how to create and obtain Application Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials.

Other authentication options

By default, all available scopes (see "Constants") are used to authenticate. To restrict scopes, use option.WithScopes:

cloudtraceService, err := cloudtrace.NewService(ctx, option.WithScopes(cloudtrace.TraceAppendScope))

To use an API key for authentication (note: some APIs do not support API keys), use option.WithAPIKey:

cloudtraceService, err := cloudtrace.NewService(ctx, option.WithAPIKey("AIza..."))

To use an OAuth token (e.g., a user token obtained via a three-legged OAuth flow), use option.WithTokenSource:

config := &oauth2.Config{...}
// ...
token, err := config.Exchange(ctx, ...)
cloudtraceService, err := cloudtrace.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token)))

See https://godoc.org/google.golang.org/api/option/ for details on options.

Index

Constants

View Source
const (
	// View and manage your data across Google Cloud Platform services
	CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"

	// Write Trace data for a project or application
	TraceAppendScope = "https://www.googleapis.com/auth/trace.append"
)

    OAuth2 scopes used by this API.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type Annotation

    type Annotation struct {
    	// Attributes: A set of attributes on the annotation. You can have up to
    	// 4 attributes
    	// per Annotation.
    	Attributes *Attributes `json:"attributes,omitempty"`
    
    	// Description: A user-supplied message describing the event. The
    	// maximum length for
    	// the description is 256 bytes.
    	Description *TruncatableString `json:"description,omitempty"`
    
    	// ForceSendFields is a list of field names (e.g. "Attributes") to
    	// unconditionally include in API requests. By default, fields with
    	// empty values are omitted from API requests. However, any non-pointer,
    	// non-interface field appearing in ForceSendFields will be sent to the
    	// server regardless of whether the field is empty or not. This may be
    	// used to include empty fields in Patch requests.
    	ForceSendFields []string `json:"-"`
    
    	// NullFields is a list of field names (e.g. "Attributes") to include in
    	// API requests with the JSON null value. By default, fields with empty
    	// values are omitted from API requests. However, any field with an
    	// empty value appearing in NullFields will be sent to the server as
    	// null. It is an error if a field in this list has a non-empty value.
    	// This may be used to include null fields in Patch requests.
    	NullFields []string `json:"-"`
    }

      Annotation: Text annotation with a set of attributes.

      func (*Annotation) MarshalJSON

      func (s *Annotation) MarshalJSON() ([]byte, error)

      type AttributeValue

      type AttributeValue struct {
      	// BoolValue: A Boolean value represented by `true` or `false`.
      	BoolValue bool `json:"boolValue,omitempty"`
      
      	// IntValue: A 64-bit signed integer.
      	IntValue int64 `json:"intValue,omitempty,string"`
      
      	// StringValue: A string up to 256 bytes long.
      	StringValue *TruncatableString `json:"stringValue,omitempty"`
      
      	// ForceSendFields is a list of field names (e.g. "BoolValue") to
      	// unconditionally include in API requests. By default, fields with
      	// empty values are omitted from API requests. However, any non-pointer,
      	// non-interface field appearing in ForceSendFields will be sent to the
      	// server regardless of whether the field is empty or not. This may be
      	// used to include empty fields in Patch requests.
      	ForceSendFields []string `json:"-"`
      
      	// NullFields is a list of field names (e.g. "BoolValue") to include in
      	// API requests with the JSON null value. By default, fields with empty
      	// values are omitted from API requests. However, any field with an
      	// empty value appearing in NullFields will be sent to the server as
      	// null. It is an error if a field in this list has a non-empty value.
      	// This may be used to include null fields in Patch requests.
      	NullFields []string `json:"-"`
      }

        AttributeValue: The allowed types for [VALUE] in a `[KEY]:[VALUE]` attribute.

        func (*AttributeValue) MarshalJSON

        func (s *AttributeValue) MarshalJSON() ([]byte, error)

        type Attributes

        type Attributes struct {
        	// AttributeMap: The set of attributes. Each attribute's key can be up
        	// to 128 bytes
        	// long. The value can be a string up to 256 bytes, a signed 64-bit
        	// integer,
        	// or the Boolean values `true` and `false`. For example:
        	//
        	//     "/instance_id": "my-instance"
        	//     "/http/user_agent": ""
        	//     "/http/request_bytes": 300
        	//     "abc.com/myattribute": true
        	AttributeMap map[string]AttributeValue `json:"attributeMap,omitempty"`
        
        	// DroppedAttributesCount: The number of attributes that were discarded.
        	// Attributes can be discarded
        	// because their keys are too long or because there are too many
        	// attributes.
        	// If this value is 0 then all attributes are valid.
        	DroppedAttributesCount int64 `json:"droppedAttributesCount,omitempty"`
        
        	// ForceSendFields is a list of field names (e.g. "AttributeMap") to
        	// unconditionally include in API requests. By default, fields with
        	// empty values are omitted from API requests. However, any non-pointer,
        	// non-interface field appearing in ForceSendFields will be sent to the
        	// server regardless of whether the field is empty or not. This may be
        	// used to include empty fields in Patch requests.
        	ForceSendFields []string `json:"-"`
        
        	// NullFields is a list of field names (e.g. "AttributeMap") to include
        	// in API requests with the JSON null value. By default, fields with
        	// empty values are omitted from API requests. However, any field with
        	// an empty value appearing in NullFields will be sent to the server as
        	// null. It is an error if a field in this list has a non-empty value.
        	// This may be used to include null fields in Patch requests.
        	NullFields []string `json:"-"`
        }

          Attributes: A set of attributes, each in the format `[KEY]:[VALUE]`.

          func (*Attributes) MarshalJSON

          func (s *Attributes) MarshalJSON() ([]byte, error)

          type BatchWriteSpansRequest

          type BatchWriteSpansRequest struct {
          	// Spans: Required. A list of new spans. The span names must not match
          	// existing
          	// spans, or the results are undefined.
          	Spans []*Span `json:"spans,omitempty"`
          
          	// ForceSendFields is a list of field names (e.g. "Spans") to
          	// unconditionally include in API requests. By default, fields with
          	// empty values are omitted from API requests. However, any non-pointer,
          	// non-interface field appearing in ForceSendFields will be sent to the
          	// server regardless of whether the field is empty or not. This may be
          	// used to include empty fields in Patch requests.
          	ForceSendFields []string `json:"-"`
          
          	// NullFields is a list of field names (e.g. "Spans") to include in API
          	// requests with the JSON null value. By default, fields with empty
          	// values are omitted from API requests. However, any field with an
          	// empty value appearing in NullFields will be sent to the server as
          	// null. It is an error if a field in this list has a non-empty value.
          	// This may be used to include null fields in Patch requests.
          	NullFields []string `json:"-"`
          }

            BatchWriteSpansRequest: The request message for the `BatchWriteSpans` method.

            func (*BatchWriteSpansRequest) MarshalJSON

            func (s *BatchWriteSpansRequest) MarshalJSON() ([]byte, error)

            type Empty

            type Empty struct {
            	// ServerResponse contains the HTTP response code and headers from the
            	// server.
            	googleapi.ServerResponse `json:"-"`
            }

              Empty: A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance:

              service Foo {
                rpc Bar(google.protobuf.Empty) returns
              

              (google.protobuf.Empty);

              }
              

              The JSON representation for `Empty` is empty JSON object `{}`.

              type Link struct {
              	// Attributes: A set of attributes on the link. You have have up to  32
              	// attributes per
              	// link.
              	Attributes *Attributes `json:"attributes,omitempty"`
              
              	// SpanId: The [SPAN_ID] for a span within a trace.
              	SpanId string `json:"spanId,omitempty"`
              
              	// TraceId: The [TRACE_ID] for a trace within a project.
              	TraceId string `json:"traceId,omitempty"`
              
              	// Type: The relationship of the current span relative to the linked
              	// span.
              	//
              	// Possible values:
              	//   "TYPE_UNSPECIFIED" - The relationship of the two spans is unknown.
              	//   "CHILD_LINKED_SPAN" - The linked span is a child of the current
              	// span.
              	//   "PARENT_LINKED_SPAN" - The linked span is a parent of the current
              	// span.
              	Type string `json:"type,omitempty"`
              
              	// ForceSendFields is a list of field names (e.g. "Attributes") to
              	// unconditionally include in API requests. By default, fields with
              	// empty values are omitted from API requests. However, any non-pointer,
              	// non-interface field appearing in ForceSendFields will be sent to the
              	// server regardless of whether the field is empty or not. This may be
              	// used to include empty fields in Patch requests.
              	ForceSendFields []string `json:"-"`
              
              	// NullFields is a list of field names (e.g. "Attributes") to include in
              	// API requests with the JSON null value. By default, fields with empty
              	// values are omitted from API requests. However, any field with an
              	// empty value appearing in NullFields will be sent to the server as
              	// null. It is an error if a field in this list has a non-empty value.
              	// This may be used to include null fields in Patch requests.
              	NullFields []string `json:"-"`
              }

                Link: A pointer from the current span to another span in the same trace or in a different trace. For example, this can be used in batching operations, where a single batch handler processes multiple requests from different traces or when the handler receives a request from a different project.

                func (*Link) MarshalJSON

                func (s *Link) MarshalJSON() ([]byte, error)
                type Links struct {
                	// DroppedLinksCount: The number of dropped links after the maximum size
                	// was enforced. If
                	// this value is 0, then no links were dropped.
                	DroppedLinksCount int64 `json:"droppedLinksCount,omitempty"`
                
                	// Link: A collection of links.
                	Link []*Link `json:"link,omitempty"`
                
                	// ForceSendFields is a list of field names (e.g. "DroppedLinksCount")
                	// to unconditionally include in API requests. By default, fields with
                	// empty values are omitted from API requests. However, any non-pointer,
                	// non-interface field appearing in ForceSendFields will be sent to the
                	// server regardless of whether the field is empty or not. This may be
                	// used to include empty fields in Patch requests.
                	ForceSendFields []string `json:"-"`
                
                	// NullFields is a list of field names (e.g. "DroppedLinksCount") to
                	// include in API requests with the JSON null value. By default, fields
                	// with empty values are omitted from API requests. However, any field
                	// with an empty value appearing in NullFields will be sent to the
                	// server as null. It is an error if a field in this list has a
                	// non-empty value. This may be used to include null fields in Patch
                	// requests.
                	NullFields []string `json:"-"`
                }

                  Links: A collection of links, which are references from this span to a span in the same or different trace.

                  func (*Links) MarshalJSON

                  func (s *Links) MarshalJSON() ([]byte, error)

                  type MessageEvent

                  type MessageEvent struct {
                  	// CompressedSizeBytes: The number of compressed bytes sent or received.
                  	// If missing assumed to
                  	// be the same size as uncompressed.
                  	CompressedSizeBytes int64 `json:"compressedSizeBytes,omitempty,string"`
                  
                  	// Id: An identifier for the MessageEvent's message that can be used to
                  	// match
                  	// SENT and RECEIVED MessageEvents. It is recommended to be unique
                  	// within
                  	// a Span.
                  	Id int64 `json:"id,omitempty,string"`
                  
                  	// Type: Type of MessageEvent. Indicates whether the message was sent
                  	// or
                  	// received.
                  	//
                  	// Possible values:
                  	//   "TYPE_UNSPECIFIED" - Unknown event type.
                  	//   "SENT" - Indicates a sent message.
                  	//   "RECEIVED" - Indicates a received message.
                  	Type string `json:"type,omitempty"`
                  
                  	// UncompressedSizeBytes: The number of uncompressed bytes sent or
                  	// received.
                  	UncompressedSizeBytes int64 `json:"uncompressedSizeBytes,omitempty,string"`
                  
                  	// ForceSendFields is a list of field names (e.g. "CompressedSizeBytes")
                  	// to unconditionally include in API requests. By default, fields with
                  	// empty values are omitted from API requests. However, any non-pointer,
                  	// non-interface field appearing in ForceSendFields will be sent to the
                  	// server regardless of whether the field is empty or not. This may be
                  	// used to include empty fields in Patch requests.
                  	ForceSendFields []string `json:"-"`
                  
                  	// NullFields is a list of field names (e.g. "CompressedSizeBytes") to
                  	// include in API requests with the JSON null value. By default, fields
                  	// with empty values are omitted from API requests. However, any field
                  	// with an empty value appearing in NullFields will be sent to the
                  	// server as null. It is an error if a field in this list has a
                  	// non-empty value. This may be used to include null fields in Patch
                  	// requests.
                  	NullFields []string `json:"-"`
                  }

                    MessageEvent: An event describing a message sent/received between Spans.

                    func (*MessageEvent) MarshalJSON

                    func (s *MessageEvent) MarshalJSON() ([]byte, error)

                    type Module

                    type Module struct {
                    	// BuildId: A unique identifier for the module, usually a hash of
                    	// its
                    	// contents (up to 128 bytes).
                    	BuildId *TruncatableString `json:"buildId,omitempty"`
                    
                    	// Module: For example: main binary, kernel modules, and dynamic
                    	// libraries
                    	// such as libc.so, sharedlib.so (up to 256 bytes).
                    	Module *TruncatableString `json:"module,omitempty"`
                    
                    	// ForceSendFields is a list of field names (e.g. "BuildId") to
                    	// unconditionally include in API requests. By default, fields with
                    	// empty values are omitted from API requests. However, any non-pointer,
                    	// non-interface field appearing in ForceSendFields will be sent to the
                    	// server regardless of whether the field is empty or not. This may be
                    	// used to include empty fields in Patch requests.
                    	ForceSendFields []string `json:"-"`
                    
                    	// NullFields is a list of field names (e.g. "BuildId") to include in
                    	// API requests with the JSON null value. By default, fields with empty
                    	// values are omitted from API requests. However, any field with an
                    	// empty value appearing in NullFields will be sent to the server as
                    	// null. It is an error if a field in this list has a non-empty value.
                    	// This may be used to include null fields in Patch requests.
                    	NullFields []string `json:"-"`
                    }

                      Module: Binary module.

                      func (*Module) MarshalJSON

                      func (s *Module) MarshalJSON() ([]byte, error)

                      type ProjectsService

                      type ProjectsService struct {
                      	Traces *ProjectsTracesService
                      	// contains filtered or unexported fields
                      }

                      func NewProjectsService

                      func NewProjectsService(s *Service) *ProjectsService

                      type ProjectsTracesBatchWriteCall

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

                      func (*ProjectsTracesBatchWriteCall) Context

                        Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                        func (*ProjectsTracesBatchWriteCall) Do

                          Do executes the "cloudtrace.projects.traces.batchWrite" call. Exactly one of *Empty or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Empty.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                          func (*ProjectsTracesBatchWriteCall) Fields

                            Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                            func (*ProjectsTracesBatchWriteCall) Header

                              Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                              type ProjectsTracesService

                              type ProjectsTracesService struct {
                              	Spans *ProjectsTracesSpansService
                              	// contains filtered or unexported fields
                              }

                              func NewProjectsTracesService

                              func NewProjectsTracesService(s *Service) *ProjectsTracesService

                              func (*ProjectsTracesService) BatchWrite

                              func (r *ProjectsTracesService) BatchWrite(name string, batchwritespansrequest *BatchWriteSpansRequest) *ProjectsTracesBatchWriteCall

                                BatchWrite: Sends new spans to new or existing traces. You cannot update existing spans. In this case, writing traces is not considered an active developer method since traces are machine generated.

                                type ProjectsTracesSpansCreateSpanCall

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

                                func (*ProjectsTracesSpansCreateSpanCall) Context

                                  Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                  func (*ProjectsTracesSpansCreateSpanCall) Do

                                    Do executes the "cloudtrace.projects.traces.spans.createSpan" call. Exactly one of *Span or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Span.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                    func (*ProjectsTracesSpansCreateSpanCall) Fields

                                      Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                      func (*ProjectsTracesSpansCreateSpanCall) Header

                                        Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                        type ProjectsTracesSpansService

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

                                        func NewProjectsTracesSpansService

                                        func NewProjectsTracesSpansService(s *Service) *ProjectsTracesSpansService

                                        func (*ProjectsTracesSpansService) CreateSpan

                                          CreateSpan: Creates a new span. In this case, writing traces is not considered an active developer method since traces are machine generated.

                                          type Service

                                          type Service struct {
                                          	BasePath  string // API endpoint base URL
                                          	UserAgent string // optional additional User-Agent fragment
                                          
                                          	Projects *ProjectsService
                                          	// contains filtered or unexported fields
                                          }

                                          func New

                                          func New(client *http.Client) (*Service, error)

                                            New creates a new Service. It uses the provided http.Client for requests.

                                            Deprecated: please use NewService instead. To provide a custom HTTP client, use option.WithHTTPClient. If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead.

                                            func NewService

                                            func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error)

                                              NewService creates a new Service.

                                              type Span

                                              type Span struct {
                                              	// Attributes: A set of attributes on the span. You can have up to 32
                                              	// attributes per
                                              	// span.
                                              	Attributes *Attributes `json:"attributes,omitempty"`
                                              
                                              	// ChildSpanCount: Optional. The number of child spans that were
                                              	// generated while this span
                                              	// was active. If set, allows implementation to detect missing child
                                              	// spans.
                                              	ChildSpanCount int64 `json:"childSpanCount,omitempty"`
                                              
                                              	// DisplayName: Required. A description of the span's operation (up to
                                              	// 128 bytes).
                                              	// Stackdriver Trace displays the description in the
                                              	// Google Cloud Platform Console.
                                              	// For example, the display name can be a qualified method name or a
                                              	// file name
                                              	// and a line number where the operation is called. A best practice is
                                              	// to use
                                              	// the same display name within an application and at the same call
                                              	// point.
                                              	// This makes it easier to correlate spans in different traces.
                                              	DisplayName *TruncatableString `json:"displayName,omitempty"`
                                              
                                              	// EndTime: Required. The end time of the span. On the client side, this
                                              	// is the time kept by
                                              	// the local machine where the span execution ends. On the server side,
                                              	// this
                                              	// is the time when the server application handler stops running.
                                              	EndTime string `json:"endTime,omitempty"`
                                              
                                              	// Links: Links associated with the span. You can have up to 128 links
                                              	// per Span.
                                              	Links *Links `json:"links,omitempty"`
                                              
                                              	// Name: The resource name of the span in the following format:
                                              	//
                                              	//     projects/[PROJECT_ID]/traces/[TRACE_ID]/spans/SPAN_ID is a unique
                                              	// identifier for a trace within a project;
                                              	// it is a 32-character hexadecimal encoding of a 16-byte
                                              	// array.
                                              	//
                                              	// [SPAN_ID] is a unique identifier for a span within a trace; it
                                              	// is a 16-character hexadecimal encoding of an 8-byte array.
                                              	Name string `json:"name,omitempty"`
                                              
                                              	// ParentSpanId: The [SPAN_ID] of this span's parent span. If this is a
                                              	// root span,
                                              	// then this field must be empty.
                                              	ParentSpanId string `json:"parentSpanId,omitempty"`
                                              
                                              	// SameProcessAsParentSpan: Optional. Set this parameter to indicate
                                              	// whether this span is in
                                              	// the same process as its parent. If you do not set this
                                              	// parameter,
                                              	// Stackdriver Trace is unable to take advantage of this
                                              	// helpful
                                              	// information.
                                              	SameProcessAsParentSpan bool `json:"sameProcessAsParentSpan,omitempty"`
                                              
                                              	// SpanId: Required. The [SPAN_ID] portion of the span's resource name.
                                              	SpanId string `json:"spanId,omitempty"`
                                              
                                              	// SpanKind: Distinguishes between spans generated in a particular
                                              	// context. For example,
                                              	// two spans with the same name may be distinguished using `CLIENT`
                                              	// (caller)
                                              	// and `SERVER` (callee) to identify an RPC call.
                                              	//
                                              	// Possible values:
                                              	//   "SPAN_KIND_UNSPECIFIED" - Unspecified. Do NOT use as
                                              	// default.
                                              	// Implementations MAY assume SpanKind.INTERNAL to be default.
                                              	//   "INTERNAL" - Indicates that the span is used internally. Default
                                              	// value.
                                              	//   "SERVER" - Indicates that the span covers server-side handling of
                                              	// an RPC or other
                                              	// remote network request.
                                              	//   "CLIENT" - Indicates that the span covers the client-side wrapper
                                              	// around an RPC or
                                              	// other remote request.
                                              	//   "PRODUCER" - Indicates that the span describes producer sending a
                                              	// message to a broker.
                                              	// Unlike client and  server, there is no direct critical path
                                              	// latency
                                              	// relationship between producer and consumer spans (e.g. publishing
                                              	// a
                                              	// message to a pubsub service).
                                              	//   "CONSUMER" - Indicates that the span describes consumer recieving a
                                              	// message from a
                                              	// broker. Unlike client and  server, there is no direct critical
                                              	// path
                                              	// latency relationship between producer and consumer spans (e.g.
                                              	// receiving
                                              	// a message from a pubsub service subscription).
                                              	SpanKind string `json:"spanKind,omitempty"`
                                              
                                              	// StackTrace: Stack trace captured at the start of the span.
                                              	StackTrace *StackTrace `json:"stackTrace,omitempty"`
                                              
                                              	// StartTime: Required. The start time of the span. On the client side,
                                              	// this is the time kept by
                                              	// the local machine where the span execution starts. On the server
                                              	// side, this
                                              	// is the time when the server's application handler starts running.
                                              	StartTime string `json:"startTime,omitempty"`
                                              
                                              	// Status: Optional. The final status for this span.
                                              	Status *Status `json:"status,omitempty"`
                                              
                                              	// TimeEvents: A set of time events. You can have up to 32 annotations
                                              	// and 128 message
                                              	// events per span.
                                              	TimeEvents *TimeEvents `json:"timeEvents,omitempty"`
                                              
                                              	// ServerResponse contains the HTTP response code and headers from the
                                              	// server.
                                              	googleapi.ServerResponse `json:"-"`
                                              
                                              	// ForceSendFields is a list of field names (e.g. "Attributes") to
                                              	// unconditionally include in API requests. By default, fields with
                                              	// empty values are omitted from API requests. However, any non-pointer,
                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                              	// server regardless of whether the field is empty or not. This may be
                                              	// used to include empty fields in Patch requests.
                                              	ForceSendFields []string `json:"-"`
                                              
                                              	// NullFields is a list of field names (e.g. "Attributes") to include in
                                              	// API requests with the JSON null value. By default, fields with empty
                                              	// values are omitted from API requests. However, any field with an
                                              	// empty value appearing in NullFields will be sent to the server as
                                              	// null. It is an error if a field in this list has a non-empty value.
                                              	// This may be used to include null fields in Patch requests.
                                              	NullFields []string `json:"-"`
                                              }

                                                Span: A span represents a single operation within a trace. Spans can be nested to form a trace tree. Often, a trace contains a root span that describes the end-to-end latency, and one or more subspans for its sub-operations. A trace can also contain multiple root spans, or none at all. Spans do not need to be contiguous—there may be gaps or overlaps between spans in a trace.

                                                func (*Span) MarshalJSON

                                                func (s *Span) MarshalJSON() ([]byte, error)

                                                type StackFrame

                                                type StackFrame struct {
                                                	// ColumnNumber: The column number where the function call appears, if
                                                	// available.
                                                	// This is important in JavaScript because of its anonymous functions.
                                                	ColumnNumber int64 `json:"columnNumber,omitempty,string"`
                                                
                                                	// FileName: The name of the source file where the function call appears
                                                	// (up to 256
                                                	// bytes).
                                                	FileName *TruncatableString `json:"fileName,omitempty"`
                                                
                                                	// FunctionName: The fully-qualified name that uniquely identifies the
                                                	// function or
                                                	// method that is active in this frame (up to 1024 bytes).
                                                	FunctionName *TruncatableString `json:"functionName,omitempty"`
                                                
                                                	// LineNumber: The line number in `file_name` where the function call
                                                	// appears.
                                                	LineNumber int64 `json:"lineNumber,omitempty,string"`
                                                
                                                	// LoadModule: The binary module from where the code was loaded.
                                                	LoadModule *Module `json:"loadModule,omitempty"`
                                                
                                                	// OriginalFunctionName: An un-mangled function name, if `function_name`
                                                	// is
                                                	// [mangled](http://www.avabodh.com/cxxin/namemangling.html). The name
                                                	// can
                                                	// be fully-qualified (up to 1024 bytes).
                                                	OriginalFunctionName *TruncatableString `json:"originalFunctionName,omitempty"`
                                                
                                                	// SourceVersion: The version of the deployed source code (up to 128
                                                	// bytes).
                                                	SourceVersion *TruncatableString `json:"sourceVersion,omitempty"`
                                                
                                                	// ForceSendFields is a list of field names (e.g. "ColumnNumber") to
                                                	// unconditionally include in API requests. By default, fields with
                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                	// server regardless of whether the field is empty or not. This may be
                                                	// used to include empty fields in Patch requests.
                                                	ForceSendFields []string `json:"-"`
                                                
                                                	// NullFields is a list of field names (e.g. "ColumnNumber") to include
                                                	// in API requests with the JSON null value. By default, fields with
                                                	// empty values are omitted from API requests. However, any field with
                                                	// an empty value appearing in NullFields will be sent to the server as
                                                	// null. It is an error if a field in this list has a non-empty value.
                                                	// This may be used to include null fields in Patch requests.
                                                	NullFields []string `json:"-"`
                                                }

                                                  StackFrame: Represents a single stack frame in a stack trace.

                                                  func (*StackFrame) MarshalJSON

                                                  func (s *StackFrame) MarshalJSON() ([]byte, error)

                                                  type StackFrames

                                                  type StackFrames struct {
                                                  	// DroppedFramesCount: The number of stack frames that were dropped
                                                  	// because there
                                                  	// were too many stack frames.
                                                  	// If this value is 0, then no stack frames were dropped.
                                                  	DroppedFramesCount int64 `json:"droppedFramesCount,omitempty"`
                                                  
                                                  	// Frame: Stack frames in this call stack.
                                                  	Frame []*StackFrame `json:"frame,omitempty"`
                                                  
                                                  	// ForceSendFields is a list of field names (e.g. "DroppedFramesCount")
                                                  	// to unconditionally include in API requests. By default, fields with
                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                  	// server regardless of whether the field is empty or not. This may be
                                                  	// used to include empty fields in Patch requests.
                                                  	ForceSendFields []string `json:"-"`
                                                  
                                                  	// NullFields is a list of field names (e.g. "DroppedFramesCount") to
                                                  	// include in API requests with the JSON null value. By default, fields
                                                  	// with empty values are omitted from API requests. However, any field
                                                  	// with an empty value appearing in NullFields will be sent to the
                                                  	// server as null. It is an error if a field in this list has a
                                                  	// non-empty value. This may be used to include null fields in Patch
                                                  	// requests.
                                                  	NullFields []string `json:"-"`
                                                  }

                                                    StackFrames: A collection of stack frames, which can be truncated.

                                                    func (*StackFrames) MarshalJSON

                                                    func (s *StackFrames) MarshalJSON() ([]byte, error)

                                                    type StackTrace

                                                    type StackTrace struct {
                                                    	// StackFrames: Stack frames in this stack trace. A maximum of 128
                                                    	// frames are allowed.
                                                    	StackFrames *StackFrames `json:"stackFrames,omitempty"`
                                                    
                                                    	// StackTraceHashId: The hash ID is used to conserve network bandwidth
                                                    	// for duplicate
                                                    	// stack traces within a single trace.
                                                    	//
                                                    	// Often multiple spans will have identical stack traces.
                                                    	// The first occurrence of a stack trace should contain both
                                                    	// the
                                                    	// `stackFrame` content and a value in `stackTraceHashId`.
                                                    	//
                                                    	// Subsequent spans within the same request can refer
                                                    	// to that stack trace by only setting `stackTraceHashId`.
                                                    	StackTraceHashId int64 `json:"stackTraceHashId,omitempty,string"`
                                                    
                                                    	// ForceSendFields is a list of field names (e.g. "StackFrames") to
                                                    	// unconditionally include in API requests. By default, fields with
                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                    	// server regardless of whether the field is empty or not. This may be
                                                    	// used to include empty fields in Patch requests.
                                                    	ForceSendFields []string `json:"-"`
                                                    
                                                    	// NullFields is a list of field names (e.g. "StackFrames") to include
                                                    	// in API requests with the JSON null value. By default, fields with
                                                    	// empty values are omitted from API requests. However, any field with
                                                    	// an empty value appearing in NullFields will be sent to the server as
                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                    	// This may be used to include null fields in Patch requests.
                                                    	NullFields []string `json:"-"`
                                                    }

                                                      StackTrace: A call stack appearing in a trace.

                                                      func (*StackTrace) MarshalJSON

                                                      func (s *StackTrace) MarshalJSON() ([]byte, error)

                                                      type Status

                                                      type Status struct {
                                                      	// Code: The status code, which should be an enum value of
                                                      	// google.rpc.Code.
                                                      	Code int64 `json:"code,omitempty"`
                                                      
                                                      	// Details: A list of messages that carry the error details.  There is a
                                                      	// common set of
                                                      	// message types for APIs to use.
                                                      	Details []googleapi.RawMessage `json:"details,omitempty"`
                                                      
                                                      	// Message: A developer-facing error message, which should be in
                                                      	// English. Any
                                                      	// user-facing error message should be localized and sent in
                                                      	// the
                                                      	// google.rpc.Status.details field, or localized by the client.
                                                      	Message string `json:"message,omitempty"`
                                                      
                                                      	// ForceSendFields is a list of field names (e.g. "Code") to
                                                      	// unconditionally include in API requests. By default, fields with
                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                      	// server regardless of whether the field is empty or not. This may be
                                                      	// used to include empty fields in Patch requests.
                                                      	ForceSendFields []string `json:"-"`
                                                      
                                                      	// NullFields is a list of field names (e.g. "Code") to include in API
                                                      	// requests with the JSON null value. By default, fields with empty
                                                      	// values are omitted from API requests. However, any field with an
                                                      	// empty value appearing in NullFields will be sent to the server as
                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                      	// This may be used to include null fields in Patch requests.
                                                      	NullFields []string `json:"-"`
                                                      }

                                                        Status: The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details.

                                                        You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).

                                                        func (*Status) MarshalJSON

                                                        func (s *Status) MarshalJSON() ([]byte, error)

                                                        type TimeEvent

                                                        type TimeEvent struct {
                                                        	// Annotation: Text annotation with a set of attributes.
                                                        	Annotation *Annotation `json:"annotation,omitempty"`
                                                        
                                                        	// MessageEvent: An event describing a message sent/received between
                                                        	// Spans.
                                                        	MessageEvent *MessageEvent `json:"messageEvent,omitempty"`
                                                        
                                                        	// Time: The timestamp indicating the time the event occurred.
                                                        	Time string `json:"time,omitempty"`
                                                        
                                                        	// ForceSendFields is a list of field names (e.g. "Annotation") to
                                                        	// unconditionally include in API requests. By default, fields with
                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                        	// server regardless of whether the field is empty or not. This may be
                                                        	// used to include empty fields in Patch requests.
                                                        	ForceSendFields []string `json:"-"`
                                                        
                                                        	// NullFields is a list of field names (e.g. "Annotation") to include in
                                                        	// API requests with the JSON null value. By default, fields with empty
                                                        	// values are omitted from API requests. However, any field with an
                                                        	// empty value appearing in NullFields will be sent to the server as
                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                        	// This may be used to include null fields in Patch requests.
                                                        	NullFields []string `json:"-"`
                                                        }

                                                          TimeEvent: A time-stamped annotation or message event in the Span.

                                                          func (*TimeEvent) MarshalJSON

                                                          func (s *TimeEvent) MarshalJSON() ([]byte, error)

                                                          type TimeEvents

                                                          type TimeEvents struct {
                                                          	// DroppedAnnotationsCount: The number of dropped annotations in all the
                                                          	// included time events.
                                                          	// If the value is 0, then no annotations were dropped.
                                                          	DroppedAnnotationsCount int64 `json:"droppedAnnotationsCount,omitempty"`
                                                          
                                                          	// DroppedMessageEventsCount: The number of dropped message events in
                                                          	// all the included time events.
                                                          	// If the value is 0, then no message events were dropped.
                                                          	DroppedMessageEventsCount int64 `json:"droppedMessageEventsCount,omitempty"`
                                                          
                                                          	// TimeEvent: A collection of `TimeEvent`s.
                                                          	TimeEvent []*TimeEvent `json:"timeEvent,omitempty"`
                                                          
                                                          	// ForceSendFields is a list of field names (e.g.
                                                          	// "DroppedAnnotationsCount") to unconditionally include in API
                                                          	// requests. By default, fields with empty values are omitted from API
                                                          	// requests. However, any non-pointer, non-interface field appearing in
                                                          	// ForceSendFields will be sent to the server regardless of whether the
                                                          	// field is empty or not. This may be used to include empty fields in
                                                          	// Patch requests.
                                                          	ForceSendFields []string `json:"-"`
                                                          
                                                          	// NullFields is a list of field names (e.g. "DroppedAnnotationsCount")
                                                          	// to include in API requests with the JSON null value. By default,
                                                          	// fields with empty values are omitted from API requests. However, any
                                                          	// field with an empty value appearing in NullFields will be sent to the
                                                          	// server as null. It is an error if a field in this list has a
                                                          	// non-empty value. This may be used to include null fields in Patch
                                                          	// requests.
                                                          	NullFields []string `json:"-"`
                                                          }

                                                            TimeEvents: A collection of `TimeEvent`s. A `TimeEvent` is a time-stamped annotation on the span, consisting of either user-supplied key:value pairs, or details of a message sent/received between Spans.

                                                            func (*TimeEvents) MarshalJSON

                                                            func (s *TimeEvents) MarshalJSON() ([]byte, error)

                                                            type TruncatableString

                                                            type TruncatableString struct {
                                                            	// TruncatedByteCount: The number of bytes removed from the original
                                                            	// string. If this
                                                            	// value is 0, then the string was not shortened.
                                                            	TruncatedByteCount int64 `json:"truncatedByteCount,omitempty"`
                                                            
                                                            	// Value: The shortened string. For example, if the original string is
                                                            	// 500
                                                            	// bytes long and the limit of the string is 128 bytes, then
                                                            	// `value` contains the first 128 bytes of the 500-byte
                                                            	// string.
                                                            	//
                                                            	// Truncation always happens on a UTF8 character boundary. If there
                                                            	// are multi-byte characters in the string, then the length of
                                                            	// the
                                                            	// shortened string might be less than the size limit.
                                                            	Value string `json:"value,omitempty"`
                                                            
                                                            	// ForceSendFields is a list of field names (e.g. "TruncatedByteCount")
                                                            	// to unconditionally include in API requests. By default, fields with
                                                            	// empty values are omitted from API requests. However, any non-pointer,
                                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                                            	// server regardless of whether the field is empty or not. This may be
                                                            	// used to include empty fields in Patch requests.
                                                            	ForceSendFields []string `json:"-"`
                                                            
                                                            	// NullFields is a list of field names (e.g. "TruncatedByteCount") to
                                                            	// include in API requests with the JSON null value. By default, fields
                                                            	// with empty values are omitted from API requests. However, any field
                                                            	// with an empty value appearing in NullFields will be sent to the
                                                            	// server as null. It is an error if a field in this list has a
                                                            	// non-empty value. This may be used to include null fields in Patch
                                                            	// requests.
                                                            	NullFields []string `json:"-"`
                                                            }

                                                              TruncatableString: Represents a string that might be shortened to a specified length.

                                                              func (*TruncatableString) MarshalJSON

                                                              func (s *TruncatableString) MarshalJSON() ([]byte, error)