Package event

var commandStarted []string
cmdMonitor := &event.CommandMonitor{
  Started: func(_ context.Context, evt *event.CommandStartedEvent) {
    commandStarted = append(commandStarted, evt.CommandName)
  },
}
clientOpts := options.Client().ApplyURI("mongodb://localhost:27017").SetMonitor(cmdMonitor)
client, err := mongo.Connect(context.Background(), clientOpts)

var int connsCheckedOut
poolMonitor := &event.PoolMonitor{
  Event: func(evt *event.PoolEvent) {
    switch evt.Type {
    case event.GetSucceeded:
      connsCheckedOut++
    case event.ConnectionReturned:
      connsCheckedOut--
    }
  },
}
clientOpts := options.Client().ApplyURI("mongodb://localhost:27017").SetPoolMonitor(poolMonitor)
client, err := mongo.Connect(context.Background(), clientOpts)

   var heartbeatStarted []*event.ServerHeartbeatStartedEvent
   svrMonitor := &event.ServerMonitor{
     ServerHeartbeatStarted: func(e *event.ServerHeartbeatStartedEvent) {
	      heartbeatStarted = append(heartbeatStarted, e)
     }
   }
   clientOpts := options.Client().ApplyURI("mongodb://localhost:27017").SetServerMonitor(svrMonitor)
   client, err := mongo.Connect(context.Background(), clientOpts)

Constants

strings for pool command monitoring reasons

const (
    ReasonIdle              = "idle"
    ReasonPoolClosed        = "poolClosed"
    ReasonStale             = "stale"
    ReasonConnectionErrored = "connectionError"
    ReasonTimedOut          = "timeout"
    ReasonError             = "error"
)

strings for pool command monitoring types

const (
    PoolCreated        = "ConnectionPoolCreated"
    PoolReady          = "ConnectionPoolReady"
    PoolCleared        = "ConnectionPoolCleared"
    PoolClosedEvent    = "ConnectionPoolClosed"
    ConnectionCreated  = "ConnectionCreated"
    ConnectionReady    = "ConnectionReady"
    ConnectionClosed   = "ConnectionClosed"
    GetStarted         = "ConnectionCheckOutStarted"
    GetFailed          = "ConnectionCheckOutFailed"
    GetSucceeded       = "ConnectionCheckedOut"
    ConnectionReturned = "ConnectionCheckedIn"
)

type CommandFailedEvent ¶

CommandFailedEvent represents an event generated when a command's execution fails.

type CommandFailedEvent struct {
    CommandFinishedEvent
    Failure string
}

type CommandFinishedEvent ¶

CommandFinishedEvent represents a generic command finishing.

type CommandFinishedEvent struct {
    // Deprecated: Use Duration instead.
    DurationNanos int64
    Duration      time.Duration
    CommandName   string
    DatabaseName  string
    RequestID     int64
    ConnectionID  string
    // ServerConnectionID 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.If the server connection ID would cause an int32 overflow, then
    // this field will be nil.
    //
    // Deprecated: Use ServerConnectionID64.
    ServerConnectionID *int32
    // 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.
    ServerConnectionID64 *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 *primitive.ObjectID
}

type CommandMonitor ¶

CommandMonitor represents a monitor that is triggered for different events.

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

// If the application makes multiple concurrent requests, it would have to
// use a concurrent map like sync.Map
startedCommands := make(map[int64]bson.Raw)
cmdMonitor := &event.CommandMonitor{
    Started: func(_ context.Context, evt *event.CommandStartedEvent) {
        startedCommands[evt.RequestID] = evt.Command
    },
    Succeeded: func(_ context.Context, evt *event.CommandSucceededEvent) {
        log.Printf("Command: %v Reply: %v\n",
            startedCommands[evt.RequestID],
            evt.Reply,
        )

        // Empty "startedCommands" for the request ID to avoid a memory leak.
        delete(startedCommands, evt.RequestID)
    },
    Failed: func(_ context.Context, evt *event.CommandFailedEvent) {
        log.Printf("Command: %v Failure: %v\n",
            startedCommands[evt.RequestID],
            evt.Failure,
        )

        // Empty "startedCommands" for the request ID to avoid a memory leak.
        delete(startedCommands, evt.RequestID)
    },
}
clientOpts := options.Client().ApplyURI("mongodb://localhost:27017").SetMonitor(cmdMonitor)
client, err := mongo.Connect(context.Background(), clientOpts)
if err != nil {
    log.Fatal(err)
}
defer func() {
    if err = client.Disconnect(context.TODO()); err != nil {
        log.Fatal(err)
    }
}()

type CommandStartedEvent ¶

CommandStartedEvent represents an event generated when a command is sent to a server.

type CommandStartedEvent struct {
    Command      bson.Raw
    DatabaseName string
    CommandName  string
    RequestID    int64
    ConnectionID string
    // ServerConnectionID 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. If the server connection ID would cause an int32 overflow, then
    // then this field will be nil.
    //
    // Deprecated: Use ServerConnectionID64.
    ServerConnectionID *int32
    // 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.
    ServerConnectionID64 *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 *primitive.ObjectID
}

type CommandSucceededEvent ¶

CommandSucceededEvent represents an event generated when a command's execution succeeds.

type CommandSucceededEvent struct {
    CommandFinishedEvent
    Reply bson.Raw
}

type MonitorPoolOptions ¶

MonitorPoolOptions contains pool options as formatted in pool events

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

type PoolEvent ¶

PoolEvent contains all information summarizing a pool event

type PoolEvent struct {
    Type         string              `json:"type"`
    Address      string              `json:"address"`
    ConnectionID uint64              `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    *primitive.ObjectID `json:"serviceId"`
    Interruption bool                `json:"interruptInUseConnections"`
    Error        error               `json:"error"`
}

type PoolMonitor ¶

PoolMonitor is a function that allows the user to gain access to events occurring in the pool

type PoolMonitor struct {
    Event func(*PoolEvent)
}

type ServerClosedEvent ¶

ServerClosedEvent is an event generated when the server is closed.

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

type ServerDescriptionChangedEvent ¶

ServerDescriptionChangedEvent represents a server description change.

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

type ServerHeartbeatFailedEvent ¶

ServerHeartbeatFailedEvent is an event generated when the heartbeat fails.

type ServerHeartbeatFailedEvent struct {
    // Deprecated: Use Duration instead.
    DurationNanos int64
    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 ¶

ServerHeartbeatStartedEvent is an event generated when the heartbeat is started.

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 ¶

ServerHeartbeatSucceededEvent is an event generated when the heartbeat succeeds.

type ServerHeartbeatSucceededEvent struct {
    // Deprecated: Use Duration instead.
    DurationNanos int64
    Duration      time.Duration
    Reply         description.Server
    ConnectionID  string // The address this heartbeat was sent to with a unique identifier
    Awaited       bool   // If this heartbeat was awaitable
}

type ServerMonitor ¶

ServerMonitor represents a monitor that is triggered for different server events. The client will monitor changes on the MongoDB deployment it is connected to, and this monitor reports the changes in the client's representation of the deployment. The topology represents the overall deployment, and heartbeats are sent to individual servers to check their current status.

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 ¶

ServerOpeningEvent is an event generated when the server is initialized.

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

type TopologyClosedEvent ¶

TopologyClosedEvent is an event generated when the topology is closed.

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

type TopologyDescriptionChangedEvent ¶

TopologyDescriptionChangedEvent represents a topology description change.

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

type TopologyOpeningEvent ¶

TopologyOpeningEvent is an event generated when the topology is initialized.

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