github.com/mundipagg/boleto-api@v0.0.0-20230620145841-3f9ec742599f/log/log.go

package log

import (
	"fmt"
	"strings"
	"time"

	"github.com/mralves/tracer"

	"github.com/mundipagg/boleto-api/config"
)

const (
	FailGetBoletoMessage    = "Falha ao recuperar Boleto"
	SuccessGetBoletoMessage = "Boleto recuperado com sucesso"
)

type LogEntry = map[string]interface{}

var logger tracer.Logger

//Operation a operacao usada na API
var Operation string

//Recipient o nome do banco
var Recipient string

//Log struct com os elementos do log
type Log struct {
	Operation      string
	Recipient      string
	PayeeGuarantor string
	RequestKey     string
	BankName       string
	IPAddress      string
	ServiceUser    string
	NossoNumero    string
	logger         tracer.Logger
}

//Install instala o "servico" de log do SEQ
func Install() {
	configureTracer()
	logger = tracer.GetLogger("boleto")
}

func formatter(message string) string {
	return "[{Application}: {Operation}] - {MessageType} " + message
}

//CreateLog cria uma nova instancia do Log
func CreateLog() *Log {
	return &Log{
		logger: logger,
	}
}

//Request loga o request para algum banco
func (l *Log) Request(content interface{}, url string, headers map[string]string) {
	if config.Get().DisableLog {
		return
	}

	go (func() {
		props := l.defaultProperties("Request", content)
		props["URL"] = url

		if config.Get().MockMode {
			props["Headers"] = headers
		} else {
			props["Headers"] = l.maskSecretHeaders(headers)
		}

		action := strings.Split(url, "/")
		msg := formatter(fmt.Sprintf("to {BankName} (%s) | {Recipient}", action[len(action)-1]))

		l.logger.Info(msg, props)
	})()
}

//Response loga o response para algum banco
func (l *Log) Response(content interface{}, url string, headers map[string]string) {
	if config.Get().DisableLog {
		return
	}
	go (func() {

		action := strings.Split(url, "/")
		msg := formatter(fmt.Sprintf("from {BankName} (%s) | {Recipient}", action[len(action)-1]))

		props := l.defaultProperties("Response", content)
		props["URL"] = url

		if config.Get().MockMode {
			props["Headers"] = headers
		} else {
			props["Headers"] = l.maskSecretHeaders(headers)
		}

		l.logger.Info(msg, props)
	})()
}

//RequestApplication loga o request que chega na boleto api
func (l *Log) RequestApplication(content interface{}, url string, headers map[string]string) {
	if config.Get().DisableLog {
		return
	}
	go (func() {

		props := l.defaultProperties("Request", content)
		props["Headers"] = headers
		props["URL"] = url

		msg := formatter("from {IPAddress} | {Recipient}")

		l.logger.Info(msg, props)
	})()
}

//ResponseApplication loga o response que sai da boleto api
func (l *Log) ResponseApplication(content interface{}, url string, errorCode string) {
	if config.Get().DisableLog {
		return
	}
	go (func() {
		props := l.defaultProperties("Response", content)
		props["URL"] = url

		if errorCode != "" {
			props["ErrorCode"] = errorCode
		}

		msg := formatter("{Operation} | {Recipient}")

		l.logger.Info(msg, props)
	})()
}

//ResponseApplicationFatal loga o response que sai do panic recovery
func (l *Log) ResponseApplicationFatal(content interface{}, url string, errorCode string) {
	if config.Get().DisableLog {
		return
	}
	go (func() {
		props := l.defaultProperties("Response", content)
		props["URL"] = url

		if errorCode != "" {
			props["ErrorCode"] = errorCode
		}

		msg := formatter("{Operation} | {Recipient}")

		l.logger.Fatal(msg, props)
	})()
}

//Info loga mensagem do level INFO
func (l *Log) Info(msg string) {
	if config.Get().DisableLog {
		return
	}
	go l.logger.Info(msg, nil)
}

// InfoWithParams cria log generico para um map
func (l *Log) InfoWithParams(msg, msgType string, params map[string]interface{}) {
	if config.Get().DisableLog {
		return
	}
	go (func() {
		props := l.defaultProperties(msgType, "")
		for k, v := range params {
			props[k] = v
		}
		l.logger.Info(formatter(msg), props)
	})()
}

// InfoWithBasic  Cria um log de information com as informações básicas do log
func (l *Log) InfoWithBasic(msg, msgType string, params map[string]interface{}) {
	if config.Get().DisableLog {
		return
	}
	go (func() {
		props := l.basicProperties(msgType)
		for k, v := range params {
			props[k] = v
		}
		l.logger.Info(formatter(msg), props)
	})()
}

//Warn loga mensagem do leve Warning
func (l *Log) Warn(content interface{}, msg string) {
	if config.Get().DisableLog {
		return
	}
	go (func() {
		props := l.defaultProperties("Warning", content)
		m := formatter(msg)

		l.logger.Warn(m, props)
	})()
}

func (l *Log) Error(content interface{}, msg string) {
	if config.Get().DisableLog {
		return
	}
	go (func() {
		props := l.defaultProperties("Error", content)
		m := formatter(msg)

		l.logger.Error(m, props)
	})()
}

// ErrorWithBasic Cria um log de erro com as informações básicas do log
func (l *Log) ErrorWithBasic(msg, msgType string, err error) {
	if config.Get().DisableLog {
		return
	}
	go (func() {
		props := l.basicProperties(msgType)
		props["Error"] = fmt.Sprintf("%v", err)
		l.logger.Error(formatter(msg), props)
	})()
}

// FallbackErrorWithBasic Cria um log de erro com as informações básicas do log de fallback
func (l *Log) ErrorWithContent(msg, msgType string, err error, content interface{}) {
	if config.Get().DisableLog {
		return
	}
	go (func() {
		props := l.defaultProperties(msgType, content)
		props["Error"] = fmt.Sprintf("%v", err)
		l.logger.Error(formatter(msg), props)
	})()
}

// Fatal loga erros da aplicação
func (l *Log) Fatal(content interface{}, msg string) {
	if config.Get().DisableLog {
		return
	}
	go (func() {
		props := l.defaultProperties("Fatal", content)
		m := formatter(msg)

		l.logger.Fatal(m, props)
	})()
}

// ErrorBasicWithContent Cria um log de erro com as informações básicas e o conteúdo
func (l *Log) ErrorBasicWithContent(msg, msgType string, content interface{}) {
	if config.Get().DisableLog {
		return
	}
	go (func() {
		props := l.basicProperties(msgType)
		props["Content"] = content
		l.logger.Error(formatter(msg), props)
	})()
}

//InitRobot loga o inicio da execução do robô de recovery
func (l *Log) InitRobot(totalRecords int) {
	msg := formatter("- Starting execution")
	go func() {
		props := defaultRobotProperties("Execute", l.Operation, "")
		props["TotalRecords"] = totalRecords
		logger.Info(msg, props)
	}()
}

//ResumeRobot loga um resumo de Recovery do robô de recovery
func (l *Log) ResumeRobot(key string) {
	msg := formatter(key)
	go func() {
		props := defaultRobotProperties("RecoveryBoleto", l.Operation, key)
		props["RequestKey"] = l.RequestKey
		logger.Info(msg, props)
	}()
}

//EndRobot loga o fim da execução do robô de recovery
func (l *Log) EndRobot() {
	msg := formatter("- Finishing execution")
	go logger.Info(msg, defaultRobotProperties("Finish", l.Operation, ""))
}

func (l *Log) defaultProperties(messageType string, content interface{}) LogEntry {
	props := LogEntry{
		"Content":     content,
		"Recipient":   l.Recipient,
		"NossoNumero": l.NossoNumero,
		"RequestKey":  l.RequestKey,
		"BankName":    l.BankName,
		"ServiceUser": l.ServiceUser,
		"IPAddress":   l.IPAddress,
	}

	if len(l.PayeeGuarantor) > 0 {
		props["PayeeGuarantor"] = l.PayeeGuarantor
	}

	for k, v := range l.basicProperties(messageType) {
		props[k] = v
	}

	return props
}

//GetBoleto Loga mensagem de recuperação de boleto
func (l *Log) GetBoleto(content interface{}, msgType string) {
	if config.Get().DisableLog {
		return
	}
	go (func() {
		props := l.getBoletoProperties(msgType, content)

		switch msgType {
		case "Warning":
			l.logger.Warn(formatter(FailGetBoletoMessage), props)
		case "Error":
			l.logger.Error(formatter(FailGetBoletoMessage), props)
		default:
			l.logger.Info(formatter(SuccessGetBoletoMessage), props)
		}
	})()
}

//handleMaskErros Handle de erro para funções internas para garantir que, caso ocorra algum problema interno
//o conteúdo continuará sendo enviado, porém sem a devida máscara.

func (l *Log) HandleMaskErrors(method string, messageType string, methodContent interface{}) {
	if r := recover(); r != nil {
		errorDescription := fmt.Sprintf("Recovering from panic during %s operation", method)
		logMessage := fmt.Sprintf("to {BankName} (%s) | {Recipient} - %s", messageType, errorDescription)
		recoverError := fmt.Errorf("%v", r)

		l.ErrorWithContent(logMessage, messageType, recoverError, methodContent)
	}
}

func (l *Log) basicProperties(messageType string) LogEntry {
	loc, _ := time.LoadLocation("UTC")
	now := time.Now().In(loc)

	props := LogEntry{
		"MessageType":   messageType,
		"Operation":     l.Operation,
		"ExecutionDate": now,
	}
	return props
}

func (l *Log) getBoletoProperties(messageType string, content interface{}) LogEntry {
	props := LogEntry{
		"RequestKey": l.RequestKey,
		"IPAddress":  l.IPAddress,
		"Content":    content,
	}

	for k, v := range l.basicProperties(messageType) {
		props[k] = v
	}

	return props
}

func defaultRobotProperties(msgType, op, key string) LogEntry {
	props := LogEntry{
		"MessageType": msgType,
		"Operation":   op,
	}

	if key != "" {
		props["BoletoKey"] = key
	}
	return props
}

func (l *Log) maskSecretHeaders(headers map[string]string) map[string]string {
	secretHeaders := map[string]bool{
		"Authorization": true,
		"access_token":  true,
		"itau-chave":    true,
	}

	maskedHeaders := make(map[string]string)

	for key, value := range headers {
		if secretHeaders[key] {
			maskedHeaders[key] = "[REDACTED]"
		} else {
			maskedHeaders[key] = value
		}
	}

	return maskedHeaders
}