Merge pull request #2172 from hashicorp/b-executor-log-level

Filter executor log messages

client/config/config.go

@@ -149,6 +149,9 @@ type Config struct {
 
 	// TLSConfig holds various TLS related configurations
 	TLSConfig *config.TLSConfig
+
+	// LogLevel is the level of the logs to putout
+	LogLevel string
 }
 
 func (c *Config) Copy() *Config {
@@ -172,6 +175,7 @@ func DefaultConfig() *Config {
 		Region:                  "global",
 		StatsCollectionInterval: 1 * time.Second,
 		TLSConfig:               &config.TLSConfig{},
+		LogLevel:                "DEBUG",
 	}
 }
 

client/driver/docker.go

@@ -6,7 +6,6 @@ import (
 	"log"
 	"net"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"regexp"
 	"runtime"
@@ -26,7 +25,6 @@ import (
 	"github.com/hashicorp/nomad/client/driver/executor"
 	dstructs "github.com/hashicorp/nomad/client/driver/structs"
 	cstructs "github.com/hashicorp/nomad/client/structs"
-	"github.com/hashicorp/nomad/helper/discover"
 	"github.com/hashicorp/nomad/helper/fields"
 	shelpers "github.com/hashicorp/nomad/helper/stats"
 	"github.com/hashicorp/nomad/nomad/structs"
@@ -387,17 +385,14 @@ func (d *DockerDriver) Prestart(ctx *ExecContext, task *structs.Task) error {
 }
 
 func (d *DockerDriver) Start(ctx *ExecContext, task *structs.Task) (DriverHandle, error) {
-	bin, err := discover.NomadExecutable()
-	if err != nil {
-		return nil, fmt.Errorf("unable to find the nomad binary: %v", err)
-	}
 
 	pluginLogFile := filepath.Join(ctx.TaskDir.Dir, "executor.out")
-	pluginConfig := &plugin.ClientConfig{
-		Cmd: exec.Command(bin, "executor", pluginLogFile),
+	executorConfig := &dstructs.ExecutorConfig{
+		LogFile:  pluginLogFile,
+		LogLevel: d.config.LogLevel,
 	}
 
-	exec, pluginClient, err := createExecutor(pluginConfig, d.config.LogOutput, d.config)
+	exec, pluginClient, err := createExecutor(d.config.LogOutput, d.config, executorConfig)
 	if err != nil {
 		return nil, err
 	}
@@ -1119,7 +1114,7 @@ func (d *DockerDriver) Open(ctx *ExecContext, handleID string) (DriverHandle, er
 	if !found {
 		return nil, fmt.Errorf("Failed to find container %s", pid.ContainerID)
 	}
-	exec, pluginClient, err := createExecutor(pluginConfig, d.config.LogOutput, d.config)
+	exec, pluginClient, err := createExecutorWithConfig(pluginConfig, d.config.LogOutput)
 	if err != nil {
 		d.logger.Printf("[INFO] driver.docker: couldn't re-attach to the plugin process: %v", err)
 		d.logger.Printf("[DEBUG] driver.docker: stopping container %q", pid.ContainerID)

client/driver/driver.go

@@ -156,7 +156,10 @@ type ExecContext struct {
 
 // NewExecContext is used to create a new execution context
 func NewExecContext(td *allocdir.TaskDir, allocID string) *ExecContext {
-	return &ExecContext{TaskDir: td, AllocID: allocID}
+	return &ExecContext{
+		TaskDir: td,
+		AllocID: allocID,
+	}
 }
 
 // GetTaskEnv converts the alloc dir, the node, task and alloc into a

client/driver/exec.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"log"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"time"
 
@@ -15,7 +14,6 @@ import (
 	"github.com/hashicorp/nomad/client/driver/executor"
 	dstructs "github.com/hashicorp/nomad/client/driver/structs"
 	cstructs "github.com/hashicorp/nomad/client/structs"
-	"github.com/hashicorp/nomad/helper/discover"
 	"github.com/hashicorp/nomad/helper/fields"
 	"github.com/hashicorp/nomad/nomad/structs"
 	"github.com/mitchellh/mapstructure"
@@ -110,16 +108,12 @@ func (d *ExecDriver) Start(ctx *ExecContext, task *structs.Task) (DriverHandle,
 		return nil, err
 	}
 
-	bin, err := discover.NomadExecutable()
-	if err != nil {
-		return nil, fmt.Errorf("unable to find the nomad binary: %v", err)
-	}
 	pluginLogFile := filepath.Join(ctx.TaskDir.Dir, "executor.out")
-	pluginConfig := &plugin.ClientConfig{
-		Cmd: exec.Command(bin, "executor", pluginLogFile),
+	executorConfig := &dstructs.ExecutorConfig{
+		LogFile:  pluginLogFile,
+		LogLevel: d.config.LogLevel,
 	}
-
-	exec, pluginClient, err := createExecutor(pluginConfig, d.config.LogOutput, d.config)
+	exec, pluginClient, err := createExecutor(d.config.LogOutput, d.config, executorConfig)
 	if err != nil {
 		return nil, err
 	}
@@ -191,7 +185,7 @@ func (d *ExecDriver) Open(ctx *ExecContext, handleID string) (DriverHandle, erro
 	pluginConfig := &plugin.ClientConfig{
 		Reattach: id.PluginConfig.PluginConfig(),
 	}
-	exec, client, err := createExecutor(pluginConfig, d.config.LogOutput, d.config)
+	exec, client, err := createExecutorWithConfig(pluginConfig, d.config.LogOutput)
 	if err != nil {
 		merrs := new(multierror.Error)
 		merrs.Errors = append(merrs.Errors, err)

client/driver/executor/executor.go

@@ -559,7 +559,7 @@ func (e *UniversalExecutor) pidStats() (map[string]*cstructs.ResourceUsage, erro
 	for pid, np := range pids {
 		p, err := process.NewProcess(int32(pid))
 		if err != nil {
-			e.logger.Printf("[DEBUG] executor: unable to create new process with pid: %v", pid)
+			e.logger.Printf("[TRACE] executor: unable to create new process with pid: %v", pid)
 			continue
 		}
 		ms := &cstructs.MemoryStats{}

client/driver/java.go

@@ -22,7 +22,6 @@ import (
 	dstructs "github.com/hashicorp/nomad/client/driver/structs"
 	"github.com/hashicorp/nomad/client/fingerprint"
 	cstructs "github.com/hashicorp/nomad/client/structs"
-	"github.com/hashicorp/nomad/helper/discover"
 	"github.com/hashicorp/nomad/helper/fields"
 	"github.com/hashicorp/nomad/nomad/structs"
 )
@@ -191,17 +190,13 @@ func (d *JavaDriver) Start(ctx *ExecContext, task *structs.Task) (DriverHandle,
 		args = append(args, driverConfig.Args...)
 	}
 
-	bin, err := discover.NomadExecutable()
-	if err != nil {
-		return nil, fmt.Errorf("unable to find the nomad binary: %v", err)
-	}
-
 	pluginLogFile := filepath.Join(ctx.TaskDir.Dir, "executor.out")
-	pluginConfig := &plugin.ClientConfig{
-		Cmd: exec.Command(bin, "executor", pluginLogFile),
+	executorConfig := &dstructs.ExecutorConfig{
+		LogFile:  pluginLogFile,
+		LogLevel: d.config.LogLevel,
 	}
 
-	execIntf, pluginClient, err := createExecutor(pluginConfig, d.config.LogOutput, d.config)
+	execIntf, pluginClient, err := createExecutor(d.config.LogOutput, d.config, executorConfig)
 	if err != nil {
 		return nil, err
 	}
@@ -285,7 +280,7 @@ func (d *JavaDriver) Open(ctx *ExecContext, handleID string) (DriverHandle, erro
 	pluginConfig := &plugin.ClientConfig{
 		Reattach: id.PluginConfig.PluginConfig(),
 	}
-	exec, pluginClient, err := createExecutor(pluginConfig, d.config.LogOutput, d.config)
+	exec, pluginClient, err := createExecutorWithConfig(pluginConfig, d.config.LogOutput)
 	if err != nil {
 		merrs := new(multierror.Error)
 		merrs.Errors = append(merrs.Errors, err)

client/driver/plugins.go

@@ -4,8 +4,10 @@ import (
 	"io"
 	"log"
 	"net"
+	"strings"
 
 	"github.com/hashicorp/go-plugin"
+	"github.com/hashicorp/logutils"
 )
 
 var HandshakeConfig = plugin.HandshakeConfig{
@@ -14,15 +16,18 @@ var HandshakeConfig = plugin.HandshakeConfig{
 	MagicCookieValue: "e4327c2e01eabfd75a8a67adb114fb34a757d57eee7728d857a8cec6e91a7255",
 }
 
-func GetPluginMap(w io.Writer) map[string]plugin.Plugin {
+func GetPluginMap(w io.Writer, logLevel string) map[string]plugin.Plugin {
 	e := new(ExecutorPlugin)
-	e.logger = log.New(w, "", log.LstdFlags)
+	filter := &logutils.LevelFilter{
+		Levels:   []logutils.LogLevel{"TRACE", "DEBUG", "INFO", "WARN", "ERR"},
+		MinLevel: logutils.LogLevel(strings.ToUpper(logLevel)),
+		Writer:   w,
+	}
+
+	e.logger = log.New(filter, "", log.LstdFlags|log.Lmicroseconds)
 
-	s := new(SyslogCollectorPlugin)
-	s.logger = log.New(w, "", log.LstdFlags)
 	return map[string]plugin.Plugin{
-		"executor":        e,
-		"syslogcollector": s,
+		"executor": e,
 	}
 }
 

client/driver/qemu.go

@@ -18,7 +18,6 @@ import (
 	dstructs "github.com/hashicorp/nomad/client/driver/structs"
 	"github.com/hashicorp/nomad/client/fingerprint"
 	cstructs "github.com/hashicorp/nomad/client/structs"
-	"github.com/hashicorp/nomad/helper/discover"
 	"github.com/hashicorp/nomad/helper/fields"
 	"github.com/hashicorp/nomad/nomad/structs"
 	"github.com/mitchellh/mapstructure"
@@ -233,17 +232,13 @@ func (d *QemuDriver) Start(ctx *ExecContext, task *structs.Task) (DriverHandle,
 	}
 
 	d.logger.Printf("[DEBUG] Starting QemuVM command: %q", strings.Join(args, " "))
-	bin, err := discover.NomadExecutable()
-	if err != nil {
-		return nil, fmt.Errorf("unable to find the nomad binary: %v", err)
-	}
-
 	pluginLogFile := filepath.Join(ctx.TaskDir.Dir, "executor.out")
-	pluginConfig := &plugin.ClientConfig{
-		Cmd: exec.Command(bin, "executor", pluginLogFile),
+	executorConfig := &dstructs.ExecutorConfig{
+		LogFile:  pluginLogFile,
+		LogLevel: d.config.LogLevel,
 	}
 
-	exec, pluginClient, err := createExecutor(pluginConfig, d.config.LogOutput, d.config)
+	exec, pluginClient, err := createExecutor(d.config.LogOutput, d.config, executorConfig)
 	if err != nil {
 		return nil, err
 	}
@@ -311,7 +306,7 @@ func (d *QemuDriver) Open(ctx *ExecContext, handleID string) (DriverHandle, erro
 		Reattach: id.PluginConfig.PluginConfig(),
 	}
 
-	exec, pluginClient, err := createExecutor(pluginConfig, d.config.LogOutput, d.config)
+	exec, pluginClient, err := createExecutorWithConfig(pluginConfig, d.config.LogOutput)
 	if err != nil {
 		d.logger.Println("[ERR] driver.qemu: error connecting to plugin so destroying plugin pid and user pid")
 		if e := destroyPlugin(id.PluginConfig.Pid, id.UserPid); e != nil {

client/driver/raw_exec.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"log"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"time"
 
@@ -15,7 +14,6 @@ import (
 	dstructs "github.com/hashicorp/nomad/client/driver/structs"
 	"github.com/hashicorp/nomad/client/fingerprint"
 	cstructs "github.com/hashicorp/nomad/client/structs"
-	"github.com/hashicorp/nomad/helper/discover"
 	"github.com/hashicorp/nomad/helper/fields"
 	"github.com/hashicorp/nomad/nomad/structs"
 	"github.com/mitchellh/mapstructure"
@@ -124,16 +122,13 @@ func (d *RawExecDriver) Start(ctx *ExecContext, task *structs.Task) (DriverHandl
 		return nil, err
 	}
 
-	bin, err := discover.NomadExecutable()
-	if err != nil {
-		return nil, fmt.Errorf("unable to find the nomad binary: %v", err)
-	}
 	pluginLogFile := filepath.Join(ctx.TaskDir.Dir, "executor.out")
-	pluginConfig := &plugin.ClientConfig{
-		Cmd: exec.Command(bin, "executor", pluginLogFile),
+	executorConfig := &dstructs.ExecutorConfig{
+		LogFile:  pluginLogFile,
+		LogLevel: d.config.LogLevel,
 	}
 
-	exec, pluginClient, err := createExecutor(pluginConfig, d.config.LogOutput, d.config)
+	exec, pluginClient, err := createExecutor(d.config.LogOutput, d.config, executorConfig)
 	if err != nil {
 		return nil, err
 	}
@@ -199,7 +194,7 @@ func (d *RawExecDriver) Open(ctx *ExecContext, handleID string) (DriverHandle, e
 	pluginConfig := &plugin.ClientConfig{
 		Reattach: id.PluginConfig.PluginConfig(),
 	}
-	exec, pluginClient, err := createExecutor(pluginConfig, d.config.LogOutput, d.config)
+	exec, pluginClient, err := createExecutorWithConfig(pluginConfig, d.config.LogOutput)
 	if err != nil {
 		d.logger.Println("[ERR] driver.raw_exec: error connecting to plugin so destroying plugin pid and user pid")
 		if e := destroyPlugin(id.PluginConfig.Pid, id.UserPid); e != nil {

client/driver/rkt.go

@@ -23,7 +23,6 @@ import (
 	"github.com/hashicorp/nomad/client/driver/executor"
 	dstructs "github.com/hashicorp/nomad/client/driver/structs"
 	cstructs "github.com/hashicorp/nomad/client/structs"
-	"github.com/hashicorp/nomad/helper/discover"
 	"github.com/hashicorp/nomad/helper/fields"
 	"github.com/hashicorp/nomad/nomad/structs"
 	"github.com/mitchellh/mapstructure"
@@ -394,17 +393,13 @@ func (d *RktDriver) Start(ctx *ExecContext, task *structs.Task) (DriverHandle, e
 	filter := strings.Split(d.config.ReadDefault("env.blacklist", config.DefaultEnvBlacklist), ",")
 	d.taskEnv.AppendHostEnvvars(filter)
 
-	bin, err := discover.NomadExecutable()
-	if err != nil {
-		return nil, fmt.Errorf("unable to find the nomad binary: %v", err)
-	}
-
 	pluginLogFile := filepath.Join(ctx.TaskDir.Dir, fmt.Sprintf("%s-executor.out", task.Name))
-	pluginConfig := &plugin.ClientConfig{
-		Cmd: exec.Command(bin, "executor", pluginLogFile),
+	executorConfig := &dstructs.ExecutorConfig{
+		LogFile:  pluginLogFile,
+		LogLevel: d.config.LogLevel,
 	}
 
-	execIntf, pluginClient, err := createExecutor(pluginConfig, d.config.LogOutput, d.config)
+	execIntf, pluginClient, err := createExecutor(d.config.LogOutput, d.config, executorConfig)
 	if err != nil {
 		return nil, err
 	}
@@ -467,7 +462,7 @@ func (d *RktDriver) Open(ctx *ExecContext, handleID string) (DriverHandle, error
 	pluginConfig := &plugin.ClientConfig{
 		Reattach: id.PluginConfig.PluginConfig(),
 	}
-	exec, pluginClient, err := createExecutor(pluginConfig, d.config.LogOutput, d.config)
+	exec, pluginClient, err := createExecutorWithConfig(pluginConfig, d.config.LogOutput)
 	if err != nil {
 		d.logger.Println("[ERROR] driver.rkt: error connecting to plugin so destroying plugin pid and user pid")
 		if e := destroyPlugin(id.PluginConfig.Pid, id.ExecutorPid); e != nil {

client/driver/structs/structs.go

@@ -55,3 +55,13 @@ type CheckResult struct {
 	// Err is the error that a check returned
 	Err error
 }
+
+// ExecutorConfig is the config that Nomad passes to the executor
+type ExecutorConfig struct {
+
+	// LogFile is the file to which Executor logs
+	LogFile string
+
+	// LogLevel is the level of the logs to putout
+	LogLevel string
+}

client/driver/syslog_plugin.go

@@ -1,69 +0,0 @@
-package driver
-
-import (
-	"log"
-	"net/rpc"
-
-	"github.com/hashicorp/go-plugin"
-	"github.com/hashicorp/nomad/client/driver/logging"
-	"github.com/hashicorp/nomad/nomad/structs"
-)
-
-type SyslogCollectorRPC struct {
-	client *rpc.Client
-}
-
-type LaunchCollectorArgs struct {
-	Ctx *logging.LogCollectorContext
-}
-
-func (e *SyslogCollectorRPC) LaunchCollector(ctx *logging.LogCollectorContext) (*logging.SyslogCollectorState, error) {
-	var ss *logging.SyslogCollectorState
-	err := e.client.Call("Plugin.LaunchCollector", LaunchCollectorArgs{Ctx: ctx}, &ss)
-	return ss, err
-}
-
-func (e *SyslogCollectorRPC) Exit() error {
-	return e.client.Call("Plugin.Exit", new(interface{}), new(interface{}))
-}
-
-func (e *SyslogCollectorRPC) UpdateLogConfig(logConfig *structs.LogConfig) error {
-	return e.client.Call("Plugin.UpdateLogConfig", logConfig, new(interface{}))
-}
-
-type SyslogCollectorRPCServer struct {
-	Impl logging.LogCollector
-}
-
-func (s *SyslogCollectorRPCServer) LaunchCollector(args LaunchCollectorArgs,
-	resp *logging.SyslogCollectorState) error {
-	ss, err := s.Impl.LaunchCollector(args.Ctx)
-	if ss != nil {
-		*resp = *ss
-	}
-	return err
-}
-
-func (s *SyslogCollectorRPCServer) Exit(args interface{}, resp *interface{}) error {
-	return s.Impl.Exit()
-}
-
-func (s *SyslogCollectorRPCServer) UpdateLogConfig(logConfig *structs.LogConfig, resp *interface{}) error {
-	return s.Impl.UpdateLogConfig(logConfig)
-}
-
-type SyslogCollectorPlugin struct {
-	logger *log.Logger
-	Impl   *SyslogCollectorRPCServer
-}
-
-func (p *SyslogCollectorPlugin) Server(*plugin.MuxBroker) (interface{}, error) {
-	if p.Impl == nil {
-		p.Impl = &SyslogCollectorRPCServer{Impl: logging.NewSyslogCollector(p.logger)}
-	}
-	return p.Impl, nil
-}
-
-func (p *SyslogCollectorPlugin) Client(b *plugin.MuxBroker, c *rpc.Client) (interface{}, error) {
-	return &SyslogCollectorRPC{client: c}, nil
-}

client/driver/utils.go

@@ -1,6 +1,7 @@
 package driver
 
 import (
+	"encoding/json"
 	"fmt"
 	"io"
 	"os"
@@ -13,17 +14,30 @@ import (
 	"github.com/hashicorp/go-plugin"
 	"github.com/hashicorp/nomad/client/config"
 	"github.com/hashicorp/nomad/client/driver/executor"
-	"github.com/hashicorp/nomad/client/driver/logging"
 	cstructs "github.com/hashicorp/nomad/client/driver/structs"
+	"github.com/hashicorp/nomad/helper/discover"
 	"github.com/hashicorp/nomad/nomad/structs"
 )
 
 // createExecutor launches an executor plugin and returns an instance of the
 // Executor interface
-func createExecutor(config *plugin.ClientConfig, w io.Writer,
-	clientConfig *config.Config) (executor.Executor, *plugin.Client, error) {
+func createExecutor(w io.Writer, clientConfig *config.Config,
+	executorConfig *cstructs.ExecutorConfig) (executor.Executor, *plugin.Client, error) {
+
+	c, err := json.Marshal(executorConfig)
+	if err != nil {
+		return nil, nil, fmt.Errorf("unable to create executor config: %v", err)
+	}
+	bin, err := discover.NomadExecutable()
+	if err != nil {
+		return nil, nil, fmt.Errorf("unable to find the nomad binary: %v", err)
+	}
+
+	config := &plugin.ClientConfig{
+		Cmd: exec.Command(bin, "executor", string(c)),
+	}
 	config.HandshakeConfig = HandshakeConfig
-	config.Plugins = GetPluginMap(w)
+	config.Plugins = GetPluginMap(w, clientConfig.LogLevel)
 	config.MaxPort = clientConfig.ClientMaxPort
 	config.MinPort = clientConfig.ClientMinPort
 
@@ -47,28 +61,25 @@ func createExecutor(config *plugin.ClientConfig, w io.Writer,
 	return executorPlugin, executorClient, nil
 }
 
-func createLogCollector(config *plugin.ClientConfig, w io.Writer,
-	clientConfig *config.Config) (logging.LogCollector, *plugin.Client, error) {
+func createExecutorWithConfig(config *plugin.ClientConfig, w io.Writer) (executor.Executor, *plugin.Client, error) {
 	config.HandshakeConfig = HandshakeConfig
-	config.Plugins = GetPluginMap(w)
-	config.MaxPort = clientConfig.ClientMaxPort
-	config.MinPort = clientConfig.ClientMinPort
-	if config.Cmd != nil {
-		isolateCommand(config.Cmd)
+
+	// Setting this to DEBUG since the log level at the executor server process
+	// is already set, and this effects only the executor client.
+	config.Plugins = GetPluginMap(w, "DEBUG")
+
+	executorClient := plugin.NewClient(config)
+	rpcClient, err := executorClient.Client()
+	if err != nil {
+		return nil, nil, fmt.Errorf("error creating rpc client for executor plugin: %v", err)
 	}
 
-	syslogClient := plugin.NewClient(config)
-	rpcCLient, err := syslogClient.Client()
+	raw, err := rpcClient.Dispense("executor")
 	if err != nil {
-		return nil, nil, fmt.Errorf("error creating rpc client for syslog plugin: %v", err)
+		return nil, nil, fmt.Errorf("unable to dispense the executor plugin: %v", err)
 	}
-
-	raw, err := rpcCLient.Dispense("syslogcollector")
-	if err != nil {
-		return nil, nil, fmt.Errorf("unable to dispense the syslog plugin: %v", err)
-	}
-	logCollector := raw.(logging.LogCollector)
-	return logCollector, syslogClient, nil
+	executorPlugin := raw.(executor.Executor)
+	return executorPlugin, executorClient, nil
 }
 
 func consulContext(clientConfig *config.Config, containerID string) *executor.ConsulContext {

command/agent/agent.go

@@ -200,6 +200,7 @@ func (a *Agent) clientConfig() (*clientconfig.Config, error) {
 		conf.RPCHandler = a.server
 	}
 	conf.LogOutput = a.logOutput
+	conf.LogLevel = a.config.LogLevel
 	conf.DevMode = a.config.DevMode
 	if a.config.Region != "" {
 		conf.Region = a.config.Region

command/executor_plugin.go

@@ -1,12 +1,14 @@
 package command
 
 import (
+	"encoding/json"
 	"os"
 	"strings"
 
 	"github.com/hashicorp/go-plugin"
 
 	"github.com/hashicorp/nomad/client/driver"
+	dstructs "github.com/hashicorp/nomad/client/driver/structs"
 )
 
 type ExecutorPluginCommand struct {
@@ -25,19 +27,23 @@ func (e *ExecutorPluginCommand) Synopsis() string {
 }
 
 func (e *ExecutorPluginCommand) Run(args []string) int {
-	if len(args) == 0 {
-		e.Ui.Error("log output file isn't provided")
+	if len(args) != 1 {
+		e.Ui.Error("json configuration not provided")
 		return 1
 	}
-	logFileName := args[0]
-	stdo, err := os.OpenFile(logFileName, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)
+	config := args[0]
+	var executorConfig dstructs.ExecutorConfig
+	if err := json.Unmarshal([]byte(config), &executorConfig); err != nil {
+		return 1
+	}
+	stdo, err := os.OpenFile(executorConfig.LogFile, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)
 	if err != nil {
 		e.Ui.Error(err.Error())
 		return 1
 	}
 	plugin.Serve(&plugin.ServeConfig{
 		HandshakeConfig: driver.HandshakeConfig,
-		Plugins:         driver.GetPluginMap(stdo),
+		Plugins:         driver.GetPluginMap(stdo, executorConfig.LogLevel),
 	})
 	return 0
 }

command/syslog_plugin.go

@@ -1,44 +0,0 @@
-package command
-
-import (
-	"os"
-	"strings"
-
-	"github.com/hashicorp/go-plugin"
-
-	"github.com/hashicorp/nomad/client/driver"
-)
-
-type SyslogPluginCommand struct {
-	Meta
-}
-
-func (e *SyslogPluginCommand) Help() string {
-	helpText := `
-	This is a command used by Nomad internally to launch a syslog collector"
-	`
-	return strings.TrimSpace(helpText)
-}
-
-func (s *SyslogPluginCommand) Synopsis() string {
-	return "internal - lanch a syslog collector plugin"
-}
-
-func (s *SyslogPluginCommand) Run(args []string) int {
-	if len(args) == 0 {
-		s.Ui.Error("log output file isn't provided")
-		return 1
-	}
-	logFileName := args[0]
-	stdo, err := os.OpenFile(logFileName, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)
-	if err != nil {
-		s.Ui.Error(err.Error())
-		return 1
-	}
-	plugin.Serve(&plugin.ServeConfig{
-		HandshakeConfig: driver.HandshakeConfig,
-		Plugins:         driver.GetPluginMap(stdo),
-	})
-
-	return 0
-}

commands.go

@@ -126,11 +126,6 @@ func Commands(metaPtr *command.Meta) map[string]cli.CommandFactory {
 				Meta: meta,
 			}, nil
 		},
-		"syslog": func() (cli.Command, error) {
-			return &command.SyslogPluginCommand{
-				Meta: meta,
-			}, nil
-		},
 		"server-force-leave": func() (cli.Command, error) {
 			return &command.ServerForceLeaveCommand{
 				Meta: meta,