Constants (Zipkin Java Core 0.4.1 API)

java.lang.Object
- io.zipkin.Constants

public final class Constants
extends Object

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`CLIENT_ADDR` When present, `BinaryAnnotation.endpoint` indicates a client address ("ca") in a span.
`static String`	`CLIENT_RECV` The client received ("cr") a response from a server.
`static String`	`CLIENT_RECV_FRAGMENT` Optionally logs progress of a (CLIENT_RECV, WIRE_RECV).
`static String`	`CLIENT_SEND` The client sent ("cs") a request to a server.
`static String`	`CLIENT_SEND_FRAGMENT` Optionally logs progress of a (CLIENT_SEND, WIRE_SEND).
`static String`	`LOCAL_COMPONENT` The `value` of "lc" is the component or namespace of a local span.
`static String`	`SERVER_ADDR` When present, `BinaryAnnotation.endpoint` indicates a server address ("sa") in a span.
`static String`	`SERVER_RECV` The server received ("sr") a request from a client.
`static String`	`SERVER_RECV_FRAGMENT` Optionally logs progress of a (SERVER_RECV, WIRE_RECV).
`static String`	`SERVER_SEND` The server sent ("ss") a response to a client.
`static String`	`SERVER_SEND_FRAGMENT` Optionally logs progress of a (SERVER_SEND, WIRE_SEND).
`static String`	`WIRE_RECV` Optionally logs an attempt to receive a message from the wire.
`static String`	`WIRE_SEND` Optionally logs an attempt to send a message on the wire.

Method Summary
- Methods inherited from class java.lang.Object
  clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - CLIENT_SEND
```
public static final String CLIENT_SEND
```
    The client sent ("cs") a request to a server. There is only one send per span. For example, if there's a transport error, each attempt can be logged as a WIRE_SEND annotation.
    If chunking is involved, each chunk could be logged as a separate CLIENT_SEND_FRAGMENT in the same span.
    Annotation.endpoint is not the server. It is the host which logged the send event, almost always the client. When logging CLIENT_SEND, instrumentation should also log the SERVER_ADDR.
    
    See Also:
    
    Constant Field Values
  - CLIENT_RECV
```
public static final String CLIENT_RECV
```
    The client received ("cr") a response from a server. There is only one receive per span. For example, if duplicate responses were received, each can be logged as a WIRE_RECV annotation.
    If chunking is involved, each chunk could be logged as a separate CLIENT_RECV_FRAGMENT in the same span.
    Annotation.endpoint is not the server. It is the host which logged the receive event, almost always the client. The actual endpoint of the server is recorded separately as SERVER_ADDR when CLIENT_SEND is logged.
    
    See Also:
    
    Constant Field Values
  - SERVER_SEND
```
public static final String SERVER_SEND
```
    The server sent ("ss") a response to a client. There is only one response per span. If there's a transport error, each attempt can be logged as a WIRE_SEND annotation.
    Typically, a trace ends with a server send, so the last timestamp of a trace is often the timestamp of the root span's server send.
    If chunking is involved, each chunk could be logged as a separate SERVER_SEND_FRAGMENT in the same span.
    Annotation.endpoint is not the client. It is the host which logged the send event, almost always the server. The actual endpoint of the client is recorded separately as CLIENT_ADDR when SERVER_RECV is logged.
    
    See Also:
    
    Constant Field Values
  - SERVER_RECV
```
public static final String SERVER_RECV
```
    The server received ("sr") a request from a client. There is only one request per span. For example, if duplicate responses were received, each can be logged as a WIRE_RECV annotation.
    Typically, a trace starts with a server receive, so the first timestamp of a trace is often the timestamp of the root span's server receive.
    If chunking is involved, each chunk could be logged as a separate SERVER_RECV_FRAGMENT in the same span.
    Annotation.endpoint is not the client. It is the host which logged the receive event, almost always the server. When logging SERVER_RECV, instrumentation should also log the CLIENT_ADDR.
    
    See Also:
    
    Constant Field Values
  - WIRE_SEND
```
public static final String WIRE_SEND
```
    Optionally logs an attempt to send a message on the wire. Multiple wire send events could indicate network retries. A lag between client or server send and wire send might indicate queuing or processing delay.
    
    See Also:
    
    Constant Field Values
  - WIRE_RECV
```
public static final String WIRE_RECV
```
    Optionally logs an attempt to receive a message from the wire. Multiple wire receive events could indicate network retries. A lag between wire receive and client or server receive might indicate queuing or processing delay.
    
    See Also:
    
    Constant Field Values
  - CLIENT_SEND_FRAGMENT
```
public static final String CLIENT_SEND_FRAGMENT
```
    Optionally logs progress of a (CLIENT_SEND, WIRE_SEND). For example, this could be one chunk in a chunked request.
    
    See Also:
    
    Constant Field Values
  - CLIENT_RECV_FRAGMENT
```
public static final String CLIENT_RECV_FRAGMENT
```
    Optionally logs progress of a (CLIENT_RECV, WIRE_RECV). For example, this could be one chunk in a chunked response.
    
    See Also:
    
    Constant Field Values
  - SERVER_SEND_FRAGMENT
```
public static final String SERVER_SEND_FRAGMENT
```
    Optionally logs progress of a (SERVER_SEND, WIRE_SEND). For example, this could be one chunk in a chunked response.
    
    See Also:
    
    Constant Field Values
  - SERVER_RECV_FRAGMENT
```
public static final String SERVER_RECV_FRAGMENT
```
    Optionally logs progress of a (SERVER_RECV, WIRE_RECV). For example, this could be one chunk in a chunked request.
    
    See Also:
    
    Constant Field Values
  - LOCAL_COMPONENT
```
public static final String LOCAL_COMPONENT
```
    The value of "lc" is the component or namespace of a local span.
    BinaryAnnotation.endpoint adds service context needed to support queries.
    Local Component("lc") supports three key features: flagging, query by service and filtering Span.name by namespace.
    While structurally the same, local spans are fundamentally different than RPC spans in how they should be interpreted. For example, zipkin v1 tools center on RPC latency and service graphs. Root local-spans are neither indicative of critical path RPC latency, nor have impact on the shape of a service graph. By flagging with "lc", tools can special-case local spans.
    Zipkin v1 Spans are unqueryable unless they can be indexed by service name. The only path to a service name is via host. By logging "lc", a local span can be queried even if no other annotations are logged.
    The value of "lc" is the namespace of Span.name. For example, it might be "finatra2", for a span named "bootstrap". "lc" allows you to resolves conflicts for the same Span.name, for example "finatra/bootstrap" vs "finch/bootstrap". Using local component, you'd search for spans named "bootstrap" where "lc=finch"
    
    See Also:
    
    Constant Field Values
  - CLIENT_ADDR
```
public static final String CLIENT_ADDR
```
    When present, BinaryAnnotation.endpoint indicates a client address ("ca") in a span. Most likely, there's only one. Multiple addresses are possible when a client changes its ip or port within a span.
    
    See Also:
    
    Constant Field Values
  - SERVER_ADDR
```
public static final String SERVER_ADDR
```
    When present, BinaryAnnotation.endpoint indicates a server address ("sa") in a span. Most likely, there's only one. Multiple addresses are possible when a client is redirected, or fails to a different server ip or port.
    
    See Also:
    
    Constant Field Values

Class Constants

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

CLIENT_SEND

CLIENT_RECV

SERVER_SEND

SERVER_RECV

WIRE_SEND

WIRE_RECV

CLIENT_SEND_FRAGMENT

CLIENT_RECV_FRAGMENT

SERVER_SEND_FRAGMENT

SERVER_RECV_FRAGMENT

LOCAL_COMPONENT

CLIENT_ADDR

SERVER_ADDR