Mongodb connection retry

Question

Created a MongoDB client which is handling the retry in case of server connection failure. Please review and how I can improve further.

package db
import (
 "context"
 "errors"
 "log"
 "time"
 
 "go.mongodb.org/mongo-driver/event"
 "go.mongodb.org/mongo-driver/mongo"
 "go.mongodb.org/mongo-driver/mongo/options"
)
const SupplyReportDB = "abc"
const SupplyAlertsCollection = "abc"
type MongoDB struct {
 client *mongo.Client
 uri string
}
func NewMongoDBCon(context context.Context, uri string) (*MongoDB, error) {
 var conn = &MongoDB{uri: uri}
 client, err := conn.Connect(context)
 if err != nil {
 return conn, err
 }
 conn.client = client
 return conn, err
}
func (m *MongoDB) Connect(context context.Context) (*mongo.Client, error) {
 serverMonitor := &event.ServerMonitor{
 ServerHeartbeatFailed: m.serverHandler, 
 }
 client, err := mongo.Connect(
 context, options.Client().
 ApplyURI(m.uri).
 SetHeartbeatInterval(5*time.Second).
 SetServerMonitor(serverMonitor),
 )
 if err != nil {
 return client, err
 }
 if err := client.Ping(context, nil); err != nil {
 return client, errors.New("not connected")
 }
 return client, nil
}
func (m *MongoDB) Close(context context.Context) error {
 if err := m.client.Disconnect(context); err != nil {
 return err
 }
 return nil
}
func (m *MongoDB) GetSupplyAlertCollection() *mongo.Collection {
 collection := m.client.Database(SupplyReportDB).Collection(SupplyAlertsCollection)
 return collection
}
func (m *MongoDB) reconnect() {
 count := 1
 for {
 if count == 3{
 log.Fatal("Problem in connecting MongoDB.. exiting..")
 }
 log.Println("Retrying for the ", count, "time")
 client, err := m.Connect(context.TODO())
 if err != nil {
 time.Sleep(4 * time.Second)
 } else {
 log.Println("Reconnected successfully.")
 m.client = client
 break
 }
 count++
 }
}
func (m *MongoDB)serverHandler(evt *event.ServerHeartbeatFailedEvent) {
 m.reconnect() 
}

Answer 1

I would think about replacing the "for loop" with a retry package https://github.com/avast/retry-go. Should be a little bit cleaner.

func (m *MongoDB) reconnect() {
err := retry.Do(func() error {
 client, err := mongo.Connect(context.TODO(), m.uri, mongo.ConnectTimeout(5*time.Second))
 if err != nil {
 log.Printf("Failed to connect to MongoDB at %s: %s", m.uri, err)
 return err
 }
 log.Println("Reconnected successfully.")
 m.client = client
 return nil
},
 retry.Attempts(3),
 retry.Delay(4*time.Second),
 retry.OnRetry(func(n uint, err error) {
 log.Printf("Retry %d: %s", n, err)
 }),
)
if err != nil {
 log.Fatal("Problem in connecting MongoDB.. exiting..")
}}

Also using exponential backoff (in the delay) could be an option.