trace

type CloseDoneInfo struct {
	Error error
}

type CloseStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
}

type ClusterCloseDoneInfo struct {
	Error error
}

type ClusterCloseStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
}

type ClusterGetDoneInfo struct {
	Endpoint endpointInfo
	Error    error
}

type ClusterGetStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
}

type ClusterInitDoneInfo struct{}

type ClusterInitStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
}

type ClusterInsertDoneInfo struct {
	State ConnState
}

type ClusterInsertStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context  *context.Context
	Endpoint endpointInfo
}

type ClusterRemoveDoneInfo struct {
	State ConnState
}

type ClusterRemoveStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context  *context.Context
	Endpoint endpointInfo
}

type ClusterUpdateDoneInfo struct {
	State ConnState
}

type ClusterUpdateStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context  *context.Context
	Endpoint endpointInfo
}

type ConnInvokeDoneInfo struct {
	Error  error
	Issues []Issue
	OpID   string
	State  ConnState
}

type ConnInvokeStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context  *context.Context
	Endpoint endpointInfo
	Method   Method
}

type ConnNewStreamDoneInfo struct {
	State ConnState
	Error error
}

type ConnNewStreamRecvInfo struct {
	Error error
}

type ConnNewStreamStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context  *context.Context
	Endpoint endpointInfo
	Method   Method
}

type ConnReleaseDoneInfo struct {
	Lock int
}

type ConnReleaseStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context  *context.Context
	Endpoint endpointInfo
}

type ConnState interface {
	IsValid() bool
	String() string
	Code() int
}

type ConnStateChangeDoneInfo struct {
	State ConnState
}

type ConnStateChangeStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context  *context.Context
	Endpoint endpointInfo
	State    ConnState
}

type ConnTakeDoneInfo struct {
	Lock  int
	Error error
}

type ConnTakeStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context  *context.Context
	Endpoint endpointInfo
}

type Coordination struct{}

type Details uint64

type DiscoverDoneInfo struct {
	Location  string
	Endpoints []string
	Error     error
}

type DiscoverStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context  *context.Context
	Address  string
	Database string
}

type Discovery struct {
	OnDiscover func(DiscoverStartInfo) func(DiscoverDoneInfo)
	OnWhoAmI   func(WhoAmIStartInfo) func(WhoAmIDoneInfo)
}

type Driver struct {
	// Driver runtime events
	OnInit  func(InitStartInfo) func(InitDoneInfo)
	OnClose func(CloseStartInfo) func(CloseDoneInfo)

	// Network events
	OnNetRead  func(NetReadStartInfo) func(NetReadDoneInfo)
	OnNetWrite func(NetWriteStartInfo) func(NetWriteDoneInfo)
	OnNetDial  func(NetDialStartInfo) func(NetDialDoneInfo)
	OnNetClose func(NetCloseStartInfo) func(NetCloseDoneInfo)

	// Resolver events
	OnResolve func(ResolveStartInfo) func(ResolveDoneInfo)

	// Conn events
	OnConnStateChange func(ConnStateChangeStartInfo) func(ConnStateChangeDoneInfo)
	OnConnInvoke      func(ConnInvokeStartInfo) func(ConnInvokeDoneInfo)
	OnConnNewStream   func(ConnNewStreamStartInfo) func(ConnNewStreamRecvInfo) func(ConnNewStreamDoneInfo)
	OnConnTake        func(ConnTakeStartInfo) func(ConnTakeDoneInfo)
	OnConnRelease     func(ConnReleaseStartInfo) func(ConnReleaseDoneInfo)

	// Cluster events
	OnClusterInit   func(ClusterInitStartInfo) func(ClusterInitDoneInfo)
	OnClusterClose  func(ClusterCloseStartInfo) func(ClusterCloseDoneInfo)
	OnClusterGet    func(ClusterGetStartInfo) func(ClusterGetDoneInfo)
	OnClusterInsert func(ClusterInsertStartInfo) func(ClusterInsertDoneInfo)
	OnClusterUpdate func(ClusterUpdateStartInfo) func(ClusterUpdateDoneInfo)
	OnClusterRemove func(ClusterRemoveStartInfo) func(ClusterRemoveDoneInfo)
	OnPessimizeNode func(PessimizeNodeStartInfo) func(PessimizeNodeDoneInfo)

	// Credentials events
	OnGetCredentials func(GetCredentialsStartInfo) func(GetCredentialsDoneInfo)
}

type ExecuteDataQueryDoneInfo struct {
	Tx       transactionInfo
	Prepared bool
	Result   result
	Error    error
}

type ExecuteDataQueryStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context    *context.Context
	Session    sessionInfo
	Query      dataQuery
	Parameters queryParameters
}

type ExecuteDoneInfo struct {
	Result result
	Error  error
}

type ExecuteStartInfo struct {
	Context    context.Context
	Query      string
	Parameters queryParameters
}

type ExplainQueryDoneInfo struct {
	AST   string
	Plan  string
	Error error
}

type ExplainQueryStartInfo struct {
	Context *context.Context
	Session sessionInfo
	Query   string
}

type FieldStubber struct {
	// OnStub is an optional callback that is called when field getting
	// stubbed.
	OnStub func(name string)

	// OnCall is an optional callback that will be called for each stubbed
	// field getting called.
	OnCall func(name string, args ...interface{})
}

type GetCredentialsDoneInfo struct {
	Token string
	Error error
}

type GetCredentialsStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
}

type InitDoneInfo struct {
	Error error
}

type InitStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context  *context.Context
	Endpoint string
	Database string
	Secure   bool
}

type Issue interface {
	GetMessage() string
	GetIssueCode() uint32
	GetSeverity() uint32
}

type KeepAliveDoneInfo struct {
	Error error
}

type KeepAliveStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
	Session sessionInfo
}

type Method string

type NetCloseDoneInfo struct {
	Error error
}

type NetCloseStartInfo struct {
	Address string
}

type NetDialDoneInfo struct {
	Error error
}

type NetDialStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
	Address string
}

type NetReadDoneInfo struct {
	Received int
	Error    error
}

type NetReadStartInfo struct {
	Address string
	Buffer  int
}

type NetWriteDoneInfo struct {
	Sent  int
	Error error
}

type NetWriteStartInfo struct {
	Address string
	Bytes   int
}

type PessimizeNodeDoneInfo struct {
	State ConnState
}

type PessimizeNodeStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context  *context.Context
	Endpoint endpointInfo
	State    ConnState
	Cause    error
}

type PooStateChangeInfo struct {
	Size  int
	Event string
}

type PoolCloseDoneInfo struct {
	Error error
}

type PoolCloseStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
}

type PoolDoDoneInfo struct {
	Attempts int
	Error    error
}

type PoolDoIntermediateInfo struct {
	Error error
}

type PoolDoStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context    *context.Context
	Idempotent bool
}

type PoolDoTxDoneInfo struct {
	Attempts int
	Error    error
}

type PoolDoTxIntermediateInfo struct {
	Error error
}

type PoolDoTxStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context    *context.Context
	Idempotent bool
}

type PoolGetDoneInfo struct {
	Session  sessionInfo
	Attempts int
	Error    error
}

type PoolGetStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
}

type PoolInitDoneInfo struct {
	Limit            int
	KeepAliveMinSize int
}

type PoolInitStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
}

type PoolPutDoneInfo struct {
	Error error
}

type PoolPutStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
	Session sessionInfo
}

type PoolSessionCloseDoneInfo struct{}

type PoolSessionCloseStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
	Session sessionInfo
}

type PoolSessionNewDoneInfo struct {
	Session sessionInfo
	Error   error
}

type PoolSessionNewStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
}

type PoolWaitDoneInfo struct {
	Session sessionInfo
	Error   error
}

type PoolWaitStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
}

type PrepareDataQueryDoneInfo struct {
	Result dataQuery
	Error  error
}

type PrepareDataQueryStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
	Session sessionInfo
	Query   string
}

type Ratelimiter struct{}

type ResolveDoneInfo struct {
	Error error
}

type ResolveStartInfo struct {
	Target   string
	Resolved []string
}

type Retry struct {
	OnRetry func(RetryLoopStartInfo) func(RetryLoopIntermediateInfo) func(RetryLoopDoneInfo)
}

type RetryLoopDoneInfo struct {
	Attempts int
	Error    error
}

type RetryLoopIntermediateInfo struct {
	Error error
}

type RetryLoopStartInfo struct {
	Context    context.Context
	ID         string
	Idempotent bool
}

type Scheme struct{}

type Scripting struct {
	OnExecute       func(ExecuteStartInfo) func(ExecuteDoneInfo)
	OnStreamExecute func(StreamExecuteStartInfo) func(StreamExecuteIntermediateInfo) func(StreamExecuteDoneInfo)
	OnExplain       func(info ExplainQueryStartInfo) func(doneInfo ExplainQueryDoneInfo)
}

type SessionDeleteDoneInfo struct {
	Error error
}

type SessionDeleteStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
	Session sessionInfo
}

type SessionNewDoneInfo struct {
	Session sessionInfo
	Error   error
}

type SessionNewStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
}

type SessionQueryStreamExecuteDoneInfo struct {
	Error error
}

type SessionQueryStreamExecuteIntermediateInfo struct {
	Error error
}

type SessionQueryStreamExecuteStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context    *context.Context
	Session    sessionInfo
	Query      dataQuery
	Parameters queryParameters
}

type SessionQueryStreamReadDoneInfo struct {
	Error error
}

type SessionQueryStreamReadIntermediateInfo struct {
	Error error
}

type SessionQueryStreamReadStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
	Session sessionInfo
}

type SessionTransactionBeginDoneInfo struct {
	Tx    transactionInfo
	Error error
}

type SessionTransactionBeginStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
	Session sessionInfo
}

type SessionTransactionCommitDoneInfo struct {
	Error error
}

type SessionTransactionCommitStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
	Session sessionInfo
	Tx      transactionInfo
}

type SessionTransactionRollbackDoneInfo struct {
	Error error
}

type SessionTransactionRollbackStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
	Session sessionInfo
	Tx      transactionInfo
}

type StreamExecuteDoneInfo struct {
	Error error
}

type StreamExecuteIntermediateInfo struct {
	Error error
}

type StreamExecuteStartInfo struct {
	Context    context.Context
	Query      string
	Parameters queryParameters
}

type Table struct {
	// Session events
	OnSessionNew       func(SessionNewStartInfo) func(SessionNewDoneInfo)
	OnSessionDelete    func(SessionDeleteStartInfo) func(SessionDeleteDoneInfo)
	OnSessionKeepAlive func(KeepAliveStartInfo) func(KeepAliveDoneInfo)
	// Query events
	OnSessionQueryPrepare func(PrepareDataQueryStartInfo) func(PrepareDataQueryDoneInfo)
	OnSessionQueryExecute func(ExecuteDataQueryStartInfo) func(ExecuteDataQueryDoneInfo)
	OnSessionQueryExplain func(ExplainQueryStartInfo) func(ExplainQueryDoneInfo)
	// Stream events
	OnSessionQueryStreamExecute func(
		SessionQueryStreamExecuteStartInfo,
	) func(
		SessionQueryStreamExecuteIntermediateInfo,
	) func(
		SessionQueryStreamExecuteDoneInfo,
	)
	OnSessionQueryStreamRead func(
		SessionQueryStreamReadStartInfo,
	) func(
		SessionQueryStreamReadIntermediateInfo,
	) func(
		SessionQueryStreamReadDoneInfo,
	)
	// Transaction events
	OnSessionTransactionBegin    func(SessionTransactionBeginStartInfo) func(SessionTransactionBeginDoneInfo)
	OnSessionTransactionCommit   func(SessionTransactionCommitStartInfo) func(SessionTransactionCommitDoneInfo)
	OnSessionTransactionRollback func(SessionTransactionRollbackStartInfo) func(SessionTransactionRollbackDoneInfo)
	// Pool events
	OnPoolInit  func(PoolInitStartInfo) func(PoolInitDoneInfo)
	OnPoolClose func(PoolCloseStartInfo) func(PoolCloseDoneInfo)
	// Pool state event
	OnPoolStateChange func(PooStateChangeInfo)
	// Pool retry events
	OnPoolDo   func(PoolDoStartInfo) func(info PoolDoIntermediateInfo) func(PoolDoDoneInfo)
	OnPoolDoTx func(PoolDoTxStartInfo) func(info PoolDoTxIntermediateInfo) func(PoolDoTxDoneInfo)
	// Pool session lifecycle events
	OnPoolSessionNew   func(PoolSessionNewStartInfo) func(PoolSessionNewDoneInfo)
	OnPoolSessionClose func(PoolSessionCloseStartInfo) func(PoolSessionCloseDoneInfo)
	// Pool common API events
	OnPoolPut  func(PoolPutStartInfo) func(PoolPutDoneInfo)
	OnPoolGet  func(PoolGetStartInfo) func(PoolGetDoneInfo)
	OnPoolWait func(PoolWaitStartInfo) func(PoolWaitDoneInfo)
}

type WhoAmIDoneInfo struct {
	User   string
	Groups []string
	Error  error
}

type WhoAmIStartInfo struct {
	// Context make available context in trace callback function.
	// Pointer to context provide replacement of context in trace callback function.
	// Warning: concurrent access to pointer on client side must be excluded.
	// Safe replacement of context are provided only inside callback function
	Context *context.Context
}