1. Added more tests

2. Improved documentation
3. Added to all facades a `Unwrap() [T]` method.

event_equality.go

@@ -121,13 +121,17 @@ func NewEventEqualityFacade(provider func() EventEquality) EventEquality {
 type eventEqualityFacade func() EventEquality
 
 func (instance eventEqualityFacade) AreEventsEqual(left, right Event) (bool, error) {
-	return instance().AreEventsEqual(left, right)
+	return instance.Unwrap().AreEventsEqual(left, right)
 }
 
 func (instance eventEqualityFacade) WithIgnoringKeys(keys ...string) EventEquality {
 	return &ignoringKeysEventEquality{instance, keys}
 }
 
+func (instance eventEqualityFacade) Unwrap() EventEquality {
+	return instance()
+}
+
 type privateEventEqualityImpl struct {
 	inner *EventEqualityImpl
 }

fields/equality.go

@@ -102,7 +102,11 @@ func NewEqualityFacade(provider func() Equality) Equality {
 type equalityFacade func() Equality
 
 func (instance equalityFacade) AreFieldsEqual(left, right Fields) (bool, error) {
-	return instance().AreFieldsEqual(left, right)
+	return instance.Unwrap().AreFieldsEqual(left, right)
+}
+
+func (instance equalityFacade) Unwrap() Equality {
+	return instance()
 }
 
 type privateEqualityImpl struct {

fields/equality_value.go

@@ -51,7 +51,11 @@ func NewValueEqualityFacade(provider func() ValueEquality) ValueEquality {
 type valueEqualityFacade func() ValueEquality
 
 func (instance valueEqualityFacade) AreValuesEqual(name string, left, right interface{}) (bool, error) {
-	return instance().AreValuesEqual(name, left, right)
+	return instance.Unwrap().AreValuesEqual(name, left, right)
+}
+
+func (instance valueEqualityFacade) Unwrap() ValueEquality {
+	return instance()
 }
 
 func isFunction(arg interface{}) bool {

fields/key_spec.go

@@ -27,17 +27,21 @@ func NewKeysSpecFacade(provider func() KeysSpec) KeysSpec {
 type keysSpecFacade func() KeysSpec
 
 func (instance keysSpecFacade) GetTimestamp() string {
-	return instance().GetTimestamp()
+	return instance.Unwrap().GetTimestamp()
 }
 
 func (instance keysSpecFacade) GetMessage() string {
-	return instance().GetMessage()
+	return instance.Unwrap().GetMessage()
 }
 
 func (instance keysSpecFacade) GetError() string {
-	return instance().GetError()
+	return instance.Unwrap().GetError()
 }
 
 func (instance keysSpecFacade) GetLogger() string {
-	return instance().GetLogger()
+	return instance.Unwrap().GetLogger()
+}
+
+func (instance keysSpecFacade) Unwrap() KeysSpec {
+	return instance()
 }

level/provider_facade.go

@@ -9,9 +9,13 @@ func NewProviderFacade(provider func() Provider) Provider {
 type providerFacade func() Provider
 
 func (instance providerFacade) GetName() string {
-	return instance().GetName()
+	return instance.Unwrap().GetName()
 }
 
 func (instance providerFacade) GetLevels() Levels {
-	return instance().GetLevels()
+	return instance.Unwrap().GetLevels()
+}
+
+func (instance providerFacade) Unwrap() Provider {
+	return instance()
 }

native/README.md

@@ -123,6 +123,25 @@ location.DefaultDiscovery = location.NewCallerDiscovery(func (t *location.Caller
 })
 ```
 
+## Flags or similar
+
+You can use the package [facade/value](facade/value) to easily configure the logger using flag libraries like the SDK implementation or other compatible ones.
+
+```go
+pv := value.NewProvider(native.DefaultProvider)
+
+flag.Var(pv.Consumer.Formatter, "log.format", "Configures the log format.")
+flag.Var(pv.Level, "log.level", "Configures the log level.")
+
+flag.Parse()
+```
+
+Now you can call you program with:
+
+```bash
+$ <myExecutable> -log.format=json -log.level=debug ...
+```
+
 ## API
 
 How the whole API works in general please refer the [documentation of slf4g](..) directly.

native/consumer/consumer.go

@@ -43,5 +43,9 @@ func NewFacade(provider func() Consumer) Consumer {
 type facade func() Consumer
 
 func (instance facade) Consume(event log.Event, source log.CoreLogger) {
-	instance().Consume(event, source)
+	instance.Unwrap().Consume(event, source)
+}
+
+func (instance facade) Unwrap() Consumer {
+	return instance()
 }

native/facade/value/consumer.go

@@ -36,7 +36,7 @@ func NewConsumer(target ConsumerTarget, customizer ...func(*Consumer)) Consumer
 
 	fa, ok := target.GetConsumer().(formatter.MutableAware)
 	if !ok {
-		panic(fmt.Errorf("%v does not implement %v", reflect.TypeOf(target.GetConsumer()), reflect.TypeOf((formatter.MutableAware)(nil))))
+		panic(fmt.Errorf("%v does not implement formatter.MutableAware", reflect.TypeOf(target.GetConsumer())))
 	}
 
 	result := Consumer{

native/facade/value/consumer_test.go

@@ -0,0 +1,80 @@
+package value
+
+import (
+	"os"
+	"testing"
+
+	"github.com/echocat/slf4g/internal/test/assert"
+	"github.com/echocat/slf4g/native/consumer"
+)
+
+func Test_NewConsumer_setDefaultConsumer(t *testing.T) {
+	givenTarget := &mockConsumerTarget{}
+
+	instance := NewConsumer(givenTarget)
+
+	assert.ToBeNotNil(t, instance)
+	assert.ToBeSame(t, consumer.Default, givenTarget.consumer)
+	assert.ToBeSame(t, givenTarget.consumer, instance.Formatter.Target)
+}
+
+func Test_NewConsumer_setFallbackConsumer(t *testing.T) {
+	old := consumer.Default
+	defer func() {
+		consumer.Default = old
+	}()
+	consumer.Default = nil
+
+	givenTarget := &mockConsumerTarget{}
+
+	instance := NewConsumer(givenTarget)
+
+	assert.ToBeNotNil(t, instance)
+	assert.ToBeEqual(t, consumer.NewWriter(os.Stderr), givenTarget.consumer)
+	assert.ToBeSame(t, givenTarget.consumer, instance.Formatter.Target)
+}
+
+func Test_NewConsumer_usingExisting(t *testing.T) {
+	givenConsumer := consumer.NewWriter(os.Stderr)
+	givenTarget := &mockConsumerTarget{
+		consumer: givenConsumer,
+	}
+
+	instance := NewConsumer(givenTarget)
+
+	assert.ToBeNotNil(t, instance)
+	assert.ToBeSame(t, givenConsumer, givenTarget.consumer)
+	assert.ToBeSame(t, givenTarget.consumer, instance.Formatter.Target)
+}
+
+func Test_NewConsumer_customize(t *testing.T) {
+	givenTarget := &mockConsumerTarget{}
+	instance := NewConsumer(givenTarget, func(c *Consumer) {
+		c.Formatter.Codec = NoopFormatterCodec()
+	})
+
+	assert.ToBeNotNil(t, instance)
+	assert.ToBeSame(t, NoopFormatterCodec(), instance.Formatter.Codec)
+}
+
+func Test_NewConsumer_panicsOnIncompatible(t *testing.T) {
+	givenTarget := &mockConsumerTarget{
+		consumer: consumer.NewRecorder(),
+	}
+
+	assert.Execution(t, func() {
+		NewConsumer(givenTarget)
+	}).WillPanicWith("^\\*consumer\\.Recorder does not implement formatter\\.MutableAware$")
+}
+
+type mockConsumerTarget struct {
+	consumer consumer.Consumer
+}
+
+func (instance *mockConsumerTarget) GetConsumer() consumer.Consumer {
+	return instance.consumer
+}
+
+func (instance *mockConsumerTarget) SetConsumer(v consumer.Consumer) {
+	instance.consumer = v
+}

native/facade/value/doc.go

@@ -0,0 +1,15 @@
+// Package value provides a value facade for native.Provider to be able
+// to easy be configured using flag libraries like the SDK implementation
+// or other compatible ones. It implements encoding.TextMarshaler and
+// encoding.TextUnmarshaler, too.
+//
+// Example:
+//    pv := value.NewProvider(native.DefaultProvider)
+//
+//    flag.Var(pv.Consumer.Formatter, "log.format", "Configures the log format.")
+//    flag.Var(pv.Level, "log.level", "Configures the log level.")
+//
+//    flag.Parse()
+// Now you can call:
+//    $ <myExecutable> -log.format=json -log.level=debug ...
+package value

native/facade/value/formatter_codec.go

@@ -51,7 +51,7 @@ func (instance MappingFormatterCodec) Parse(plain string) (formatter.Formatter,
 func (instance MappingFormatterCodec) Format(what formatter.Formatter) (string, error) {
 	for n, f := range instance {
 		candidate, err := f()
-		if err == nil && reflect.DeepEqual(what, candidate) {
+		if err == nil && (what == candidate || reflect.DeepEqual(what, candidate)) {
 			return n, nil
 		}
 	}
@@ -84,9 +84,13 @@ func NewFormatterCodecFacade(provider func() FormatterCodec) FormatterCodec {
 type formatterCodecFacade func() FormatterCodec
 
 func (instance formatterCodecFacade) Parse(plain string) (formatter.Formatter, error) {
-	return instance().Parse(plain)
+	return instance.Unwrap().Parse(plain)
 }
 
 func (instance formatterCodecFacade) Format(what formatter.Formatter) (string, error) {
-	return instance().Format(what)
+	return instance.Unwrap().Format(what)
+}
+
+func (instance formatterCodecFacade) Unwrap() FormatterCodec {
+	return instance()
 }