Filter and standard filter

Author: ccpaging

config.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/ccpaging/nxlog4go/cast"
 	"github.com/ccpaging/nxlog4go/driver"
-	"github.com/ccpaging/nxlog4go/patt"
 )
 
 // NameValue stores every single option's name and value.
@@ -35,35 +34,39 @@ type LoggerConfig struct {
 	Filters []*FilterConfig `xml:"filter" json:"filters"`
 }
 
-func setLogger(l *Logger, level int, props []NameValue) (errs []error) {
-	l.Set("level", level)
-	for _, prop := range props {
+func setLogger(l *Logger, enb bool, fc *FilterConfig) (errs []error) {
+	l.Set("level", Level(INFO).Int(fc.Level))
+	for _, prop := range fc.Properties {
 		v := strings.Trim(prop.Value, " \r\n")
 		if err := l.Set(prop.Name, v); err != nil {
 			errs = append(errs, fmt.Errorf("Warn: %s. %s: %s", err.Error(), prop.Name, v))
 		}
 	}
+	l.Enable(enb)
 	return
 }
 
-func loadFilter(level int, typ string, dsn string, props []NameValue) (filter *Filter, errs []error) {
-	app, err := driver.Open(typ, dsn)
+func loadFilter(fc *FilterConfig) (filter *driver.Filter, errs []error) {
+	app, err := driver.Open(fc.Type, fc.Dsn)
 	if app == nil {
 		return nil, append(errs, err)
 	}
 
-	for _, prop := range props {
+	for _, prop := range fc.Properties {
 		v := strings.Trim(prop.Value, " \r\n")
 		if err := app.Set(prop.Name, v); err != nil {
-			errs = append(errs, fmt.Errorf("Warn: Set [%s] as [%s=%s]. %s", typ, prop.Name, v, err.Error()))
+			errs = append(errs, fmt.Errorf("Warn: Set [%s] as [%s=%s]. %s", fc.Type, prop.Name, v, err.Error()))
 		}
 	}
 
-	filter = &Filter{
-		Enabler: driver.AtAbove(level),
-		Layout:  patt.NewLayout(""),
+	filter = &driver.Filter{
+		Name:    fc.Tag,
+		Enabler: driver.AtAbove(Level(INFO).Int(fc.Level)),
+		Layout:  nil,
 		Apps:    []driver.Appender{app},
 	}
+
+	errs = append(errs, fmt.Errorf("Trace: Succeeded loading tag [%s], type [%s], dsn [%s]", fc.Tag, fc.Type, fc.Dsn))
 	return
 }
 
@@ -73,7 +76,7 @@ func (l *Logger) LoadConfiguration(lc *LoggerConfig) (errs []error) {
 		return append(errs, fmt.Errorf("Warn: Logger configuration is NIL"))
 	}
 
-	var filters []*Filter
+	var filters []*driver.Filter
 	for i, fc := range lc.Filters {
 		if fc.Type == "" {
 			errs = append(errs, fmt.Errorf("Warn: The type of Filter [%d] is not defined", i))
@@ -84,28 +87,28 @@ func (l *Logger) LoadConfiguration(lc *LoggerConfig) (errs []error) {
 
 		}
 
-		if enabled, err := cast.ToBool(fc.Enabled); !enabled {
+		enabled, err := cast.ToBool(fc.Enabled)
+		if err != nil {
 			errs = append(errs, fmt.Errorf("Trace: Disable filter [%s]. Error: %v", fc.Tag, err))
-			continue
+		} else if !enabled {
+			errs = append(errs, fmt.Errorf("Trace: Disable filter [%s]", fc.Tag))
 		}
 
-		level := Level(INFO).Int(fc.Level)
-
-		switch fc.Type {
-		case "loglog":
-			multiErr := setLogger(GetLogLog(), level, fc.Properties)
-			errs = append(errs, multiErr...)
-		case "stdout":
-			multiErr := setLogger(l, level, fc.Properties)
-			errs = append(errs, multiErr...)
-		default:
-			filter, multiErr := loadFilter(level, fc.Type, fc.Dsn, fc.Properties)
-			errs = append(errs, multiErr...)
+		var e []error
+		if fc.Type == "loglog" {
+			e = setLogger(GetLogLog(), enabled, fc)
+		} else if fc.Type == stdfName {
+			e = setLogger(l, enabled, fc)
+		} else if enabled {
+			var filter *driver.Filter
+			filter, e = loadFilter(fc)
 			if filter != nil {
-				errs = append(errs, fmt.Errorf("Trace: Succeeded loading tag [%s], type [%s], dsn [%s]", fc.Tag, fc.Type, fc.Dsn))
 				filters = append(filters, filter)
 			}
+		} else {
+			// disabled
 		}
+		errs = append(errs, e...)
 	}
 
 	l.Attach(filters...)

config_test.go

@@ -16,7 +16,7 @@ import (
 )
 
 var xmlBuf = `<logging>
-  <filter enabled="true">
+  <filter enabled="false">
     <tag>stdout</tag>
     <type>stdout</type>
     <level>DEBUG</level>
@@ -27,7 +27,7 @@ var xmlBuf = `<logging>
     <tag>loglog</tag>
     <type>loglog</type>
     <level>DEBUG</level>
-    <property name="format">[%D %T] [%L] (%S) %M</property>
+    <property name="format">"[%D %T] [%L] [%P] (%S) \t%M"</property>
   </filter>
   <filter enabled="true">
     <tag>console</tag>
@@ -118,17 +118,17 @@ func TestXMLConfig(t *testing.T) {
 
 	// Make sure we got all loggers
 	if filters == nil {
-		t.Fatalf("XMLConfig: Expected 3 filters, found %d", len(filters))
+		t.Fatalf("XMLConfig: Expected 4 filters, found %d", len(filters))
 	}
 
-	if len(filters) != 3 {
-		t.Fatalf("XMLConfig: Expected 3 filters, found %d", len(filters))
+	if len(filters) != 4 {
+		t.Fatalf("XMLConfig: Expected 4 filters, found %d", len(filters))
 	}
 
 	// Make sure they're the right type
-	for i, filter := range filters {
+	for name, filter := range filters {
 		if fmt.Sprintf("%T", filter.Dispatch) != "func(*driver.Recorder)" {
-			t.Fatalf("XMLConfig: Expected [%d] filter Dispatch(*nxlog4go.Recorder), found %T", i, filter.Dispatch)
+			t.Fatalf("XMLConfig: Expected [%s] filter Dispatch(*nxlog4go.Recorder), found %T", name, filter.Dispatch)
 		}
 	}
 

filter.go renamed to driver/filter.go

@@ -1,35 +1,28 @@
 // Copyright (C) 2017, ccpaging <[email protected]>.  All rights reserved.
 
-package nxlog4go
+package driver
 
 import (
 	"bytes"
-
-	"github.com/ccpaging/nxlog4go/driver"
 )
 
 // Filter contains:
 //  - Enabler, the Enabler interface for filter log Recorder
 //  - Layout, the Layout interface for encoding log Recorder
 //  - Apps, the slice of the Appender interface
 type Filter struct {
-	driver.Enabler
-	driver.Layout
-	Apps []driver.Appender
-}
-
-// NewFilter creates a new filter with an enabler, a layout
-// and appenders.
-func NewFilter(level int, lo driver.Layout, apps ...driver.Appender) *Filter {
-	return &Filter{driver.AtAbove(level), lo, apps}
+	Name string
+	Enabler
+	Layout
+	Apps []Appender
 }
 
 // Dispatch filters, encodes a log recorder to bytes, and writes it to all appenders.
 //  - Enabler.Enabled, filter log Recorder.
 //  - Layout.Encode, encode log Recorder to bytes.Buffer.
 //  - Apps[i].Enabled, filter log recorder by appender.
 //  - Apps[i].Write, append with log recorder encoded bytes.
-func (f *Filter) Dispatch(r *driver.Recorder) {
+func (f *Filter) Dispatch(r *Recorder) {
 	if f.Enabler != nil && !f.Enabler.Enabled(r) {
 		return
 	}
@@ -53,8 +46,9 @@ func (f *Filter) Dispatch(r *driver.Recorder) {
 
 // Close closes all log appenders in preparation for exiting the program.
 // Calling this is not really imperative, unless you want to
-// guarantee that all log messages are written.  Close() removes
-// all appenders from the filter.
+// guarantee that all log messages are written.
+//
+// Notice: Close() removes all appenders from the filter.
 func (f *Filter) Close() {
 	for _, a := range f.Apps {
 		if a != nil {

examples/example.json

@@ -2,7 +2,7 @@
     "version": "",
     "filters": [
         {
-            "enabled": "true",
+            "enabled": "false",
             "tag": "stdout",
             "type": "stdout",
             "dsn": "",
@@ -27,7 +27,7 @@
             "properties": [
                 {
                     "name": "format",
-                    "value": "[%D %T] [%L] (%S) %M"
+                    "value": "\"[%D %T] [%L] [%P] (%S) \\t%M\""
                 }
             ]
         },

examples/example.xml

@@ -1,5 +1,5 @@
 <logging>
-  <filter enabled="true">
+  <filter enabled="false">
     <tag>stdout</tag>
     <type>stdout</type>
     <level>DEBUG</level>
@@ -10,7 +10,7 @@
     <tag>loglog</tag>
     <type>loglog</type>
     <level>DEBUG</level>
-    <property name="format">[%D %T] [%L] (%S) %M</property>
+    <property name="format">"[%D %T] [%L] [%P] (%S) \t%M"</property>
   </filter>
   <filter enabled="true">
     <tag>console</tag>

examples/jsonconfig.go

@@ -16,7 +16,7 @@ var (
 	fname = flag.String("conf", "example.json", "config file")
 )
 
-var log = l4g.GetLogger().SetOptions("caller", false, "format", "[%T] [%L] (%S) %M\n")
+var log = l4g.GetLogger().SetOptions("caller", true, "format", "[%T] [%P] [%L] (%S) %M\n")
 
 func main() {
 	flag.Parse()

examples/xmlconfig.go

@@ -58,10 +58,10 @@ func main() {
 	log.Trace("Oh no!  %d + %d = %d!", 2, 2, 2+2)
 	log.Info("About that time, eh chaps?")
 
-	// Unload filters
-	log.Detach(filters...)
 	// Do not forget close all filters
 	for _, f := range filters {
+		// Unload filters
+		log.Detach(f)
 		if f != nil {
 			f.Close()
 		}

file/example/jsonOntime.go

@@ -32,7 +32,7 @@ func main() {
 		return
 	}
 
-	logger.Attach(log.NewFilter(log.TRACE, nil, a))
+	logger.AddFilter("json", log.TRACE, a)
 
 	for i := 0; i < 25; i++ {
 		for j := 0; j < 5; j++ {
@@ -61,6 +61,8 @@ func main() {
 		fmt.Println(err)
 	}
 
+	fmt.Println("rotate = 0. Only one log file.")
+
 	// contains a list of all files in the current directory
 	files, _ := filepath.Glob(removeFiles)
 	fmt.Printf("%d files match %s\n", len(files), removeFiles)

file/example/xmlOndemand.go

@@ -32,7 +32,7 @@ func main() {
 		return
 	}
 
-	logger.Attach(log.NewFilter(log.FINE, nil, a))
+	logger.AddFilter("xml", log.FINE, a)
 
 	for i := 0; i < 125; i++ {
 		log.Info("%d: The time is now: %s", i+1, time.Now().Format("15:04:05 MST 2006/01/02"))
@@ -46,6 +46,8 @@ func main() {
 		fmt.Println(err)
 	}
 
+	fmt.Println("rotate = 1. There are two log files.")
+
 	// contains a list of all files in the current directory
 	files, _ := filepath.Glob(removeFiles)
 	fmt.Printf("%d files match %s\n", len(files), removeFiles)

file/filelog_test.go

@@ -32,6 +32,15 @@ func newLogRecord(level int, src string, msg string) *driver.Recorder {
 	}
 }
 
+func newFilter(level int, a driver.Appender) *driver.Filter {
+	return &driver.Filter{
+		Name:    "file",
+		Enabler: driver.AtAbove(level),
+		Layout:  nil,
+		Apps:    []driver.Appender{a},
+	}
+}
+
 func removeFile(t *testing.T, filename string) {
 	err := os.Remove(filename)
 	if err != nil && t != nil {
@@ -82,7 +91,7 @@ func TestFileLog(t *testing.T) {
 
 	// Create a default logger that is logging messages of FINE or higher
 	a, _ := NewFileAppender(testLogFile, "rotate", 0)
-	f := l4g.NewFilter(l4g.FINE, nil, a)
+	f := newFilter(l4g.FINE, a)
 	log.Attach(f)
 	writeSomethingToLogFile(log)
 	log.Detach(f)
@@ -112,7 +121,7 @@ func TestFileLogRotate(t *testing.T) {
 		"cycle", 5,
 		"maxsize", "5k")
 
-	log.Attach(l4g.NewFilter(l4g.FINE, nil, a))
+	log.Attach(newFilter(l4g.FINE, a))
 	// Log some experimental messages
 	for j := 0; j < 15; j++ {
 		for i := 0; i < 200/(j+1); i++ {
@@ -140,7 +149,7 @@ func BenchmarkCacheFileLog(b *testing.B) {
 	b.StopTimer()
 	a, _ := NewFileAppender(benchLogFile,
 		"level", l4g.INFO, "rotate", 0)
-	sl.Attach(l4g.NewFilter(l4g.INFO, nil, a))
+	sl.Attach(newFilter(l4g.INFO, a))
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		sl.Warn("This is a log message")
@@ -155,7 +164,7 @@ func BenchmarkCacheFileNotLogged(b *testing.B) {
 	b.StopTimer()
 	a, _ := NewFileAppender(benchLogFile,
 		"level", l4g.INFO, "rotate", 0)
-	sl.Attach(l4g.NewFilter(l4g.INFO, nil, a))
+	sl.Attach(newFilter(l4g.INFO, a))
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		sl.Debug("This is a log message")
@@ -170,7 +179,7 @@ func BenchmarkCacheFileUtilLog(b *testing.B) {
 	b.StopTimer()
 	a, _ := NewFileAppender(benchLogFile,
 		"level", l4g.INFO, "rotate", 0)
-	sl.Attach(l4g.NewFilter(l4g.INFO, nil, a))
+	sl.Attach(newFilter(l4g.INFO, a))
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		sl.Info("%s is a log message", "This")
@@ -185,7 +194,7 @@ func BenchmarkCacheFileUtilNotLog(b *testing.B) {
 	b.StopTimer()
 	a, _ := NewFileAppender(benchLogFile,
 		"level", l4g.INFO, "rotate", 0)
-	sl.Attach(l4g.NewFilter(l4g.WARN, nil, a))
+	sl.Attach(newFilter(l4g.WARN, a))
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		sl.Debug("%s is a log message", "This")