feat: logger interface added

Author: Pratham-Mishra04

bifrost.go

@@ -8,6 +8,7 @@ import (
 	"math/rand"
 	"os"
 	"os/signal"
+	"slices"
 	"sync"
 	"syscall"
 	"time"
@@ -34,6 +35,7 @@ type Bifrost struct {
 	plugins       []interfaces.Plugin
 	requestQueues map[interfaces.SupportedModelProvider]chan ChannelMessage // provider request queues
 	waitGroups    map[interfaces.SupportedModelProvider]*sync.WaitGroup
+	logger        interfaces.Logger
 }
 
 func createProviderFromProviderKey(providerKey interfaces.SupportedModelProvider, config *interfaces.ProviderConfig) (interfaces.Provider, error) {
@@ -75,7 +77,7 @@ func (bifrost *Bifrost) prepareProvider(providerKey interfaces.SupportedModelPro
 		return fmt.Errorf("failed to get provider for the given key: %v", err)
 	}
 
-	for i := 0; i < providerConfig.ConcurrencyAndBufferSize.Concurrency; i++ {
+	for range providerConfig.ConcurrencyAndBufferSize.Concurrency {
 		bifrost.waitGroups[providerKey].Add(1)
 		go bifrost.processRequests(provider, queue)
 	}
@@ -84,7 +86,7 @@ func (bifrost *Bifrost) prepareProvider(providerKey interfaces.SupportedModelPro
 }
 
 // Initializes infinite listening channels for each provider
-func Init(account interfaces.Account, plugins []interfaces.Plugin) (*Bifrost, error) {
+func Init(account interfaces.Account, plugins []interfaces.Plugin, logger interfaces.Logger) (*Bifrost, error) {
 	bifrost := &Bifrost{account: account, plugins: plugins}
 	bifrost.waitGroups = make(map[interfaces.SupportedModelProvider]*sync.WaitGroup)
 
@@ -107,6 +109,11 @@ func Init(account interfaces.Account, plugins []interfaces.Plugin) (*Bifrost, er
 		}
 	}
 
+	if logger == nil {
+		logger = NewDefaultLogger(interfaces.LogLevelInfo)
+	}
+	bifrost.logger = logger
+
 	return bifrost, nil
 }
 
@@ -123,11 +130,8 @@ func (bifrost *Bifrost) SelectKeyFromProviderForModel(providerKey interfaces.Sup
 	// filter out keys which dont support the model
 	var supportedKeys []interfaces.Key
 	for _, key := range keys {
-		for _, supportedModel := range key.Models {
-			if supportedModel == model {
-				supportedKeys = append(supportedKeys, key)
-				break
-			}
+		if slices.Contains(key.Models, model) {
+			supportedKeys = append(supportedKeys, key)
 		}
 	}
 

interfaces/logger.go

@@ -0,0 +1,26 @@
+package interfaces
+
+// LogLevel represents the severity level of a log message
+type LogLevel string
+
+const (
+	LogLevelDebug LogLevel = "debug"
+	LogLevelInfo  LogLevel = "info"
+	LogLevelWarn  LogLevel = "warn"
+	LogLevelError LogLevel = "error"
+)
+
+// Logger defines the interface for logging operations
+type Logger interface {
+	// Debug logs a debug level message
+	Debug(msg string, err error)
+
+	// Info logs an info level message
+	Info(msg string, err error)
+
+	// Warn logs a warning level message
+	Warn(msg string, err error)
+
+	// Error logs an error level message
+	Error(msg string, err error)
+}

logger.go

@@ -0,0 +1,62 @@
+package bifrost
+
+import (
+	"fmt"
+	"os"
+	"time"
+
+	"bifrost/interfaces"
+)
+
+// DefaultLogger implements the Logger interface with stdout printing
+type DefaultLogger struct {
+	level interfaces.LogLevel
+}
+
+// NewDefaultLogger creates a new DefaultLogger instance
+func NewDefaultLogger(level interfaces.LogLevel) *DefaultLogger {
+	return &DefaultLogger{
+		level: level,
+	}
+}
+
+// formatMessage formats the log message with timestamp and level
+func (logger *DefaultLogger) formatMessage(level interfaces.LogLevel, msg string, err error) string {
+	timestamp := time.Now().Format(time.RFC3339)
+	baseMsg := fmt.Sprintf("[BIFROST-%s] %s: %s", timestamp, level, msg)
+	if err != nil {
+		return fmt.Sprintf("%s (error: %v)", baseMsg, err)
+	}
+	return baseMsg
+}
+
+// Debug logs a debug level message
+func (logger *DefaultLogger) Debug(msg string, err error) {
+	if logger.level == interfaces.LogLevelDebug {
+		fmt.Fprintln(os.Stdout, logger.formatMessage(interfaces.LogLevelDebug, msg, err))
+	}
+}
+
+// Info logs an info level message
+func (logger *DefaultLogger) Info(msg string, err error) {
+	if logger.level == interfaces.LogLevelDebug || logger.level == interfaces.LogLevelInfo {
+		fmt.Fprintln(os.Stdout, logger.formatMessage(interfaces.LogLevelInfo, msg, err))
+	}
+}
+
+// Warn logs a warning level message
+func (logger *DefaultLogger) Warn(msg string, err error) {
+	if logger.level == interfaces.LogLevelDebug || logger.level == interfaces.LogLevelInfo || logger.level == interfaces.LogLevelWarn {
+		fmt.Fprintln(os.Stdout, logger.formatMessage(interfaces.LogLevelWarn, msg, err))
+	}
+}
+
+// Error logs an error level message
+func (logger *DefaultLogger) Error(msg string, err error) {
+	fmt.Fprintln(os.Stderr, logger.formatMessage(interfaces.LogLevelError, msg, err))
+}
+
+// SetLevel sets the logging level
+func (logger *DefaultLogger) SetLevel(level interfaces.LogLevel) {
+	logger.level = level
+}

tests/setup.go

@@ -44,7 +44,7 @@ func getBifrost() (*bifrost.Bifrost, error) {
 		return nil, err
 	}
 
-	bifrost, err := bifrost.Init(&account, []interfaces.Plugin{plugin})
+	bifrost, err := bifrost.Init(&account, []interfaces.Plugin{plugin}, nil)
 	if err != nil {
 		return nil, err
 	}