Add Entry structure and define logging methods

Entry structure defines a single log entity.

Entries are created by Logger with private newEntry method.
Centralization of creation:
* allows proper initialization of Logger field;
* opens possibility of adding entries pool in future implementation
    for optimization purposes;
* opens possibility of adding logger's context to entries in future
    implementation.

Logger functions: Emergency, Alert, Critical, Error, Warning, Notice,
Info, Debug create new Entries and log them using process method.
There are also formatted variants of these methods with "f" suffix,
e.g. Errorf.

Similar methods are defined on Entry type. Those methods also call
process method finalizing and logging enries. They are used in case
of finalizing Entries.
This will be useful in case of structured Entries containing properties
or errors. These will be provided by future commits.

The process method verifies if Entry's level pass logger's threshold
and completes Entry structure. In future commits it will pass Entry
to be logged by the Logger.

Change-Id: If7f3b5d251e03031f2fde48e33eae91aa89c8614
Signed-off-by: Lukasz Wojciechowski <l.wojciechow@partner.samsung.com>

diff --git a/logger/entry.go b/logger/entry.go
new file mode 100644 (file)
index 0000000..ee2dcc2
--- /dev/null
+++ b/logger/entry.go
@@ -0,0 +1,132 @@
+/*
+ *  Copyright (c) 2018 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License
+ */
+
+package logger
+
+import (
+       "fmt"
+)
+
+// Entry defines a single log message entity.
+type Entry struct {
+       // Logger points to instance that manages this Entry.
+       Logger *Logger
+       // Level defines importance of log message.
+       Level Level
+       // Message contains actual log message.
+       Message string
+}
+
+// Log builds log message and logs entry.
+func (e *Entry) Log(level Level, args ...interface{}) {
+       e.process(level, fmt.Sprint(args...))
+}
+
+// Logf builds formatted log message and logs entry.
+func (e *Entry) Logf(level Level, format string, args ...interface{}) {
+       e.process(level, fmt.Sprintf(format, args...))
+}
+
+// process verifies if log level is above threshold and logs entry.
+func (e *Entry) process(level Level, msg string) {
+       if !e.Logger.PassThreshold(level) {
+               return
+       }
+       e.Level = level
+       e.Message = msg
+
+       // TODO do the logging stuff.
+}
+
+// Emergency logs emergency level message.
+func (e *Entry) Emergency(args ...interface{}) {
+       e.Log(EmergLevel, args...)
+}
+
+// Alert logs alert level message.
+func (e *Entry) Alert(args ...interface{}) {
+       e.Log(AlertLevel, args...)
+}
+
+// Critical logs critical level message.
+func (e *Entry) Critical(args ...interface{}) {
+       e.Log(CritLevel, args...)
+}
+
+// Error logs error level message.
+func (e *Entry) Error(args ...interface{}) {
+       e.Log(ErrLevel, args...)
+}
+
+// Warning logs warning level message.
+func (e *Entry) Warning(args ...interface{}) {
+       e.Log(WarningLevel, args...)
+}
+
+// Notice logs notice level message.
+func (e *Entry) Notice(args ...interface{}) {
+       e.Log(NoticeLevel, args...)
+}
+
+// Info logs info level message.
+func (e *Entry) Info(args ...interface{}) {
+       e.Log(InfoLevel, args...)
+}
+
+// Debug logs debug level message.
+func (e *Entry) Debug(args ...interface{}) {
+       e.Log(DebugLevel, args...)
+}
+
+// Emergencyf logs emergency level formatted message.
+func (e *Entry) Emergencyf(format string, args ...interface{}) {
+       e.Logf(EmergLevel, format, args...)
+}
+
+// Alertf logs alert level formatted message.
+func (e *Entry) Alertf(format string, args ...interface{}) {
+       e.Logf(AlertLevel, format, args...)
+}
+
+// Criticalf logs critical level formatted message.
+func (e *Entry) Criticalf(format string, args ...interface{}) {
+       e.Logf(CritLevel, format, args...)
+}
+
+// Errorf logs error level formatted message.
+func (e *Entry) Errorf(format string, args ...interface{}) {
+       e.Logf(ErrLevel, format, args...)
+}
+
+// Warningf logs warning level formatted message.
+func (e *Entry) Warningf(format string, args ...interface{}) {
+       e.Logf(WarningLevel, format, args...)
+}
+
+// Noticef logs notice level formatted message.
+func (e *Entry) Noticef(format string, args ...interface{}) {
+       e.Logf(NoticeLevel, format, args...)
+}
+
+// Infof logs info level formatted message.
+func (e *Entry) Infof(format string, args ...interface{}) {
+       e.Logf(InfoLevel, format, args...)
+}
+
+// Debugf logs debug level formatted message.
+func (e *Entry) Debugf(format string, args ...interface{}) {
+       e.Logf(DebugLevel, format, args...)
+}

diff --git a/logger/logger.go b/logger/logger.go
index 45711a3..ed24596 100644 (file)
--- a/logger/logger.go
+++ b/logger/logger.go
@@ -72,3 +72,100 @@ func (l *Logger) PassThreshold(level Level) bool {
        defer l.mutex.Unlock()
        return (level <= l.threshold)
 }
+
+// newEntry creates a new log entry.
+func (l *Logger) newEntry() *Entry {
+       return &Entry{
+               Logger: l,
+       }
+}
+
+// Log builds log message and logs entry.
+func (l *Logger) Log(level Level, args ...interface{}) {
+       l.newEntry().Log(level, args...)
+}
+
+// Logf builds formatted log message and logs entry.
+func (l *Logger) Logf(level Level, format string, args ...interface{}) {
+       l.newEntry().Logf(level, format, args...)
+}
+
+// Emergency logs emergency level message.
+func (l *Logger) Emergency(args ...interface{}) {
+       l.newEntry().Emergency(args...)
+}
+
+// Alert logs alert level message.
+func (l *Logger) Alert(args ...interface{}) {
+       l.newEntry().Alert(args...)
+}
+
+// Critical logs critical level message.
+func (l *Logger) Critical(args ...interface{}) {
+       l.newEntry().Critical(args...)
+}
+
+// Error logs error level message.
+func (l *Logger) Error(args ...interface{}) {
+       l.newEntry().Error(args...)
+}
+
+// Warning logs warning level message.
+func (l *Logger) Warning(args ...interface{}) {
+       l.newEntry().Warning(args...)
+}
+
+// Notice logs notice level message.
+func (l *Logger) Notice(args ...interface{}) {
+       l.newEntry().Notice(args...)
+}
+
+// Info logs info level message.
+func (l *Logger) Info(args ...interface{}) {
+       l.newEntry().Info(args...)
+}
+
+// Debug logs debug level message.
+func (l *Logger) Debug(args ...interface{}) {
+       l.newEntry().Debug(args...)
+}
+
+// Emergencyf logs emergency level formatted message.
+func (l *Logger) Emergencyf(format string, args ...interface{}) {
+       l.newEntry().Emergencyf(format, args...)
+}
+
+// Alertf logs alert level formatted message.
+func (l *Logger) Alertf(format string, args ...interface{}) {
+       l.newEntry().Alertf(format, args...)
+}
+
+// Criticalf logs critical level formatted message.
+func (l *Logger) Criticalf(format string, args ...interface{}) {
+       l.newEntry().Criticalf(format, args...)
+}
+
+// Errorf logs error level formatted message.
+func (l *Logger) Errorf(format string, args ...interface{}) {
+       l.newEntry().Errorf(format, args...)
+}
+
+// Warningf logs warning level formatted message.
+func (l *Logger) Warningf(format string, args ...interface{}) {
+       l.newEntry().Warningf(format, args...)
+}
+
+// Noticef logs notice level formatted message.
+func (l *Logger) Noticef(format string, args ...interface{}) {
+       l.newEntry().Noticef(format, args...)
+}
+
+// Infof logs info level formatted message.
+func (l *Logger) Infof(format string, args ...interface{}) {
+       l.newEntry().Infof(format, args...)
+}
+
+// Debugf logs debug level formatted message.
+func (l *Logger) Debugf(format string, args ...interface{}) {
+       l.newEntry().Debugf(format, args...)
+}