wiretrace

type Chunk struct {
	Conn   int // connection generation: a new SYN on a reused 4-tuple starts a new one
	Packet int
	TimeNS int64
	Data   []byte
}

type Completeness struct {
	Gaps     int      // streams with a hole: a segment was never captured
	Partial  []string // streams that ended inside a connect packet or frame
	Requests int      // client requests decoded
}

type Endpoint struct {
	IP   [4]byte
	Port uint16
}

type Flow struct{ Src, Dst Endpoint }

type Frame struct {
	TimeNS int64 // capture time of the segment that made the frame's last byte readable
	Flow   Flow
	// Segment is that segment's capture index, so frames completed by one
	// captured segment share it.
	Segment int
	Token   [16]byte
	Body    []byte
}

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

type Kind string

type KindSummary struct {
	Requests     int `json:"requests"`
	Replied      int `json:"replied"`
	Errors       int `json:"errors"`
	Transactions int `json:"transactions"` // GRV: transactions the requests asked for
	// ClientSegments is the number of client TCP segments that completed a
	// request: requests written together share one.
	ClientSegments int `json:"client_segments"`
	// Malformed counts replies that arrived but did not decode.
	Malformed int `json:"malformed"`
	// Commits only. ServerBatches is the number of distinct commit versions:
	// a commit proxy gives every transaction of one batch the same version.
	// (GRV and storage replies carry observed read versions, which separate
	// batches can share, so they are not grouped.)
	ServerBatches int `json:"server_batches"`
	// BatchSizes counts commit batches by the number of commits in them.
	BatchSizes map[int]int `json:"batch_sizes"`
	// ArrivalSpreadNS is the time from a batch's first commit to its last,
	// at the capture point; the median, 90th percentile and maximum.
	ArrivalSpreadNS [3]int64 `json:"arrival_spread_ns"`
	// LatencyNS is the time from request to reply at the capture point.
	LatencyNS [3]int64 `json:"latency_ns"`
	// ReorderedReplies counts successful replies that became readable before
	// their request did: their timing is not a latency and is left out of
	// LatencyNS.
	ReorderedReplies int `json:"reordered_replies,omitempty"`
	// Params counts range requests by their parameters; More counts replies
	// that reported more rows; ReplyBytes is their total packed size.
	Params     map[string]int `json:"params,omitempty"`
	More       int            `json:"more,omitempty"`
	ReplyBytes int            `json:"reply_bytes,omitempty"`
}

type Reassembler struct {

	// Gaps counts streams with data that never became readable: a segment was
	// missing, so a hole remained when the capture ended or was too long.
	Gaps int
	// contains filtered or unexported fields
}

type Request struct {
	Kind       Kind
	Flow       Flow  // client to server
	SentNS     int64 // capture time of the request's last byte
	Segment    int   // client segment number within Flow
	TxnCount   uint32
	ReplyToken [16]byte
	ReplyNS    int64 // 0: no reply captured
	Version    int64 // read or commit version from the reply
	ErrorCode  int   // nonzero: the reply was an error
	Malformed  bool  // the reply arrived but did not decode
	// Range requests only: the request's parameters and the reply's shape.
	Params     string // limit, byte limit, selector offsets and read options
	ReplyBytes int    // length of the reply's packed rows
	More       bool
}

type Rounds struct {
	Size int `json:"round_size"`
	// Whole and Split count the batches that did and did not hold a whole round.
	Whole int `json:"whole_batches"`
	Split int `json:"split_batches"`
	// FirstSplit is the index of the first batch after a whole one that did not
	// hold a whole round, -1 if none.
	FirstSplit int `json:"first_split"`
	// Runs alternates the lengths of consecutive whole and split stretches,
	// starting with a whole one (possibly of length 0).
	Runs []int `json:"runs"`
}

type Segment struct {
	Index   int // capture order, from 1
	TimeNS  int64
	Flow    Flow
	Seq     uint32
	SYN     bool
	FIN     bool
	Payload []byte
}

type Summary struct {
	Flows       int                  `json:"client_flows"`
	Kinds       map[Kind]KindSummary `json:"kinds"`
	Undecodable int                  `json:"undecodable"`
	Gaps        int                  `json:"stream_gaps"`
	// Partial counts streams that ended inside a connect packet or frame.
	Partial int `json:"partial_streams"`
	// Complete is false when any stream had a gap or ended inside a frame:
	// some requests or replies are missing, so the counts are not a measurement.
	Complete bool    `json:"complete"`
	Rounds   *Rounds `json:"rounds,omitempty"`
}

type Trace struct {
	Requests []*Request
	// Undecodable counts request frames with a followed file identifier that
	// did not decode, and replies that did not decode.
	Undecodable int
	// contains filtered or unexported fields
}