event

type CommandFailedEvent struct {
	CommandFinishedEvent
	Failure error
}

type CommandFinishedEvent struct {
	Duration     time.Duration
	CommandName  string
	DatabaseName string
	RequestID    int64
	ConnectionID string
	// ServerConnectionID64 contains the connection ID from the server of the operation. If the server does not
	// return this value (e.g. on MDB < 4.2), it is unset.
	ServerConnectionID *int64
	// ServiceID contains the ID of the server to which the command was sent if it is running behind a load balancer.
	// Otherwise, it is unset.
	ServiceID *bson.ObjectID
}

type CommandMonitor struct {
	Started   func(context.Context, *CommandStartedEvent)
	Succeeded func(context.Context, *CommandSucceededEvent)
	Failed    func(context.Context, *CommandFailedEvent)
}

type CommandStartedEvent struct {
	Command      bson.Raw
	DatabaseName string
	CommandName  string
	RequestID    int64
	ConnectionID string
	// ServerConnectionID64 contains the connection ID from the server of the operation. If the server does not
	// return this value (e.g. on MDB < 4.2), it is unset.
	ServerConnectionID *int64
	// ServiceID contains the ID of the server to which the command was sent if it is running behind a load balancer.
	// Otherwise, it is unset.
	ServiceID *bson.ObjectID
}

type CommandSucceededEvent struct {
	CommandFinishedEvent
	Reply bson.Raw
}

type MonitorPoolOptions struct {
	MaxPoolSize        uint64 `json:"maxPoolSize"`
	MinPoolSize        uint64 `json:"minPoolSize"`
	WaitQueueTimeoutMS uint64 `json:"maxIdleTimeMS"`
}

type PoolEvent struct {
	Type         string              `json:"type"`
	Address      string              `json:"address"`
	ConnectionID int64               `json:"connectionId"`
	PoolOptions  *MonitorPoolOptions `json:"options"`
	Duration     time.Duration       `json:"duration"`
	Reason       string              `json:"reason"`
	// ServiceID is only set if the Type is PoolCleared and the server is deployed behind a load balancer. This field
	// can be used to distinguish between individual servers in a load balanced deployment.
	ServiceID    *bson.ObjectID `json:"serviceId"`
	Interruption bool           `json:"interruptInUseConnections"`
	Error        error          `json:"error"`
}

type PoolMonitor struct {
	Event func(*PoolEvent)
}

type ServerClosedEvent struct {
	Address    address.Address
	TopologyID bson.ObjectID // A unique identifier for the topology this server is a part of
}

type ServerDescription struct {
	Addr                     address.Address
	Arbiters                 []string
	Compression              []string // compression methods returned by server
	CanonicalAddr            address.Address
	ElectionID               bson.ObjectID
	IsCryptd                 bool
	HelloOK                  bool
	Hosts                    []string
	Kind                     string
	LastWriteTime            time.Time
	MaxBatchCount            uint32
	MaxDocumentSize          uint32
	MaxMessageSize           uint32
	MaxWireVersion           int32
	MinWireVersion           int32
	Members                  []address.Address
	Passives                 []string
	Passive                  bool
	Primary                  address.Address
	ReadOnly                 bool
	ServiceID                *bson.ObjectID // Only set for servers that are deployed behind a load balancer.
	SessionTimeoutMinutes    *int64
	SetName                  string
	SetVersion               uint32
	Tags                     tag.Set
	TopologyVersionProcessID bson.ObjectID
	TopologyVersionCounter   int64
}

type ServerDescriptionChangedEvent struct {
	Address             address.Address
	TopologyID          bson.ObjectID // A unique identifier for the topology this server is a part of
	PreviousDescription ServerDescription
	NewDescription      ServerDescription
}

type ServerHeartbeatFailedEvent struct {
	Duration     time.Duration
	Failure      error
	ConnectionID string // The address this heartbeat was sent to with a unique identifier
	Awaited      bool   // If this heartbeat was awaitable
}

type ServerHeartbeatStartedEvent struct {
	ConnectionID string // The address this heartbeat was sent to with a unique identifier
	Awaited      bool   // If this heartbeat was awaitable
}

type ServerHeartbeatSucceededEvent struct {
	Duration     time.Duration
	Reply        ServerDescription
	ConnectionID string // The address this heartbeat was sent to with a unique identifier
	Awaited      bool   // If this heartbeat was awaitable
}

type ServerMonitor struct {
	ServerDescriptionChanged func(*ServerDescriptionChangedEvent)
	ServerOpening            func(*ServerOpeningEvent)
	ServerClosed             func(*ServerClosedEvent)
	// TopologyDescriptionChanged is called when the topology is locked, so the callback should
	// not attempt any operation that requires server selection on the same client.
	TopologyDescriptionChanged func(*TopologyDescriptionChangedEvent)
	TopologyOpening            func(*TopologyOpeningEvent)
	TopologyClosed             func(*TopologyClosedEvent)
	ServerHeartbeatStarted     func(*ServerHeartbeatStartedEvent)
	ServerHeartbeatSucceeded   func(*ServerHeartbeatSucceededEvent)
	ServerHeartbeatFailed      func(*ServerHeartbeatFailedEvent)
}

type ServerOpeningEvent struct {
	Address    address.Address
	TopologyID bson.ObjectID // A unique identifier for the topology this server is a part of
}

type TopologyClosedEvent struct {
	TopologyID bson.ObjectID // A unique identifier for the topology this server is a part of
}

type TopologyDescription struct {
	Servers               []ServerDescription
	SetName               string
	Kind                  string
	SessionTimeoutMinutes *int64
	CompatibilityErr      error
}

type TopologyDescriptionChangedEvent struct {
	TopologyID          bson.ObjectID // A unique identifier for the topology this server is a part of
	PreviousDescription TopologyDescription
	NewDescription      TopologyDescription
}

type TopologyOpeningEvent struct {
	TopologyID bson.ObjectID // A unique identifier for the topology this server is a part of
}