github.com/smartcontractkit/chainlink-testing-framework/libs@v0.0.0-20240227141906-ec710b4eb1a3/logging/log.go

package logging

import (
	"fmt"
	"os"
	"strings"
	"testing"
	"time"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
	"github.com/stretchr/testify/require"
	tc "github.com/testcontainers/testcontainers-go"

	"github.com/smartcontractkit/chainlink-testing-framework/libs/k8s/config"
)

const afterTestEndedMsg = "LOG AFTER TEST ENDED"

// CustomT wraps testing.T for two puposes:
// 1. it implements Write to override the default logger
// 2. it implements Printf to implement the testcontainers-go/Logging interface
// The reason for both of these is that go parallel testing causes the logs to get mixed up,
// so we need to override the default logger to *testing.T.Log to ensure that the logs are
// properly associated with the tests running. The testcontainers-go/Logging interface complicates
// this more since it needs a struct with L to hold the logger and needs to override Printf.
type CustomT struct {
	*testing.T
	L     zerolog.Logger
	ended bool
}

func (ct *CustomT) Write(p []byte) (n int, err error) {
	str := string(p)
	if strings.TrimSpace(str) == "" {
		return len(p), nil
	}
	if ct.ended {
		l := GetTestLogger(nil)
		l.Error().Msgf("%s %s: %s", afterTestEndedMsg, ct.Name(), string(p))
		return len(p), nil
	}
	ct.T.Log(strings.TrimSuffix(str, "\n"))
	return len(p), nil
}

// Printf implements the testcontainers-go/Logging interface.
func (ct CustomT) Printf(format string, v ...interface{}) {
	if ct.ended {
		s := "%s: "
		formatted := fmt.Sprintf("%s %s%s", afterTestEndedMsg, s, format)
		l := GetTestLogger(nil)
		l.Error().Msgf(formatted, ct.Name(), v)
	} else {
		ct.L.Info().Msgf(format, v...)
	}
}

func Init() {
	l := GetLogger(nil, config.EnvVarLogLevel)
	log.Logger = l
}

// GetLogger returns a logger that will write to the testing.T.Log function using the env var provided for the log level.
// nil can be passed for t to get a logger that is not associated with a go test.
func GetLogger(t *testing.T, envVarName string) zerolog.Logger {
	lvlStr := os.Getenv(envVarName)
	if lvlStr == "" {
		lvlStr = "info"
	}
	lvl, err := zerolog.ParseLevel(lvlStr)
	if err != nil {
		if t != nil {
			require.NoError(t, err, "error parsing log level")
		} else {
			panic(fmt.Sprintf("failed to parse log level: %s", err))
		}
	}
	zerolog.TimeFieldFormat = time.RFC3339Nano
	if t != nil {
		ct := &CustomT{T: t}
		// Use Cleanup function to set ended to true once the test completes
		t.Cleanup(func() {
			ct.ended = true
		})
		return zerolog.New(ct).Output(zerolog.ConsoleWriter{Out: ct, TimeFormat: "15:04:05.00"}).Level(lvl).With().Timestamp().Logger()
	}
	return log.Output(zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: "15:04:05.00"}).Level(lvl).With().Timestamp().Logger()
}

// GetTestLogger returns a logger that will write to the testing.T.Log function using the env var for log level.
// nil can be passed for t to get a logger that is not associated with a go test.
func GetTestLogger(t *testing.T) zerolog.Logger {
	return GetLogger(t, config.EnvVarLogLevel)
}

// GetTestContainersGoTestLogger returns a logger that will write to the testing.T.Log function using the env var for log level
// for logs that testcontainers-go will log out. nil can be passed to this and it will be treated as the default tc.Logger
func GetTestContainersGoTestLogger(t *testing.T) tc.Logging {
	l := tc.Logger
	if t != nil {
		l = CustomT{
			T: t,
			L: GetTestLogger(t),
		}
	}
	return l
}

// SplitStringIntoChunks takes a string and splits it into chunks of a specified size.
func SplitStringIntoChunks(s string, chunkSize int) []string {
	// Length of the string.
	strLen := len(s)

	// Number of chunks needed.
	numChunks := (strLen + chunkSize - 1) / chunkSize

	// Slice to hold the chunks.
	chunks := make([]string, numChunks)

	// Loop to create chunks.
	for i := 0; i < numChunks; i++ {
		// Calculate the start and end indices of the chunk.
		start := i * chunkSize
		end := start + chunkSize

		// If the end index goes beyond the string length, adjust it to the string length.
		if end > strLen {
			end = strLen
		}

		// Slice the string and add the chunk to the slice.
		chunks[i] = s[start:end]
	}

	return chunks
}