Function TestLogRotationInterval

base/logging_test.go:62–109

(t *testing.T)

}

func TestLogRotationInterval(t *testing.T) {
	LongRunningTest(t)

	// override min rotation interval for testing
	originalMinRotationInterval := minLogRotationInterval
	minLogRotationInterval = time.Millisecond * 10
	defer func() { minLogRotationInterval = originalMinRotationInterval }()

	rotationInterval := time.Millisecond * 100
	config := &FileLoggerConfig{
		Enabled:             Ptr(true),
		CollationBufferSize: Ptr(0),
		Rotation: logRotationConfig{
			RotationInterval: NewConfigDuration(rotationInterval),
			compress:         Ptr(false),
		},
	}

	logPath := lumberjackTempDir(t)
	countBefore := numFilesInDir(t, logPath, false)
	t.Logf("countBefore: %d", countBefore)

	ctx := TestCtx(t)
	fl, err := NewFileLogger(ctx, config, LevelTrace, "test", logPath, 0, nil, nil)
	require.NoError(t, err)
	defer func() {
		assert.NoError(t, fl.Close())
		// Wait for Lumberjack to finish its async log compression work
		// we have no way of waiting for this to finish, or even stopping the millRun() process inside Lumberjack.
		time.Sleep(time.Second)
	}()

	fl.logf("test 1")
	countAfter1 := numFilesInDir(t, logPath, false)
	t.Logf("countAfter1: %d", countAfter1)
	assert.Greater(t, countAfter1, countBefore)

	time.Sleep(rotationInterval * 5)
	countAfterSleep := numFilesInDir(t, logPath, false)
	t.Logf("countAfterSleep: %d", countAfterSleep)
	assert.Greater(t, countAfterSleep, countAfter1)

	fl.logf("test 2")
	countAfter2 := numFilesInDir(t, logPath, false)
	t.Logf("countAfter2: %d", countAfter2)
	assert.GreaterOrEqual(t, countAfter2, countAfterSleep)

}

// Benchmark the time it takes to write x bytes of data to a logger, and optionally rotate and compress it.
func BenchmarkLogRotation(b *testing.B) {