Merge pull request #16 from deploymenttheory/dev

Dev

Author: ShocOne

httpclient/httpclient_client.go

@@ -59,6 +59,7 @@ type AuthConfig struct {
 // ClientOptions holds optional configuration options for the HTTP Client.
 type ClientOptions struct {
 	LogLevel                  string // Field for defining tiered logging level.
+	LogOutputFormat           string // Field for defining the output format of the logs. Use "LogOutputJSON" for JSON format, "LogOutputHumanReadable" for human-readable format
 	HideSensitiveData         bool   // Field for defining whether sensitive fields should be hidden in logs.
 	MaxRetryAttempts          int    // Config item defines the max number of retry request attempts for retryable HTTP methods.
 	EnableDynamicRateLimiting bool   // Field for defining whether dynamic rate limiting should be enabled.
@@ -84,8 +85,8 @@ func BuildClient(config ClientConfig) (*Client, error) {
 	// Parse the log level string to logger.LogLevel
 	parsedLogLevel := logger.ParseLogLevelFromString(config.ClientOptions.LogLevel)
 
-	// Initialize the logger with the parsed log level
-	log := logger.BuildLogger(parsedLogLevel)
+	// Initialize the logger with the parsed log level and log output format
+	log := logger.BuildLogger(parsedLogLevel, config.ClientOptions.LogOutputFormat)
 
 	// Set the logger's level (optional if BuildLogger already sets the level based on the input)
 	log.SetLevel(parsedLogLevel)
@@ -165,6 +166,7 @@ func BuildClient(config ClientConfig) (*Client, error) {
 		zap.String("Override Base Domain", config.Environment.OverrideBaseDomain),
 		zap.String("Authentication Method", authMethod),
 		zap.String("Logging Level", config.ClientOptions.LogLevel),
+		zap.String("Log Output Format", config.ClientOptions.LogOutputFormat),
 		zap.Bool("Hide Sensitive Data In Logs", config.ClientOptions.HideSensitiveData),
 		zap.Int("Max Retry Attempts", config.ClientOptions.MaxRetryAttempts),
 		zap.Int("Max Concurrent Requests", config.ClientOptions.MaxConcurrentRequests),

httpclient/httpclient_helpers.go

@@ -31,8 +31,8 @@ func RedactSensitiveData(client *Client, key string, value string) string {
 	if client.clientConfig.ClientOptions.HideSensitiveData {
 		// Define sensitive data keys that should be redacted.
 		sensitiveKeys := map[string]bool{
-			"AccessToken": true,
-			// Add more sensitive keys as necessary.
+			"AccessToken":   true,
+			"Authorization": true,
 		}
 
 		if _, found := sensitiveKeys[key]; found {
@@ -41,74 +41,3 @@ func RedactSensitiveData(client *Client, key string, value string) string {
 	}
 	return value
 }
-
-/*
-// EnsureHTTPScheme prefixes a URL with "http://" it defaults to "https://" doesn't already have an "https://".
-func EnsureHTTPScheme(url string) string {
-	if !strings.HasPrefix(url, "http://") && !strings.HasPrefix(url, "https://") {
-		return fmt.Sprintf("https://%s", url)
-	}
-	return url
-}
-*/
-
-/*
-// SetAuthenticationCredentials interprets and sets the credentials for the Client.
-func (c *Client) SetAuthenticationCredentials(creds map[string]string) {
-	// Check for OAuth credentials
-	if clientID, ok := creds["clientID"]; ok {
-		if clientSecret, ok := creds["clientSecret"]; ok {
-			c.OAuthCredentials = OAuthCredentials{
-				ClientID:     clientID,
-				ClientSecret: clientSecret,
-			}
-			c.AuthMethod = "oauth"
-			return
-		}
-	}
-
-	// Check for Bearer Token credentials
-	if username, ok := creds["username"]; ok {
-		if password, ok := creds["password"]; ok {
-			c.BearerTokenAuthCredentials = BearerTokenAuthCredentials{
-				Username: username,
-				Password: password,
-			}
-			c.AuthMethod = "bearer"
-			return
-		}
-	}
-}
-
-// GetOAuthCredentials retrieves the current OAuth credentials (Client ID and Client Secret)
-// set for the client instance. Used for test cases.
-func (c *Client) GetOAuthCredentials() OAuthCredentials {
-	return c.OAuthCredentials
-}
-
-// GetBearerAuthCredentials retrieves the current bearer auth credentials (Username and Password)
-// set for the client instance. Used for test cases.
-func (c *Client) GetBearerAuthCredentials() BearerTokenAuthCredentials {
-	return c.BearerTokenAuthCredentials
-}
-*/
-/*
-// LoadAuthConfig reads a JSON configuration file and decodes it into a ClientAuthConfig struct.
-// It is used to retrieve authentication details like BaseURL, Username, and Password for the client.
-func LoadAuthConfig(filename string) (*AuthConfig, error) {
-	file, err := os.Open(filename)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-
-	config := &AuthConfig{}
-	decoder := json.NewDecoder(file)
-	err = decoder.Decode(config)
-	if err != nil {
-		return nil, err
-	}
-
-	return config, nil
-}
-*/

httpclient/httpclient_request.go

@@ -112,14 +112,19 @@ func (c *Client) DoRequest(method, endpoint string, body, out interface{}, log l
 		"*/*;q=0.05"
 
 	// Set Headers
-	req.Header.Add("Authorization", "Bearer "+c.Token)
+	req.Header.Add("Authorization", c.Token)
 	req.Header.Add("Content-Type", contentType)
 	req.Header.Add("Accept", acceptHeader)
 	req.Header.Set("User-Agent", GetUserAgentHeader())
 
-	// Debug: Print request headers if in debug mode
-	headersStr := HeadersToString(req.Header)
-	log.Debug("HTTP Multipart Request Headers:", zap.String("headers", headersStr))
+	// Debug: Print request headers
+	redactedAuthorization := RedactSensitiveData(c, "Authorization", req.Header.Get("Authorization"))
+	c.Logger.Debug("HTTP Request Headers",
+		zap.String("Authorization", redactedAuthorization),
+		zap.String("Content-Type", req.Header.Get("Content-Type")),
+		zap.String("Accept", req.Header.Get("Accept")),
+		zap.String("User-Agent", req.Header.Get("User-Agent")),
+	)
 
 	// Define if request is retryable
 	retryableHTTPMethods := map[string]bool{
@@ -383,9 +388,14 @@ func (c *Client) DoMultipartRequest(method, endpoint string, fields map[string]s
 	req.Header.Set("Content-Type", contentType)
 	req.Header.Set("User-Agent", GetUserAgentHeader())
 
-	// Debug: Print request headers if in debug mode
-	headersStr := HeadersToString(req.Header)
-	log.Debug("HTTP Multipart Request Headers:", zap.String("headers", headersStr))
+	// Debug: Print request headers
+	redactedAuthorization := RedactSensitiveData(c, "Authorization", req.Header.Get("Authorization"))
+	c.Logger.Debug("HTTP Request Headers",
+		zap.String("Authorization", redactedAuthorization),
+		zap.String("Content-Type", req.Header.Get("Content-Type")),
+		zap.String("Accept", req.Header.Get("Accept")),
+		zap.String("User-Agent", req.Header.Get("User-Agent")),
+	)
 
 	// Execute the request
 	resp, err := c.httpClient.Do(req)

logger/format.go

@@ -0,0 +1,87 @@
+// logger.go
+package logger
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"reflect"
+)
+
+// LogEntry represents the structure of a log entry.
+type LogEntry struct {
+	Level      string                 `json:"level"`
+	Timestamp  string                 `json:"timestamp"`
+	Message    string                 `json:"msg"`
+	Additional map[string]interface{} `json:"-"`
+}
+
+// UnmarshalJSONLog customizes the unmarshalling of LogEntry to handle arbitrary key-value pairs.
+func (le *LogEntry) UnmarshalJSONLog(data []byte) error {
+	// Unmarshal fixed fields first
+	type Alias LogEntry
+	aux := &struct {
+		*Alias
+	}{
+		Alias: (*Alias)(le),
+	}
+	if err := json.Unmarshal(data, &aux); err != nil {
+		return err
+	}
+
+	// Unmarshal additional fields into a map
+	var additionalFields map[string]interface{}
+	if err := json.Unmarshal(data, &additionalFields); err != nil {
+		return err
+	}
+
+	// Remove fixed fields from the map
+	delete(additionalFields, "level")
+	delete(additionalFields, "timestamp")
+	delete(additionalFields, "msg")
+
+	le.Additional = additionalFields
+	return nil
+}
+
+// ProcessLogs parses and outputs the log entries in a human-readable form.
+func ProcessLogs(logEntries []string) {
+	for _, logEntryStr := range logEntries {
+		var logEntry LogEntry
+		if err := json.Unmarshal([]byte(logEntryStr), &logEntry); err != nil {
+			log.Printf("Failed to parse log entry: %v", err)
+			continue
+		}
+
+		fmt.Printf("[%s] %s: %s\n", logEntry.Timestamp, logEntry.Level, logEntry.Message)
+		for key, value := range logEntry.Additional {
+			valueStr := formatValue(value)
+			fmt.Printf("  %s: %s\n", key, valueStr)
+		}
+		fmt.Println()
+	}
+}
+
+// formatValue returns a string representation of the value, considering its type.
+func formatValue(value interface{}) string {
+	if value == nil {
+		return "null"
+	}
+	val := reflect.ValueOf(value)
+	switch val.Kind() {
+	case reflect.String:
+		return fmt.Sprintf("%q", value)
+	case reflect.Int, reflect.Int64, reflect.Float64:
+		return fmt.Sprintf("%v", value)
+	case reflect.Bool:
+		return fmt.Sprintf("%t", value)
+	case reflect.Map, reflect.Slice, reflect.Array:
+		bytes, err := json.Marshal(value)
+		if err != nil {
+			return "error"
+		}
+		return string(bytes)
+	default:
+		return fmt.Sprintf("%v", value)
+	}
+}

logger/loggerconfig.go

@@ -4,14 +4,21 @@ package logger
 // Ref: https://betterstack.com/community/guides/logging/go/zap/#logging-errors-with-zap
 
 import (
+	"fmt"
+
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
 )
 
+const (
+	LogOutputJSON          = "json"
+	LogOutputHumanReadable = "human-readable"
+)
+
 // BuildLogger creates and returns a new zap logger instance.
 // It configures the logger with JSON formatting and a custom encoder to ensure the 'pid', 'application', and 'timestamp' fields
 // appear at the end of each log message. The function panics if the logger cannot be initialized.
-func BuildLogger(logLevel LogLevel) Logger {
+func BuildLogger(logLevel LogLevel, logOutputFormat string) Logger {
 
 	// Set up custom encoder configuration
 	encoderCfg := zap.NewProductionEncoderConfig()
@@ -21,6 +28,11 @@ func BuildLogger(logLevel LogLevel) Logger {
 	// Convert the custom LogLevel to zap's logging level
 	zapLogLevel := convertToZapLevel(logLevel)
 
+	// Select the appropriate encoder based on the logOutputFormat
+	if logOutputFormat == LogOutputHumanReadable {
+		encoderCfg.EncodeLevel = zapcore.CapitalColorLevelEncoder // For human-readable output, use colored level encoder
+	}
+
 	// Define the logger configuration
 	config := zap.Config{
 		Level:             zap.NewAtomicLevelAt(zapLogLevel), // Default log level is Info
@@ -41,9 +53,20 @@ func BuildLogger(logLevel LogLevel) Logger {
 			//"application": version.GetAppName(),
 		},
 	}
+	/*
+		// Build the logger from the configuration
+		logger := zap.Must(config.Build())
+	*/
+	// Override Encoding for human-readable format
+	if logOutputFormat == LogOutputHumanReadable {
+		config.Encoding = "console"
+	}
 
 	// Build the logger from the configuration
-	logger := zap.Must(config.Build())
+	logger, err := config.Build()
+	if err != nil {
+		panic(fmt.Sprintf("Failed to build logger: %v", err))
+	}
 
 	// Wrap the original core with the custom core
 	wrappedCore := &customCore{logger.Core()}