- working on new cmd and logger setup

9 files changed, 144 insertions, 20 deletions

diff --git a/plugins/factory/app.go b/plugins/app/app.go
index 4951e3df..950d7791 100755..100644
--- a/plugins/factory/app.go
+++ b/plugins/app/app.go
@@ -1,4 +1,4 @@
-package factory
+package app
 
 import (
 	"context"
@@ -19,9 +19,9 @@ const ServiceName = "app"
 
 type Env map[string]string
 
-// AppFactory creates workers for the application.
-type AppFactory interface {
-	NewCmdFactory(env Env) (func() *exec.Cmd, error)
+// WorkerFactory creates workers for the application.
+type WorkerFactory interface {
+	CmdFactory(env Env) (func() *exec.Cmd, error)
 	NewWorker(ctx context.Context, env Env) (roadrunner.WorkerBase, error)
 	NewWorkerPool(ctx context.Context, opt roadrunner.Config, env Env) (roadrunner.Pool, error)
 }
@@ -68,7 +68,8 @@ func (app *App) Stop() error {
 	return app.factory.Close(context.Background())
 }
 
-func (app *App) NewCmdFactory(env Env) (func() *exec.Cmd, error) {
+// CmdFactory provides worker command factory assocated with given context.
+func (app *App) CmdFactory(env Env) (func() *exec.Cmd, error) {
 	var cmdArgs []string
 
 	// create command according to the config
@@ -93,8 +94,9 @@ func (app *App) NewCmdFactory(env Env) (func() *exec.Cmd, error) {
 	}, nil
 }
 
+// NewWorker issues new standalone worker.
 func (app *App) NewWorker(ctx context.Context, env Env) (roadrunner.WorkerBase, error) {
-	spawnCmd, err := app.NewCmdFactory(env)
+	spawnCmd, err := app.CmdFactory(env)
 	if err != nil {
 		return nil, err
 	}
@@ -102,8 +104,9 @@ func (app *App) NewWorker(ctx context.Context, env Env) (roadrunner.WorkerBase,
 	return app.factory.SpawnWorkerWithContext(ctx, spawnCmd())
 }
 
+// NewWorkerPool issues new worker pool.
 func (app *App) NewWorkerPool(ctx context.Context, opt roadrunner.Config, env Env) (roadrunner.Pool, error) {
-	spawnCmd, err := app.NewCmdFactory(env)
+	spawnCmd, err := app.CmdFactory(env)
 	if err != nil {
 		return nil, err
 	}
@@ -124,6 +127,7 @@ func (app *App) NewWorkerPool(ctx context.Context, opt roadrunner.Config, env En
 	return p, nil
 }
 
+// creates relay and worker factory.
 func (app *App) initFactory() (roadrunner.Factory, error) {
 	if app.cfg.Relay == "" || app.cfg.Relay == "pipes" {
 		return roadrunner.NewPipeFactory(), nil
diff --git a/plugins/factory/config.go b/plugins/app/config.go
index b2d1d0ad..eaa54e2d 100755..100644
--- a/plugins/factory/config.go
+++ b/plugins/app/config.go
@@ -1,4 +1,4 @@
-package factory
+package app
 
 import "time"
 
diff --git a/plugins/factory/tests/.rr.yaml b/plugins/app/tests/.rr.yaml
index 171f51dc..171f51dc 100755..100644
--- a/plugins/factory/tests/.rr.yaml
+++ b/plugins/app/tests/.rr.yaml
diff --git a/plugins/factory/tests/factory_test.go b/plugins/app/tests/factory_test.go
index 6c264fd6..7c885797 100755..100644
--- a/plugins/factory/tests/factory_test.go
+++ b/plugins/app/tests/factory_test.go
@@ -7,8 +7,8 @@ import (
 	"time"
 
 	"github.com/spiral/endure"
+	"github.com/spiral/roadrunner/v2/plugins/app"
 	"github.com/spiral/roadrunner/v2/plugins/config"
-	"github.com/spiral/roadrunner/v2/plugins/factory"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -26,7 +26,7 @@ func TestFactory(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = container.Register(&factory.App{})
+	err = container.Register(&app.App{})
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/plugins/factory/tests/hello.php b/plugins/app/tests/hello.php
index bf9e82cc..bf9e82cc 100755..100644
--- a/plugins/factory/tests/hello.php
+++ b/plugins/app/tests/hello.php
diff --git a/plugins/factory/tests/plugin_1.go b/plugins/app/tests/plugin_1.go
index 9011bb00..7259ea9d 100755..100644
--- a/plugins/factory/tests/plugin_1.go
+++ b/plugins/app/tests/plugin_1.go
@@ -4,16 +4,16 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/spiral/roadrunner/v2/plugins/app"
 	"github.com/spiral/roadrunner/v2/plugins/config"
-	"github.com/spiral/roadrunner/v2/plugins/factory"
 )
 
 type Foo struct {
 	configProvider config.Provider
-	spawner        factory.AppFactory
+	spawner        app.WorkerFactory
 }
 
-func (f *Foo) Init(p config.Provider, spw factory.AppFactory) error {
+func (f *Foo) Init(p config.Provider, spw app.WorkerFactory) error {
 	f.configProvider = p
 	f.spawner = spw
 	return nil
@@ -22,14 +22,14 @@ func (f *Foo) Init(p config.Provider, spw factory.AppFactory) error {
 func (f *Foo) Serve() chan error {
 	errCh := make(chan error, 1)
 
-	r := &factory.Config{}
+	r := &app.Config{}
 	err := f.configProvider.UnmarshalKey("app", r)
 	if err != nil {
 		errCh <- err
 		return errCh
 	}
 
-	cmd, err := f.spawner.NewCmdFactory(nil)
+	cmd, err := f.spawner.CmdFactory(nil)
 	if err != nil {
 		errCh <- err
 		return errCh
diff --git a/plugins/factory/tests/plugin_2.go b/plugins/app/tests/plugin_2.go
index 9f401bec..86da4eed 100755..100644
--- a/plugins/factory/tests/plugin_2.go
+++ b/plugins/app/tests/plugin_2.go
@@ -7,16 +7,16 @@ import (
 	"time"
 
 	"github.com/spiral/roadrunner/v2"
+	"github.com/spiral/roadrunner/v2/plugins/app"
 	"github.com/spiral/roadrunner/v2/plugins/config"
-	"github.com/spiral/roadrunner/v2/plugins/factory"
 )
 
 type Foo2 struct {
 	configProvider config.Provider
-	wf             factory.AppFactory
+	wf             app.WorkerFactory
 }
 
-func (f *Foo2) Init(p config.Provider, workerFactory factory.AppFactory) error {
+func (f *Foo2) Init(p config.Provider, workerFactory app.WorkerFactory) error {
 	f.configProvider = p
 	f.wf = workerFactory
 	return nil
@@ -25,14 +25,14 @@ func (f *Foo2) Init(p config.Provider, workerFactory factory.AppFactory) error {
 func (f *Foo2) Serve() chan error {
 	errCh := make(chan error, 1)
 
-	r := &factory.Config{}
+	r := &app.Config{}
 	err := f.configProvider.UnmarshalKey("app", r)
 	if err != nil {
 		errCh <- err
 		return errCh
 	}
 
-	cmd, err := f.wf.NewCmdFactory(nil)
+	cmd, err := f.wf.CmdFactory(nil)
 	if err != nil {
 		errCh <- err
 		return errCh
diff --git a/plugins/logger/config.go b/plugins/logger/config.go
new file mode 100644
index 00000000..12badade
--- /dev/null
+++ b/plugins/logger/config.go
@@ -0,0 +1,9 @@
+package logger
+
+type Config struct {
+	Squash   bool
+	Channels map[string]LoggerConfig
+}
+
+type LoggerConfig struct {
+}
diff --git a/plugins/logger/zap_logger.go b/plugins/logger/zap_logger.go
new file mode 100644
index 00000000..747cbf77
--- /dev/null
+++ b/plugins/logger/zap_logger.go
@@ -0,0 +1,111 @@
+package logger
+
+import (
+	"github.com/fatih/color"
+	"github.com/spiral/endure"
+	"github.com/spiral/roadrunner/v2/plugins/config"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+	"strings"
+	"time"
+)
+
+// ServiceName declares service name.
+const ServiceName = "logs"
+
+type LogFactory interface {
+	// GlobalLogger returns global log instance.
+	GlobalLogger() *zap.Logger
+
+	// NamedLogger returns logger dedicated to the specific channel. Similar to Named() but also reads the core params.
+	NamedLogger(name string) *zap.Logger
+}
+
+// ZapLogger manages zap logger.
+type ZapLogger struct {
+	base *zap.Logger
+	cfg  Config
+}
+
+func (z *ZapLogger) Init(cfg config.Provider) (err error) {
+	err = cfg.UnmarshalKey(ServiceName, &z.cfg)
+	if err != nil {
+		return err
+	}
+
+	if z.base == nil {
+		cfg := zap.Config{
+			Level:    zap.NewAtomicLevelAt(zap.DebugLevel),
+			Encoding: "console",
+			EncoderConfig: zapcore.EncoderConfig{
+				MessageKey: "message",
+				LevelKey:   "level",
+				TimeKey:    "time",
+				NameKey:    "name",
+				EncodeName: func(s string, enc zapcore.PrimitiveArrayEncoder) {
+					if len(s) < 12 {
+						s = s + strings.Repeat(" ", 12-len(s))
+					}
+
+					enc.AppendString(color.HiGreenString(s))
+				},
+				EncodeLevel: func(level zapcore.Level, enc zapcore.PrimitiveArrayEncoder) {
+					switch level {
+					case zapcore.DebugLevel:
+						enc.AppendString(color.HiWhiteString(level.CapitalString()))
+					case zapcore.InfoLevel:
+						enc.AppendString(color.HiCyanString(level.CapitalString()))
+					case zapcore.WarnLevel:
+						enc.AppendString(color.HiYellowString(level.CapitalString()))
+					case zapcore.ErrorLevel, zapcore.DPanicLevel:
+						enc.AppendString(color.HiRedString(level.CapitalString()))
+					case zapcore.PanicLevel, zapcore.FatalLevel:
+						enc.AppendString(color.HiMagentaString(level.CapitalString()))
+					}
+				},
+				EncodeTime: func(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
+					enc.AppendString(t.UTC().Format("2006/01/02 15:04:05"))
+				},
+				EncodeCaller: zapcore.ShortCallerEncoder,
+			},
+			OutputPaths:      []string{"stderr"},
+			ErrorOutputPaths: []string{"stderr"},
+		}
+
+		z.base, err = cfg.Build()
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// GlobalLogger returns global log instance.
+func (z *ZapLogger) GlobalLogger() *zap.Logger {
+	return z.base
+}
+
+// NamedLogger returns logger dedicated to the specific channel. Similar to Named() but also reads the core params.
+func (z *ZapLogger) NamedLogger(name string) *zap.Logger {
+	// todo: automatically configure
+	return z.base.Named(name)
+}
+
+// Provides declares factory methods.
+func (z *ZapLogger) Provides() []interface{} {
+	return []interface{}{
+		z.DefaultLogger,
+		z.AllocateLogger,
+	}
+}
+
+// AllocateLogger allocates logger for the service.
+func (z *ZapLogger) AllocateLogger(n endure.Named) (*zap.Logger, error) {
+	return z.NamedLogger(n.Name()), nil
+}
+
+// DefaultLogger returns default logger.
+func (z *ZapLogger) DefaultLogger() (*zap.Logger, error) {
+	return z.GlobalLogger(), nil
+}