When testing with multiple logger instances, the default logger (in scope) needs to be overridden (to be initialized with the cloned (of the given) logger instance). Context: https://github.com/tetratelabs/telemetry/pull/13.

Signed-off-by: Dhi Aurrahman [email protected]

When registering a new scope, we need to make sure we clone the default logger, if present. Otherwise, all scopes will end up sharing the same log level and it won't be able to be changed individually. This was already addressed in the UseLogger method but was not taken care of during registration, making the scope level setting only work if the loggers were registered before calling the UseLogger method.

Fix https://github.com/tetratelabs/telemetry/issues/15

Fixes how cloning works in the Function logger so that enhancing a logger with values keeps the original references (such as levels) for the fields, but cloning dereferences them. This effectively helps decorating the Function logger with logging scopes.

I have the following program (using github.com/tetratelabs/log as the telemetry.Logger implementation): https://go.dev/play/p/zFPUPY_72Jz, I expect executing scopeA.SetLevel(telemetry.LevelInfo) only updates the scopeA, however, I saw scopeB's level is also updated. I believe I missed something obvious here. 🙇🏾

package main

import (
	"fmt"

	"github.com/tetratelabs/log"
	"github.com/tetratelabs/telemetry"
	"github.com/tetratelabs/telemetry/scope"
)

func main() {
	l := log.New()
	a := scope.Register("a", "Messages from a")
	b := scope.Register("b", "Messages from b")
	scope.UseLogger(l)

	scopeA, _ := scope.Find("a")
	scopeA.SetLevel(telemetry.LevelDebug)
	scopeB, _ := scope.Find("b")
	scopeB.SetLevel(telemetry.LevelDebug)

	fmt.Println("scopeA == instance a", scopeA == a, scopeA)
	fmt.Println("scopeB == instance b", scopeB == b, scopeB)

	fmt.Println()
	fmt.Println("scope level a", scopeA.Level().String())
	fmt.Println("scope level b", scopeB.Level().String()) // despite only updating scope a, scope b level is changed too.
	fmt.Println()

	print(a)
	print(b)

	scopeA.SetLevel(telemetry.LevelInfo)

	fmt.Println()
	fmt.Println("after scope 'a' is updated to info:")

	fmt.Println()
	fmt.Println("scope level a", scopeA.Level().String())
	fmt.Println("scope level b", scopeB.Level().String()) // despite only updating scope a, scope b level is changed too.

	print(a)
	print(b) // Since we don't update scope 'b', we expect to still see "time="..." level=debug msg="debug" scope="b"" here.
}

func print(logger telemetry.Logger) {
	logger.Info("info")
	logger.Debug("debug")
}

Output, after scope 'a' is updated to info, I expect scope b to still have that debug part.

scopeA == instance a true &{0xc000060190 [] <nil> <nil> a Messages from a <nil>}
scopeB == instance b true &{0xc000060280 [] <nil> <nil> b Messages from b <nil>}

scope level a debug
scope level b debug

time="2009/11/10 23:00:00" level=info msg="info" scope="a"
time="2009/11/10 23:00:00" level=debug msg="debug" scope="a"
time="2009/11/10 23:00:00" level=info msg="info" scope="b"
time="2009/11/10 23:00:00" level=debug msg="debug" scope="b"

after scope 'a' is updated to info:

scope level a info
scope level b info
time="2009/11/10 23:00:00" level=info msg="info" scope="a"
time="2009/11/10 23:00:00" level=info msg="info" scope="b"

Program exited.

Seems like if being used, "replaces" are not being transitively resolved from the project that consumes this module.

Signed-off-by: Dhi Aurrahman [email protected]

Makes the Level concept top-level in the Logger interface and adds a Function logger that allows users to easily configure logging with a custom function.

Now that the code contains more tests, this also adds the pertinent CI configuration and build files to run tests, sanity checks, coverage, linters, etc.

GlobalMetricSink logic allows packages to purely use the telemetry.MetricSink interface without it being passed along.

Common initialization:

func main() {
	...
	telemetry.SetGlobalMetricSink(opencensus.New(
		scope.Register("metrics", "metrics related messages"),
	))
	...
}

Common usage:

package somelib

var (
	labelStatus   telemetry.Label
	metricCounter telemetry.Metric
)

func init() {
	telemetry.ToGlobalMetricSink(func(m telemetry.MetricSink) {
		labelStatus = m.NewLabel("status")
		metricCounter = m.NewSum(
			"counter_total", 
			"description of this metric",
			telemetry.WithLabels(labelStatus).
	}
)

This PR Adds:

• level logger interface and level logger wrapper (for bare bones telemetry.Logger implementations)
• scoped logger facade (similar to Istio one) with level logger support (allowing lazy loading of logger implementation)
• run.Group compatible config for scoped logger