github.com/Jeffail/benthos/v3@v3.65.0/lib/log/modular_test.go (about)

     1  package log
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  	"github.com/stretchr/testify/require"
     9  )
    10  
    11  func TestModules(t *testing.T) {
    12  	loggerConfig := NewConfig()
    13  	loggerConfig.AddTimeStamp = false
    14  	loggerConfig.JSONFormat = false
    15  	loggerConfig.Prefix = "root"
    16  	loggerConfig.LogLevel = "WARN"
    17  
    18  	var buf bytes.Buffer
    19  
    20  	logger := New(&buf, loggerConfig)
    21  	logger.Warnln("Warning message root module")
    22  
    23  	logger2 := logger.NewModule(".foo")
    24  	logger2.Warnln("Warning message root.foo module")
    25  
    26  	logger3 := logger.NewModule(".foo2")
    27  	logger3.Warnln("Warning message root.foo2 module")
    28  
    29  	logger4 := logger2.NewModule(".bar")
    30  	logger4.Warnln("Warning message root.foo.bar module")
    31  
    32  	expected := "WARN | root | Warning message root module\n" +
    33  		"WARN | root.foo | Warning message root.foo module\n" +
    34  		"WARN | root.foo2 | Warning message root.foo2 module\n" +
    35  		"WARN | root.foo.bar | Warning message root.foo.bar module\n"
    36  
    37  	assert.Equal(t, expected, buf.String())
    38  }
    39  
    40  func TestStaticFields(t *testing.T) {
    41  	loggerConfig := NewConfig()
    42  	loggerConfig.AddTimeStamp = false
    43  	loggerConfig.JSONFormat = true
    44  	loggerConfig.Prefix = "root"
    45  	loggerConfig.LogLevel = "WARN"
    46  	loggerConfig.StaticFields = map[string]string{
    47  		"@service": "benthos_service",
    48  		"@system":  "foo",
    49  	}
    50  
    51  	var buf bytes.Buffer
    52  
    53  	logger := New(&buf, loggerConfig)
    54  	logger.Warnln("Warning message root module")
    55  	logger.Warnf("Warning message root module\n")
    56  
    57  	logger2 := logger.NewModule(".foo")
    58  	logger2.Warnln("Warning message root.foo module")
    59  
    60  	expected := `{"@service":"benthos_service","@system":"foo","component":"root","level":"WARN","message":"Warning message root module"}
    61  {"@service":"benthos_service","@system":"foo","component":"root","level":"WARN","message":"Warning message root module"}
    62  {"@service":"benthos_service","@system":"foo","component":"root.foo","level":"WARN","message":"Warning message root.foo module"}
    63  `
    64  
    65  	assert.Equal(t, expected, buf.String())
    66  }
    67  
    68  func TestStaticFieldsOverride(t *testing.T) {
    69  	loggerConfig := NewConfig()
    70  	loggerConfig.AddTimeStamp = false
    71  	loggerConfig.JSONFormat = true
    72  	loggerConfig.Prefix = "root"
    73  	loggerConfig.LogLevel = "WARN"
    74  	loggerConfig.StaticFields = map[string]string{
    75  		"@service": "benthos_service",
    76  		"@system":  "foo",
    77  	}
    78  
    79  	var buf bytes.Buffer
    80  
    81  	logger := New(&buf, loggerConfig)
    82  	logger.Warnf("Warning message root module")
    83  
    84  	logger2 := WithFields(logger, map[string]string{"foo": "bar", "@service": "fooserve"})
    85  	logger2.Warnln("Warning message foo fields")
    86  
    87  	logger.Warnf("Warning message root module\n")
    88  
    89  	expected := `{"@service":"benthos_service","@system":"foo","component":"root","level":"WARN","message":"Warning message root module"}
    90  {"@service":"fooserve","@system":"foo","component":"root","foo":"bar","level":"WARN","message":"Warning message foo fields"}
    91  {"@service":"benthos_service","@system":"foo","component":"root","level":"WARN","message":"Warning message root module"}
    92  `
    93  
    94  	assert.Equal(t, expected, buf.String())
    95  }
    96  
    97  func TestStaticFieldsEmpty(t *testing.T) {
    98  	loggerConfig := NewConfig()
    99  	loggerConfig.AddTimeStamp = false
   100  	loggerConfig.JSONFormat = true
   101  	loggerConfig.Prefix = "root"
   102  	loggerConfig.LogLevel = "WARN"
   103  	loggerConfig.StaticFields = map[string]string{}
   104  
   105  	var buf bytes.Buffer
   106  
   107  	logger := New(&buf, loggerConfig)
   108  	logger.Warnln("Warning message root module")
   109  	logger.Warnf("Warning message root module\n")
   110  
   111  	logger2 := logger.NewModule(".foo")
   112  	logger2.Warnln("Warning message root.foo module")
   113  
   114  	expected := `{"component":"root","level":"WARN","message":"Warning message root module"}
   115  {"component":"root","level":"WARN","message":"Warning message root module"}
   116  {"component":"root.foo","level":"WARN","message":"Warning message root.foo module"}
   117  `
   118  
   119  	assert.Equal(t, expected, buf.String())
   120  }
   121  
   122  func TestLoggerWith(t *testing.T) {
   123  	loggerConfig := NewConfig()
   124  	loggerConfig.AddTimeStamp = false
   125  	loggerConfig.Format = "logfmt"
   126  	loggerConfig.LogLevel = "WARN"
   127  	loggerConfig.StaticFields = map[string]string{
   128  		"@service": "benthos_service",
   129  		"@system":  "foo",
   130  	}
   131  
   132  	var buf bytes.Buffer
   133  
   134  	logger, err := NewV2(&buf, loggerConfig)
   135  	require.NoError(t, err)
   136  
   137  	logger.Warnf("Warning message root module")
   138  
   139  	logger2, err := With(logger, "foo", "bar", "count", 10, "thing", "is a string", "iscool", true)
   140  	require.NoError(t, err)
   141  	logger2.Warnln("Warning message foo fields")
   142  
   143  	logger.Warnf("Warning message root module\n")
   144  
   145  	expected := `@service=benthos_service @system=foo component=benthos level=WARN msg="Warning message root module"
   146  @service=benthos_service @system=foo component=benthos count=10 foo=bar iscool=true thing="is a string" level=WARN msg="Warning message foo fields"
   147  @service=benthos_service @system=foo component=benthos level=WARN msg="Warning message root module"
   148  `
   149  
   150  	assert.Equal(t, expected, buf.String())
   151  }
   152  
   153  func TestLoggerWithOddArgs(t *testing.T) {
   154  	loggerConfig := NewConfig()
   155  	loggerConfig.AddTimeStamp = false
   156  	loggerConfig.Format = "logfmt"
   157  	loggerConfig.LogLevel = "WARN"
   158  	loggerConfig.StaticFields = map[string]string{
   159  		"@service": "benthos_service",
   160  		"@system":  "foo",
   161  	}
   162  
   163  	var buf bytes.Buffer
   164  
   165  	logger, err := NewV2(&buf, loggerConfig)
   166  	require.NoError(t, err)
   167  
   168  	logger, err = With(logger, "foo", "bar", "count", 10, "thing", "is a string", "iscool", true, "woops")
   169  	require.NoError(t, err)
   170  
   171  	logger.Warnln("Warning message foo fields")
   172  
   173  	expected := `@service=benthos_service @system=foo component=benthos count=10 foo=bar iscool=true thing="is a string" level=WARN msg="Warning message foo fields"
   174  `
   175  
   176  	assert.Equal(t, expected, buf.String())
   177  }
   178  
   179  func TestLoggerWithNonStringKeys(t *testing.T) {
   180  	loggerConfig := NewConfig()
   181  	loggerConfig.AddTimeStamp = false
   182  	loggerConfig.Format = "logfmt"
   183  	loggerConfig.LogLevel = "WARN"
   184  	loggerConfig.StaticFields = map[string]string{
   185  		"@service": "benthos_service",
   186  		"@system":  "foo",
   187  	}
   188  
   189  	var buf bytes.Buffer
   190  
   191  	logger, err := NewV2(&buf, loggerConfig)
   192  	require.NoError(t, err)
   193  
   194  	logger, err = With(logger, "foo", "bar", 10, "count", "thing", "is a string", "iscool", true)
   195  	require.NoError(t, err)
   196  
   197  	logger.Warnln("Warning message foo fields")
   198  
   199  	expected := `@service=benthos_service @system=foo component=benthos foo=bar iscool=true thing="is a string" level=WARN msg="Warning message foo fields"
   200  `
   201  
   202  	assert.Equal(t, expected, buf.String())
   203  }
   204  
   205  func TestFormattedLogging(t *testing.T) {
   206  	loggerConfig := NewConfig()
   207  	loggerConfig.AddTimeStamp = false
   208  	loggerConfig.JSONFormat = false
   209  	loggerConfig.Prefix = "test"
   210  	loggerConfig.LogLevel = "WARN"
   211  
   212  	var buf bytes.Buffer
   213  
   214  	logger := New(&buf, loggerConfig)
   215  	logger.Fatalf("fatal test %v\n", 1)
   216  	logger.Errorf("error test %v\n", 2)
   217  	logger.Warnf("warn test %v\n", 3)
   218  	logger.Infof("info test %v\n", 4)
   219  	logger.Debugf("info test %v\n", 5)
   220  	logger.Tracef("trace test %v\n", 6)
   221  
   222  	expected := "FATAL | test | fatal test 1\nERROR | test | error test 2\nWARN | test | warn test 3\n"
   223  
   224  	assert.Equal(t, expected, buf.String())
   225  }
   226  
   227  func TestLineLogging(t *testing.T) {
   228  	loggerConfig := NewConfig()
   229  	loggerConfig.AddTimeStamp = false
   230  	loggerConfig.JSONFormat = false
   231  	loggerConfig.Prefix = "test"
   232  	loggerConfig.LogLevel = "WARN"
   233  
   234  	var buf bytes.Buffer
   235  
   236  	logger := New(&buf, loggerConfig)
   237  	logger.Fatalln("fatal test")
   238  	logger.Errorln("error test")
   239  	logger.Warnln("warn test")
   240  	logger.Infoln("info test")
   241  	logger.Debugln("info test")
   242  	logger.Traceln("trace test")
   243  
   244  	expected := "FATAL | test | fatal test\nERROR | test | error test\nWARN | test | warn test\n"
   245  
   246  	assert.Equal(t, expected, buf.String())
   247  }
   248  
   249  type logCounter struct {
   250  	count int
   251  }
   252  
   253  func (l *logCounter) Write(p []byte) (n int, err error) {
   254  	l.count++
   255  	return len(p), nil
   256  }
   257  
   258  func TestLogLevels(t *testing.T) {
   259  	for i := 0; i < LogAll; i++ {
   260  		loggerConfig := NewConfig()
   261  		loggerConfig.JSONFormat = false
   262  		loggerConfig.LogLevel = intToLogLevel(i)
   263  
   264  		buf := logCounter{}
   265  
   266  		logger := New(&buf, loggerConfig)
   267  		logger.Fatalln("fatal test")
   268  		logger.Errorln("error test")
   269  		logger.Warnln("warn test")
   270  		logger.Infoln("info test")
   271  		logger.Debugln("info test")
   272  		logger.Traceln("trace test")
   273  
   274  		if i != buf.count {
   275  			t.Errorf("Wrong log count for [%v], %v != %v", loggerConfig.LogLevel, i, buf.count)
   276  		}
   277  	}
   278  }