Documentation

Index

Constants

View Source
const CLIENT_ADDR = "ca"
View Source
const CLIENT_RECV = "cr"
View Source
const CLIENT_RECV_FRAGMENT = "crf"
View Source
const CLIENT_SEND = "cs"
View Source
const CLIENT_SEND_FRAGMENT = "csf"
View Source
const LOCAL_COMPONENT = "lc"
View Source
const SERVER_ADDR = "sa"
View Source
const SERVER_RECV = "sr"
View Source
const SERVER_RECV_FRAGMENT = "srf"
View Source
const SERVER_SEND = "ss"
View Source
const SERVER_SEND_FRAGMENT = "ssf"
View Source
const WIRE_RECV = "wr"
View Source
const WIRE_SEND = "ws"

Variables

View Source
var GoUnusedProtection__ int
View Source
var Span_Debug_DEFAULT bool = false
View Source
var Span_Duration_DEFAULT int64
View Source
var Span_ParentID_DEFAULT int64
View Source
var Span_Timestamp_DEFAULT int64
View Source
var ZipkinCollectorSubmitZipkinBatchResult_Success_DEFAULT []*Response

Functions

This section is empty.

Types

type Annotation

type Annotation struct {
	Timestamp int64     `thrift:"timestamp,1" json:"timestamp"`
	Value     string    `thrift:"value,2" json:"value"`
	Host      *Endpoint `thrift:"host,3" json:"host,omitempty"`
}

    An annotation is similar to a log statement. It includes a host field which allows these events to be attributed properly, and also aggregatable.

    Attributes:

    - Timestamp: Microseconds from epoch.
    

    This value should use the most precise value possible. For example, gettimeofday or syncing nanoTime against a tick of currentTimeMillis.

    - Value
    - Host: Always the host that recorded the event. By specifying the host you allow
    

    rollup of all events (such as client requests to a service) by IP address.

    func NewAnnotation

    func NewAnnotation() *Annotation

    func (*Annotation) GetHost

    func (p *Annotation) GetHost() *Endpoint

    func (*Annotation) GetTimestamp

    func (p *Annotation) GetTimestamp() int64

    func (*Annotation) GetValue

    func (p *Annotation) GetValue() string

    func (*Annotation) IsSetHost

    func (p *Annotation) IsSetHost() bool

    func (*Annotation) Read

    func (p *Annotation) Read(iprot thrift.TProtocol) error

    func (*Annotation) String

    func (p *Annotation) String() string

    func (*Annotation) Write

    func (p *Annotation) Write(oprot thrift.TProtocol) error

    type AnnotationType

    type AnnotationType int64
    const (
    	AnnotationType_BOOL   AnnotationType = 0
    	AnnotationType_BYTES  AnnotationType = 1
    	AnnotationType_I16    AnnotationType = 2
    	AnnotationType_I32    AnnotationType = 3
    	AnnotationType_I64    AnnotationType = 4
    	AnnotationType_DOUBLE AnnotationType = 5
    	AnnotationType_STRING AnnotationType = 6
    )

    func AnnotationTypeFromString

    func AnnotationTypeFromString(s string) (AnnotationType, error)

    func AnnotationTypePtr

    func AnnotationTypePtr(v AnnotationType) *AnnotationType

    func (AnnotationType) MarshalText

    func (p AnnotationType) MarshalText() ([]byte, error)

    func (AnnotationType) String

    func (p AnnotationType) String() string

    func (*AnnotationType) UnmarshalText

    func (p *AnnotationType) UnmarshalText(text []byte) error

    type BinaryAnnotation

    type BinaryAnnotation struct {
    	Key            string         `thrift:"key,1" json:"key"`
    	Value          []byte         `thrift:"value,2" json:"value"`
    	AnnotationType AnnotationType `thrift:"annotation_type,3" json:"annotation_type"`
    	Host           *Endpoint      `thrift:"host,4" json:"host,omitempty"`
    }

      Binary annotations are tags applied to a Span to give it context. For example, a binary annotation of "http.uri" could the path to a resource in a RPC call.

      Binary annotations of type STRING are always queryable, though more a historical implementation detail than a structural concern.

      Binary annotations can repeat, and vary on the host. Similar to Annotation, the host indicates who logged the event. This allows you to tell the difference between the client and server side of the same key. For example, the key "http.uri" might be different on the client and server side due to rewriting, like "/api/v1/myresource" vs "/myresource. Via the host field, you can see the different points of view, which often help in debugging.

      Attributes:

      - Key
      - Value
      - AnnotationType
      - Host: The host that recorded tag, which allows you to differentiate between
      

      multiple tags with the same key. There are two exceptions to this.

      When the key is CLIENT_ADDR or SERVER_ADDR, host indicates the source or destination of an RPC. This exception allows zipkin to display network context of uninstrumented services, or clients such as web browsers.

      func NewBinaryAnnotation

      func NewBinaryAnnotation() *BinaryAnnotation

      func (*BinaryAnnotation) GetAnnotationType

      func (p *BinaryAnnotation) GetAnnotationType() AnnotationType

      func (*BinaryAnnotation) GetHost

      func (p *BinaryAnnotation) GetHost() *Endpoint

      func (*BinaryAnnotation) GetKey

      func (p *BinaryAnnotation) GetKey() string

      func (*BinaryAnnotation) GetValue

      func (p *BinaryAnnotation) GetValue() []byte

      func (*BinaryAnnotation) IsSetHost

      func (p *BinaryAnnotation) IsSetHost() bool

      func (*BinaryAnnotation) Read

      func (p *BinaryAnnotation) Read(iprot thrift.TProtocol) error

      func (*BinaryAnnotation) String

      func (p *BinaryAnnotation) String() string

      func (*BinaryAnnotation) Write

      func (p *BinaryAnnotation) Write(oprot thrift.TProtocol) error

      type Endpoint

      type Endpoint struct {
      	Ipv4        int32  `thrift:"ipv4,1" json:"ipv4"`
      	Port        int16  `thrift:"port,2" json:"port"`
      	ServiceName string `thrift:"service_name,3" json:"service_name"`
      }

        Indicates the network context of a service recording an annotation with two exceptions.

        When a BinaryAnnotation, and key is CLIENT_ADDR or SERVER_ADDR, the endpoint indicates the source or destination of an RPC. This exception allows zipkin to display network context of uninstrumented services, or clients such as web browsers.

        Attributes:

        - Ipv4: IPv4 host address packed into 4 bytes.
        

        Ex for the ip 1.2.3.4, it would be (1 << 24) | (2 << 16) | (3 << 8) | 4

        - Port: IPv4 port
        

        Note: this is to be treated as an unsigned integer, so watch for negatives.

        Conventionally, when the port isn't known, port = 0.

        - ServiceName: Service name in lowercase, such as "memcache" or "zipkin-web"
        

        Conventionally, when the service name isn't known, service_name = "unknown".

        var Annotation_Host_DEFAULT *Endpoint
        var BinaryAnnotation_Host_DEFAULT *Endpoint

        func NewEndpoint

        func NewEndpoint() *Endpoint

        func (*Endpoint) GetIpv4

        func (p *Endpoint) GetIpv4() int32

        func (*Endpoint) GetPort

        func (p *Endpoint) GetPort() int16

        func (*Endpoint) GetServiceName

        func (p *Endpoint) GetServiceName() string

        func (*Endpoint) Read

        func (p *Endpoint) Read(iprot thrift.TProtocol) error

        func (*Endpoint) String

        func (p *Endpoint) String() string

        func (*Endpoint) Write

        func (p *Endpoint) Write(oprot thrift.TProtocol) error

        type Response

        type Response struct {
        	Ok bool `thrift:"ok,1,required" json:"ok"`
        }

          Attributes:

          - Ok
          

          func NewResponse

          func NewResponse() *Response

          func (*Response) GetOk

          func (p *Response) GetOk() bool

          func (*Response) Read

          func (p *Response) Read(iprot thrift.TProtocol) error

          func (*Response) String

          func (p *Response) String() string

          func (*Response) Write

          func (p *Response) Write(oprot thrift.TProtocol) error

          type Span

          type Span struct {
          	TraceID int64 `thrift:"trace_id,1" json:"trace_id"`
          	// unused field # 2
          	Name        string        `thrift:"name,3" json:"name"`
          	ID          int64         `thrift:"id,4" json:"id"`
          	ParentID    *int64        `thrift:"parent_id,5" json:"parent_id,omitempty"`
          	Annotations []*Annotation `thrift:"annotations,6" json:"annotations"`
          	// unused field # 7
          	BinaryAnnotations []*BinaryAnnotation `thrift:"binary_annotations,8" json:"binary_annotations"`
          	Debug             bool                `thrift:"debug,9" json:"debug,omitempty"`
          	Timestamp         *int64              `thrift:"timestamp,10" json:"timestamp,omitempty"`
          	Duration          *int64              `thrift:"duration,11" json:"duration,omitempty"`
          }

            A trace is a series of spans (often RPC calls) which form a latency tree.

            The root span is where trace_id = id and parent_id = Nil. The root span is usually the longest interval in the trace, starting with a SERVER_RECV annotation and ending with a SERVER_SEND.

            Attributes:

            - TraceID
            - Name: Span name in lowercase, rpc method for example
            

            Conventionally, when the span name isn't known, name = "unknown".

            - ID
            - ParentID
            - Annotations
            - BinaryAnnotations
            - Debug
            - Timestamp: Microseconds from epoch of the creation of this span.
            

            This value should be set directly by instrumentation, using the most precise value possible. For example, gettimeofday or syncing nanoTime against a tick of currentTimeMillis.

            For compatibilty with instrumentation that precede this field, collectors or span stores can derive this via Annotation.timestamp. For example, SERVER_RECV.timestamp or CLIENT_SEND.timestamp.

            This field is optional for compatibility with old data: first-party span stores are expected to support this at time of introduction.

            - Duration: Measurement of duration in microseconds, used to support queries.
            

            This value should be set directly, where possible. Doing so encourages precise measurement decoupled from problems of clocks, such as skew or NTP updates causing time to move backwards.

            For compatibilty with instrumentation that precede this field, collectors or span stores can derive this by subtracting Annotation.timestamp. For example, SERVER_SEND.timestamp - SERVER_RECV.timestamp.

            If this field is persisted as unset, zipkin will continue to work, except duration query support will be implementation-specific. Similarly, setting this field non-atomically is implementation-specific.

            This field is i64 vs i32 to support spans longer than 35 minutes.

            func NewSpan

            func NewSpan() *Span

            func (*Span) GetAnnotations

            func (p *Span) GetAnnotations() []*Annotation

            func (*Span) GetBinaryAnnotations

            func (p *Span) GetBinaryAnnotations() []*BinaryAnnotation

            func (*Span) GetDebug

            func (p *Span) GetDebug() bool

            func (*Span) GetDuration

            func (p *Span) GetDuration() int64

            func (*Span) GetID

            func (p *Span) GetID() int64

            func (*Span) GetName

            func (p *Span) GetName() string

            func (*Span) GetParentID

            func (p *Span) GetParentID() int64

            func (*Span) GetTimestamp

            func (p *Span) GetTimestamp() int64

            func (*Span) GetTraceID

            func (p *Span) GetTraceID() int64

            func (*Span) IsSetDebug

            func (p *Span) IsSetDebug() bool

            func (*Span) IsSetDuration

            func (p *Span) IsSetDuration() bool

            func (*Span) IsSetParentID

            func (p *Span) IsSetParentID() bool

            func (*Span) IsSetTimestamp

            func (p *Span) IsSetTimestamp() bool

            func (*Span) Read

            func (p *Span) Read(iprot thrift.TProtocol) error

            func (*Span) String

            func (p *Span) String() string

            func (*Span) Write

            func (p *Span) Write(oprot thrift.TProtocol) error

            type ZipkinCollector

            type ZipkinCollector interface {
            	// Parameters:
            	//  - Spans
            	SubmitZipkinBatch(spans []*Span) (r []*Response, err error)
            }

            type ZipkinCollectorClient

            type ZipkinCollectorClient struct {
            	Transport       thrift.TTransport
            	ProtocolFactory thrift.TProtocolFactory
            	InputProtocol   thrift.TProtocol
            	OutputProtocol  thrift.TProtocol
            	SeqId           int32
            }

            func NewZipkinCollectorClientProtocol

            func NewZipkinCollectorClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *ZipkinCollectorClient

            func (*ZipkinCollectorClient) SubmitZipkinBatch

            func (p *ZipkinCollectorClient) SubmitZipkinBatch(spans []*Span) (r []*Response, err error)

              Parameters:

              - Spans
              

              type ZipkinCollectorProcessor

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

              func NewZipkinCollectorProcessor

              func NewZipkinCollectorProcessor(handler ZipkinCollector) *ZipkinCollectorProcessor

              func (*ZipkinCollectorProcessor) AddToProcessorMap

              func (p *ZipkinCollectorProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction)

              func (*ZipkinCollectorProcessor) GetProcessorFunction

              func (p *ZipkinCollectorProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool)

              func (*ZipkinCollectorProcessor) Process

              func (p *ZipkinCollectorProcessor) Process(iprot, oprot thrift.TProtocol) (success bool, err thrift.TException)

              func (*ZipkinCollectorProcessor) ProcessorMap

              type ZipkinCollectorSubmitZipkinBatchArgs

              type ZipkinCollectorSubmitZipkinBatchArgs struct {
              	Spans []*Span `thrift:"spans,1" json:"spans"`
              }

                Attributes:

                - Spans
                

                func NewZipkinCollectorSubmitZipkinBatchArgs

                func NewZipkinCollectorSubmitZipkinBatchArgs() *ZipkinCollectorSubmitZipkinBatchArgs

                func (*ZipkinCollectorSubmitZipkinBatchArgs) GetSpans

                func (p *ZipkinCollectorSubmitZipkinBatchArgs) GetSpans() []*Span

                func (*ZipkinCollectorSubmitZipkinBatchArgs) Read

                func (*ZipkinCollectorSubmitZipkinBatchArgs) String

                func (*ZipkinCollectorSubmitZipkinBatchArgs) Write

                type ZipkinCollectorSubmitZipkinBatchResult

                type ZipkinCollectorSubmitZipkinBatchResult struct {
                	Success []*Response `thrift:"success,0" json:"success,omitempty"`
                }

                  Attributes:

                  - Success
                  

                  func NewZipkinCollectorSubmitZipkinBatchResult

                  func NewZipkinCollectorSubmitZipkinBatchResult() *ZipkinCollectorSubmitZipkinBatchResult

                  func (*ZipkinCollectorSubmitZipkinBatchResult) GetSuccess

                  func (*ZipkinCollectorSubmitZipkinBatchResult) IsSetSuccess

                  func (p *ZipkinCollectorSubmitZipkinBatchResult) IsSetSuccess() bool

                  func (*ZipkinCollectorSubmitZipkinBatchResult) Read

                  func (*ZipkinCollectorSubmitZipkinBatchResult) String

                  func (*ZipkinCollectorSubmitZipkinBatchResult) Write