@@ -328,7 +328,7 @@ func (container *Container) StartLogger() (logger.Logger, error) {

 	if err != nil {

 		return nil, fmt.Errorf("failed to get logging factory: %v", err)

 	}

-	ctx := logger.Context{

+	info := logger.Info{

 		Config:              cfg.Config,

 		ContainerID:         container.ID,

 		ContainerName:       container.Name,

@@ -344,12 +344,12 @@ func (container *Container) StartLogger() (logger.Logger, error) {

 	// Set logging file for "json-logger"

 	if cfg.Type == jsonfilelog.Name {

-		ctx.LogPath, err = container.GetRootResourcePath(fmt.Sprintf("%s-json.log", container.ID))

+		info.LogPath, err = container.GetRootResourcePath(fmt.Sprintf("%s-json.log", container.ID))

 		if err != nil {

 			return nil, err

 		}

 	}

-	return c(ctx)

+	return c(info)

 }

 // GetProcessLabel returns the process label for the container.

@@ -88,17 +88,17 @@ func init() {

 // also taken from environment variables AWS_REGION, AWS_ACCESS_KEY_ID,

 // AWS_SECRET_ACCESS_KEY, the shared credentials file (~/.aws/credentials), and

 // the EC2 Instance Metadata Service.

-func New(ctx logger.Context) (logger.Logger, error) {

-	logGroupName := ctx.Config[logGroupKey]

-	logStreamName, err := loggerutils.ParseLogTag(ctx, "{{.FullID}}")

+func New(info logger.Info) (logger.Logger, error) {

+	logGroupName := info.Config[logGroupKey]

+	logStreamName, err := loggerutils.ParseLogTag(info, "{{.FullID}}")

 	if err != nil {

 		return nil, err

 	}

-	if ctx.Config[logStreamKey] != "" {

-		logStreamName = ctx.Config[logStreamKey]

+	if info.Config[logStreamKey] != "" {

+		logStreamName = info.Config[logStreamKey]

 	}

-	client, err := newAWSLogsClient(ctx)

+	client, err := newAWSLogsClient(info)

 	if err != nil {

 		return nil, err

 	}

@@ -127,13 +127,13 @@ var newRegionFinder = func() regionFinder {

 // Customizations to the default client from the SDK include a Docker-specific

 // User-Agent string and automatic region detection using the EC2 Instance

 // Metadata Service when region is otherwise unspecified.

-func newAWSLogsClient(ctx logger.Context) (api, error) {

+func newAWSLogsClient(info logger.Info) (api, error) {

 	var region *string

 	if os.Getenv(regionEnvKey) != "" {

 		region = aws.String(os.Getenv(regionEnvKey))

 	}

-	if ctx.Config[regionKey] != "" {

-		region = aws.String(ctx.Config[regionKey])

+	if info.Config[regionKey] != "" {

+		region = aws.String(info.Config[regionKey])

 	}

 	if region == nil || *region == "" {

 		logrus.Info("Trying to get region from EC2 Metadata")

@@ -28,13 +28,13 @@ const (

 )

 func TestNewAWSLogsClientUserAgentHandler(t *testing.T) {

-	ctx := logger.Context{

+	info := logger.Info{

 		Config: map[string]string{

 			regionKey: "us-east-1",

 		},

 	}

-	client, err := newAWSLogsClient(ctx)

+	client, err := newAWSLogsClient(info)

 	if err != nil {

 		t.Fatal(err)

 	}

@@ -59,7 +59,7 @@ func TestNewAWSLogsClientUserAgentHandler(t *testing.T) {

 }

 func TestNewAWSLogsClientRegionDetect(t *testing.T) {

-	ctx := logger.Context{

+	info := logger.Info{

 		Config: map[string]string{},

 	}

@@ -71,7 +71,7 @@ func TestNewAWSLogsClientRegionDetect(t *testing.T) {

 		successResult: "us-east-1",

 	}

-	_, err := newAWSLogsClient(ctx)

+	_, err := newAWSLogsClient(info)

 	if err != nil {

 		t.Fatal(err)

 	}

@@ -695,12 +695,12 @@ func TestCollectBatchWithDuplicateTimestamps(t *testing.T) {

 func TestCreateTagSuccess(t *testing.T) {

 	mockClient := newMockClient()

-	ctx := logger.Context{

+	info := logger.Info{

 		ContainerName: "/test-container",

 		ContainerID:   "container-abcdefghijklmnopqrstuvwxyz01234567890",

 		Config:        map[string]string{"tag": "{{.Name}}/{{.FullID}}"},

 	}

-	logStreamName, e := loggerutils.ParseLogTag(ctx, loggerutils.DefaultTemplate)

+	logStreamName, e := loggerutils.ParseLogTag(info, loggerutils.DefaultTemplate)

 	if e != nil {

 		t.Errorf("Error generating tag: %q", e)

 	}

deleted file mode 100644

@@ -1,111 +0,0 @@

-package logger

-

-import (

-	"fmt"

-	"os"

-	"strings"

-	"time"

-)

-

-// Context provides enough information for a logging driver to do its function.

-type Context struct {

-	Config              map[string]string

-	ContainerID         string

-	ContainerName       string

-	ContainerEntrypoint string

-	ContainerArgs       []string

-	ContainerImageID    string

-	ContainerImageName  string

-	ContainerCreated    time.Time

-	ContainerEnv        []string

-	ContainerLabels     map[string]string

-	LogPath             string

-	DaemonName          string

-}

-

-// ExtraAttributes returns the user-defined extra attributes (labels,

-// environment variables) in key-value format. This can be used by log drivers

-// that support metadata to add more context to a log.

-func (ctx *Context) ExtraAttributes(keyMod func(string) string) map[string]string {

-	extra := make(map[string]string)

-	labels, ok := ctx.Config["labels"]

-	if ok && len(labels) > 0 {

-		for _, l := range strings.Split(labels, ",") {

-			if v, ok := ctx.ContainerLabels[l]; ok {

-				if keyMod != nil {

-					l = keyMod(l)

-				}

-				extra[l] = v

-			}

-		}

-	}

-

-	env, ok := ctx.Config["env"]

-	if ok && len(env) > 0 {

-		envMapping := make(map[string]string)

-		for _, e := range ctx.ContainerEnv {

-			if kv := strings.SplitN(e, "=", 2); len(kv) == 2 {

-				envMapping[kv[0]] = kv[1]

-			}

-		}

-		for _, l := range strings.Split(env, ",") {

-			if v, ok := envMapping[l]; ok {

-				if keyMod != nil {

-					l = keyMod(l)

-				}

-				extra[l] = v

-			}

-		}

-	}

-

-	return extra

-}

-

-// Hostname returns the hostname from the underlying OS.

-func (ctx *Context) Hostname() (string, error) {

-	hostname, err := os.Hostname()

-	if err != nil {

-		return "", fmt.Errorf("logger: can not resolve hostname: %v", err)

-	}

-	return hostname, nil

-}

-

-// Command returns the command that the container being logged was

-// started with. The Entrypoint is prepended to the container

-// arguments.

-func (ctx *Context) Command() string {

-	terms := []string{ctx.ContainerEntrypoint}

-	terms = append(terms, ctx.ContainerArgs...)

-	command := strings.Join(terms, " ")

-	return command

-}

-

-// ID Returns the Container ID shortened to 12 characters.

-func (ctx *Context) ID() string {

-	return ctx.ContainerID[:12]

-}

-

-// FullID is an alias of ContainerID.

-func (ctx *Context) FullID() string {

-	return ctx.ContainerID

-}

-

-// Name returns the ContainerName without a preceding '/'.

-func (ctx *Context) Name() string {

-	return strings.TrimPrefix(ctx.ContainerName, "/")

-}

-

-// ImageID returns the ContainerImageID shortened to 12 characters.

-func (ctx *Context) ImageID() string {

-	return ctx.ContainerImageID[:12]

-}

-

-// ImageFullID is an alias of ContainerImageID.

-func (ctx *Context) ImageFullID() string {

-	return ctx.ContainerImageID

-}

-

-// ImageName is an alias of ContainerImageName

-func (ctx *Context) ImageName() string {

-	return ctx.ContainerImageName

-}

@@ -54,17 +54,17 @@ func init() {

 }

 // New creates a new etwLogs logger for the given container and registers the EWT provider.

-func New(ctx logger.Context) (logger.Logger, error) {

+func New(info logger.Info) (logger.Logger, error) {

 	if err := registerETWProvider(); err != nil {

 		return nil, err

 	}

-	logrus.Debugf("logging driver etwLogs configured for container: %s.", ctx.ContainerID)

+	logrus.Debugf("logging driver etwLogs configured for container: %s.", info.ContainerID)

 	return &etwLogs{

-		containerName: ctx.Name(),

-		imageName:     ctx.ContainerImageName,

-		containerID:   ctx.ContainerID,

-		imageID:       ctx.ContainerImageID,

+		containerName: info.Name(),

+		imageName:     info.ContainerImageName,

+		containerID:   info.ContainerID,

+		imageID:       info.ContainerImageID,

 	}, nil

 }

@@ -6,7 +6,7 @@ import (

 )

 // Creator builds a logging driver instance with given context.

-type Creator func(Context) (Logger, error)

+type Creator func(Info) (Logger, error)

 // LogOptValidator checks the options specific to the underlying

 // logging implementation.

@@ -67,22 +67,22 @@ func init() {

 // New creates a fluentd logger using the configuration passed in on

 // the context. The supported context configuration variable is

 // fluentd-address.

-func New(ctx logger.Context) (logger.Logger, error) {

-	loc, err := parseAddress(ctx.Config[addressKey])

+func New(info logger.Info) (logger.Logger, error) {

+	loc, err := parseAddress(info.Config[addressKey])

 	if err != nil {

 		return nil, err

 	}

-	tag, err := loggerutils.ParseLogTag(ctx, loggerutils.DefaultTemplate)

+	tag, err := loggerutils.ParseLogTag(info, loggerutils.DefaultTemplate)

 	if err != nil {

 		return nil, err

 	}

-	extra := ctx.ExtraAttributes(nil)

+	extra := info.ExtraAttributes(nil)

 	bufferLimit := defaultBufferLimit

-	if ctx.Config[bufferLimitKey] != "" {

-		bl64, err := units.RAMInBytes(ctx.Config[bufferLimitKey])

+	if info.Config[bufferLimitKey] != "" {

+		bl64, err := units.RAMInBytes(info.Config[bufferLimitKey])

 		if err != nil {

 			return nil, err

 		}

@@ -90,8 +90,8 @@ func New(ctx logger.Context) (logger.Logger, error) {

 	}

 	retryWait := defaultRetryWait

-	if ctx.Config[retryWaitKey] != "" {

-		rwd, err := time.ParseDuration(ctx.Config[retryWaitKey])

+	if info.Config[retryWaitKey] != "" {

+		rwd, err := time.ParseDuration(info.Config[retryWaitKey])

 		if err != nil {

 			return nil, err

 		}

@@ -99,8 +99,8 @@ func New(ctx logger.Context) (logger.Logger, error) {

 	}

 	maxRetries := defaultMaxRetries

-	if ctx.Config[maxRetriesKey] != "" {

-		mr64, err := strconv.ParseUint(ctx.Config[maxRetriesKey], 10, strconv.IntSize)

+	if info.Config[maxRetriesKey] != "" {

+		mr64, err := strconv.ParseUint(info.Config[maxRetriesKey], 10, strconv.IntSize)

 		if err != nil {

 			return nil, err

 		}

@@ -108,8 +108,8 @@ func New(ctx logger.Context) (logger.Logger, error) {

 	}

 	asyncConnect := false

-	if ctx.Config[asyncConnectKey] != "" {

-		if asyncConnect, err = strconv.ParseBool(ctx.Config[asyncConnectKey]); err != nil {

+	if info.Config[asyncConnectKey] != "" {

+		if asyncConnect, err = strconv.ParseBool(info.Config[asyncConnectKey]); err != nil {

 			return nil, err

 		}

 	}

@@ -125,7 +125,7 @@ func New(ctx logger.Context) (logger.Logger, error) {

 		AsyncConnect:     asyncConnect,

 	}

-	logrus.WithField("container", ctx.ContainerID).WithField("config", fluentConfig).

+	logrus.WithField("container", info.ContainerID).WithField("config", fluentConfig).

 		Debug("logging driver fluentd configured")

 	log, err := fluent.New(fluentConfig)

@@ -134,8 +134,8 @@ func New(ctx logger.Context) (logger.Logger, error) {

 	}

 	return &fluentd{

 		tag:           tag,

-		containerID:   ctx.ContainerID,

-		containerName: ctx.ContainerName,

+		containerID:   info.ContainerID,

+		containerName: info.ContainerName,

 		writer:        log,

 		extra:         extra,

 	}, nil

@@ -100,14 +100,14 @@ func initGCP() {

 // default credentials.

 //

 // See https://developers.google.com/identity/protocols/application-default-credentials

-func New(ctx logger.Context) (logger.Logger, error) {

+func New(info logger.Info) (logger.Logger, error) {

 	initGCP()

 	var project string

 	if projectID != "" {

 		project = projectID

 	}

-	if projectID, found := ctx.Config[projectOptKey]; found {

+	if projectID, found := info.Config[projectOptKey]; found {

 		project = projectID

 	}

 	if project == "" {

@@ -127,17 +127,17 @@ func New(ctx logger.Context) (logger.Logger, error) {

 	l := &gcplogs{

 		logger: lg,

 		container: &containerInfo{

-			Name:      ctx.ContainerName,

-			ID:        ctx.ContainerID,

-			ImageName: ctx.ContainerImageName,

-			ImageID:   ctx.ContainerImageID,

-			Created:   ctx.ContainerCreated,

-			Metadata:  ctx.ExtraAttributes(nil),

+			Name:      info.ContainerName,

+			ID:        info.ContainerID,

+			ImageName: info.ContainerImageName,

+			ImageID:   info.ContainerImageID,

+			Created:   info.ContainerCreated,

+			Metadata:  info.ExtraAttributes(nil),

 		},

 	}

-	if ctx.Config[logCmdKey] == "true" {

-		l.container.Command = ctx.Command()

+	if info.Config[logCmdKey] == "true" {

+		l.container.Command = info.Command()

 	}

 	if onGCE {

@@ -146,11 +146,11 @@ func New(ctx logger.Context) (logger.Logger, error) {

 			Name: instanceName,

 			ID:   instanceID,

 		}

-	} else if ctx.Config[logZoneKey] != "" || ctx.Config[logNameKey] != "" || ctx.Config[logIDKey] != "" {

+	} else if info.Config[logZoneKey] != "" || info.Config[logNameKey] != "" || info.Config[logIDKey] != "" {

 		l.instance = &instanceInfo{

-			Zone: ctx.Config[logZoneKey],

-			Name: ctx.Config[logNameKey],

-			ID:   ctx.Config[logIDKey],

+			Zone: info.Config[logZoneKey],

+			Name: info.Config[logNameKey],

+			ID:   info.Config[logIDKey],

 		}

 	}

@@ -24,7 +24,7 @@ const name = "gelf"

 type gelfLogger struct {

 	writer   *gelf.Writer

-	ctx      logger.Context

+	info     logger.Info

 	hostname string

 	rawExtra json.RawMessage

 }

@@ -40,36 +40,36 @@ func init() {

 // New creates a gelf logger using the configuration passed in on the

 // context. The supported context configuration variable is gelf-address.

-func New(ctx logger.Context) (logger.Logger, error) {

+func New(info logger.Info) (logger.Logger, error) {

 	// parse gelf address

-	address, err := parseAddress(ctx.Config["gelf-address"])

+	address, err := parseAddress(info.Config["gelf-address"])

 	if err != nil {

 		return nil, err

 	}

 	// collect extra data for GELF message

-	hostname, err := ctx.Hostname()

+	hostname, err := info.Hostname()

 	if err != nil {

 		return nil, fmt.Errorf("gelf: cannot access hostname to set source field")

 	}

 	// parse log tag

-	tag, err := loggerutils.ParseLogTag(ctx, loggerutils.DefaultTemplate)

+	tag, err := loggerutils.ParseLogTag(info, loggerutils.DefaultTemplate)

 	if err != nil {

 		return nil, err

 	}

 	extra := map[string]interface{}{

-		"_container_id":   ctx.ContainerID,

-		"_container_name": ctx.Name(),

-		"_image_id":       ctx.ContainerImageID,

-		"_image_name":     ctx.ContainerImageName,

-		"_command":        ctx.Command(),

+		"_container_id":   info.ContainerID,

+		"_container_name": info.Name(),

+		"_image_id":       info.ContainerImageID,

+		"_image_name":     info.ContainerImageName,

+		"_command":        info.Command(),

 		"_tag":            tag,

-		"_created":        ctx.ContainerCreated,

+		"_created":        info.ContainerCreated,

 	}

-	extraAttrs := ctx.ExtraAttributes(func(key string) string {

+	extraAttrs := info.ExtraAttributes(func(key string) string {

 		if key[0] == '_' {

 			return key

 		}

@@ -90,7 +90,7 @@ func New(ctx logger.Context) (logger.Logger, error) {

 		return nil, fmt.Errorf("gelf: cannot connect to GELF endpoint: %s %v", address, err)

 	}

-	if v, ok := ctx.Config["gelf-compression-type"]; ok {

+	if v, ok := info.Config["gelf-compression-type"]; ok {

 		switch v {

 		case "gzip":

 			gelfWriter.CompressionType = gelf.CompressGzip

@@ -103,7 +103,7 @@ func New(ctx logger.Context) (logger.Logger, error) {

 		}

 	}

-	if v, ok := ctx.Config["gelf-compression-level"]; ok {

+	if v, ok := info.Config["gelf-compression-level"]; ok {

 		val, err := strconv.Atoi(v)

 		if err != nil {

 			return nil, fmt.Errorf("gelf: invalid compression level %s, err %v", v, err)

@@ -113,7 +113,7 @@ func New(ctx logger.Context) (logger.Logger, error) {

 	return &gelfLogger{

 		writer:   gelfWriter,

-		ctx:      ctx,

+		info:     info,

 		hostname: hostname,

 		rawExtra: rawExtra,

 	}, nil

@@ -58,24 +58,24 @@ func sanitizeKeyMod(s string) string {

 // New creates a journald logger using the configuration passed in on

 // the context.

-func New(ctx logger.Context) (logger.Logger, error) {

+func New(info logger.Info) (logger.Logger, error) {

 	if !journal.Enabled() {

 		return nil, fmt.Errorf("journald is not enabled on this host")

 	}

 	// parse log tag

-	tag, err := loggerutils.ParseLogTag(ctx, loggerutils.DefaultTemplate)

+	tag, err := loggerutils.ParseLogTag(info, loggerutils.DefaultTemplate)

 	if err != nil {

 		return nil, err

 	}

 	vars := map[string]string{

-		"CONTAINER_ID":      ctx.ContainerID[:12],

-		"CONTAINER_ID_FULL": ctx.ContainerID,

-		"CONTAINER_NAME":    ctx.Name(),

+		"CONTAINER_ID":      info.ContainerID[:12],

+		"CONTAINER_ID_FULL": info.ContainerID,

+		"CONTAINER_NAME":    info.Name(),

 		"CONTAINER_TAG":     tag,

 	}

-	extraAttrs := ctx.ExtraAttributes(sanitizeKeyMod)

+	extraAttrs := info.ExtraAttributes(sanitizeKeyMod)

 	for k, v := range extraAttrs {

 		vars[k] = v

 	}

@@ -40,9 +40,9 @@ func init() {

 // New creates new JSONFileLogger which writes to filename passed in

 // on given context.

-func New(ctx logger.Context) (logger.Logger, error) {

+func New(info logger.Info) (logger.Logger, error) {

 	var capval int64 = -1

-	if capacity, ok := ctx.Config["max-size"]; ok {

+	if capacity, ok := info.Config["max-size"]; ok {

 		var err error

 		capval, err = units.FromHumanSize(capacity)

 		if err != nil {

@@ -50,7 +50,7 @@ func New(ctx logger.Context) (logger.Logger, error) {

 		}

 	}

 	var maxFiles = 1

-	if maxFileString, ok := ctx.Config["max-file"]; ok {

+	if maxFileString, ok := info.Config["max-file"]; ok {

 		var err error

 		maxFiles, err = strconv.Atoi(maxFileString)

 		if err != nil {

@@ -61,13 +61,13 @@ func New(ctx logger.Context) (logger.Logger, error) {

 		}

 	}

-	writer, err := loggerutils.NewRotateFileWriter(ctx.LogPath, capval, maxFiles)

+	writer, err := loggerutils.NewRotateFileWriter(info.LogPath, capval, maxFiles)

 	if err != nil {

 		return nil, err

 	}

 	var extra []byte

-	if attrs := ctx.ExtraAttributes(nil); len(attrs) > 0 {

+	if attrs := info.ExtraAttributes(nil); len(attrs) > 0 {

 		var err error

 		extra, err = json.Marshal(attrs)

 		if err != nil {

@@ -22,7 +22,7 @@ func TestJSONFileLogger(t *testing.T) {

 	}

 	defer os.RemoveAll(tmp)

 	filename := filepath.Join(tmp, "container.log")

-	l, err := New(logger.Context{

+	l, err := New(logger.Info{

 		ContainerID: cid,

 		LogPath:     filename,

 	})

@@ -62,7 +62,7 @@ func BenchmarkJSONFileLogger(b *testing.B) {

 	}

 	defer os.RemoveAll(tmp)

 	filename := filepath.Join(tmp, "container.log")

-	l, err := New(logger.Context{

+	l, err := New(logger.Info{

 		ContainerID: cid,

 		LogPath:     filename,

 	})

@@ -97,7 +97,7 @@ func TestJSONFileLoggerWithOpts(t *testing.T) {

 	defer os.RemoveAll(tmp)

 	filename := filepath.Join(tmp, "container.log")

 	config := map[string]string{"max-file": "2", "max-size": "1k"}

-	l, err := New(logger.Context{

+	l, err := New(logger.Info{

 		ContainerID: cid,

 		LogPath:     filename,

 		Config:      config,

@@ -161,7 +161,7 @@ func TestJSONFileLoggerWithLabelsEnv(t *testing.T) {

 	defer os.RemoveAll(tmp)

 	filename := filepath.Join(tmp, "container.log")

 	config := map[string]string{"labels": "rack,dc", "env": "environ,debug,ssl"}

-	l, err := New(logger.Context{

+	l, err := New(logger.Info{

 		ContainerID:     cid,

 		LogPath:         filename,

 		Config:          config,

@@ -210,7 +210,7 @@ func BenchmarkJSONFileLoggerWithReader(b *testing.B) {

 	}

 	defer os.RemoveAll(dir)

-	l, err := New(logger.Context{

+	l, err := New(logger.Info{

 		ContainerID: cid,

 		LogPath:     filepath.Join(dir, "container.log"),

 	})

@@ -35,18 +35,18 @@ func init() {

 // New creates a logentries logger using the configuration passed in on

 // the context. The supported context configuration variable is

 // logentries-token.

-func New(ctx logger.Context) (logger.Logger, error) {

-	logrus.WithField("container", ctx.ContainerID).

-		WithField("token", ctx.Config[token]).

+func New(info logger.Info) (logger.Logger, error) {

+	logrus.WithField("container", info.ContainerID).

+		WithField("token", info.Config[token]).

 		Debug("logging driver logentries configured")

-	log, err := le_go.Connect(ctx.Config[token])

+	log, err := le_go.Connect(info.Config[token])

 	if err != nil {

 		return nil, err

 	}

 	return &logentries{

-		containerID:   ctx.ContainerID,

-		containerName: ctx.ContainerName,

+		containerID:   info.ContainerID,

+		containerName: info.ContainerName,

 		writer:        log,

 	}, nil

 }

@@ -12,8 +12,8 @@ const DefaultTemplate = "{{.ID}}"

 // ParseLogTag generates a context aware tag for consistency across different

 // log drivers based on the context of the running container.

-func ParseLogTag(ctx logger.Context, defaultTemplate string) (string, error) {

-	tagTemplate := ctx.Config["tag"]

+func ParseLogTag(info logger.Info, defaultTemplate string) (string, error) {

+	tagTemplate := info.Config["tag"]

 	if tagTemplate == "" {

 		tagTemplate = defaultTemplate

 	}

@@ -23,7 +23,7 @@ func ParseLogTag(ctx logger.Context, defaultTemplate string) (string, error) {

 		return "", err

 	}

 	buf := new(bytes.Buffer)

-	if err := tmpl.Execute(buf, &ctx); err != nil {

+	if err := tmpl.Execute(buf, &info); err != nil {

 		return "", err

 	}

@@ -7,27 +7,27 @@ import (

 )

 func TestParseLogTagDefaultTag(t *testing.T) {

-	ctx := buildContext(map[string]string{})

-	tag, e := ParseLogTag(ctx, "{{.ID}}")

-	assertTag(t, e, tag, ctx.ID())

+	info := buildContext(map[string]string{})

+	tag, e := ParseLogTag(info, "{{.ID}}")

+	assertTag(t, e, tag, info.ID())

 }

 func TestParseLogTag(t *testing.T) {

-	ctx := buildContext(map[string]string{"tag": "{{.ImageName}}/{{.Name}}/{{.ID}}"})

-	tag, e := ParseLogTag(ctx, "{{.ID}}")

+	info := buildContext(map[string]string{"tag": "{{.ImageName}}/{{.Name}}/{{.ID}}"})

+	tag, e := ParseLogTag(info, "{{.ID}}")

 	assertTag(t, e, tag, "test-image/test-container/container-ab")

 }

 func TestParseLogTagEmptyTag(t *testing.T) {

-	ctx := buildContext(map[string]string{})

-	tag, e := ParseLogTag(ctx, "{{.DaemonName}}/{{.ID}}")

+	info := buildContext(map[string]string{})

+	tag, e := ParseLogTag(info, "{{.DaemonName}}/{{.ID}}")

 	assertTag(t, e, tag, "test-dockerd/container-ab")

 }

 // Helpers

-func buildContext(cfg map[string]string) logger.Context {

-	return logger.Context{

+func buildContext(cfg map[string]string) logger.Info {

+	return logger.Info{

 		ContainerID:        "container-abcdefghijklmnopqrstuvwxyz01234567890",

 		ContainerName:      "/test-container",

 		ContainerImageID:   "image-abcdefghijklmnopqrstuvwxyz01234567890",

new file mode 100644

@@ -0,0 +1,111 @@

+package logger

+

+import (

+	"fmt"

+	"os"

+	"strings"

+	"time"

+)

+

+// Info provides enough information for a logging driver to do its function.

+type Info struct {

+	Config              map[string]string

+	ContainerID         string

+	ContainerName       string

+	ContainerEntrypoint string

+	ContainerArgs       []string

+	ContainerImageID    string

+	ContainerImageName  string

+	ContainerCreated    time.Time

+	ContainerEnv        []string

+	ContainerLabels     map[string]string

+	LogPath             string

+	DaemonName          string

+}

+

+// ExtraAttributes returns the user-defined extra attributes (labels,

+// environment variables) in key-value format. This can be used by log drivers

+// that support metadata to add more context to a log.

+func (info *Info) ExtraAttributes(keyMod func(string) string) map[string]string {

+	extra := make(map[string]string)

+	labels, ok := info.Config["labels"]

+	if ok && len(labels) > 0 {

+		for _, l := range strings.Split(labels, ",") {

+			if v, ok := info.ContainerLabels[l]; ok {

+				if keyMod != nil {

+					l = keyMod(l)

+				}

+				extra[l] = v

+			}

+		}

+	}

+

+	env, ok := info.Config["env"]

+	if ok && len(env) > 0 {

+		envMapping := make(map[string]string)

+		for _, e := range info.ContainerEnv {

+			if kv := strings.SplitN(e, "=", 2); len(kv) == 2 {

+				envMapping[kv[0]] = kv[1]

+			}

+		}

+		for _, l := range strings.Split(env, ",") {

+			if v, ok := envMapping[l]; ok {

+				if keyMod != nil {

+					l = keyMod(l)

+				}

+				extra[l] = v

+			}

+		}

+	}

+

+	return extra

+}

+

+// Hostname returns the hostname from the underlying OS.

+func (info *Info) Hostname() (string, error) {

+	hostname, err := os.Hostname()

+	if err != nil {

+		return "", fmt.Errorf("logger: can not resolve hostname: %v", err)

+	}

+	return hostname, nil

+}

+

+// Command returns the command that the container being logged was

+// started with. The Entrypoint is prepended to the container

+// arguments.

+func (info *Info) Command() string {

+	terms := []string{info.ContainerEntrypoint}

+	terms = append(terms, info.ContainerArgs...)

+	command := strings.Join(terms, " ")

+	return command

+}

+

+// ID Returns the Container ID shortened to 12 characters.

+func (info *Info) ID() string {

+	return info.ContainerID[:12]

+}

+

+// FullID is an alias of ContainerID.

+func (info *Info) FullID() string {

+	return info.ContainerID

+}

+

+// Name returns the ContainerName without a preceding '/'.

+func (info *Info) Name() string {

+	return strings.TrimPrefix(info.ContainerName, "/")

+}

+

+// ImageID returns the ContainerImageID shortened to 12 characters.

+func (info *Info) ImageID() string {

+	return info.ContainerImageID[:12]

+}

+

+// ImageFullID is an alias of ContainerImageID.

+func (info *Info) ImageFullID() string {

+	return info.ContainerImageID

+}

+

+// ImageName is an alias of ContainerImageName

+func (info *Info) ImageName() string {

+	return info.ContainerImageName

+}

@@ -140,20 +140,20 @@ func init() {

 }

 // New creates splunk logger driver using configuration passed in context

-func New(ctx logger.Context) (logger.Logger, error) {

-	hostname, err := ctx.Hostname()

+func New(info logger.Info) (logger.Logger, error) {

+	hostname, err := info.Hostname()

 	if err != nil {

 		return nil, fmt.Errorf("%s: cannot access hostname to set source field", driverName)

 	}

 	// Parse and validate Splunk URL

-	splunkURL, err := parseURL(ctx)

+	splunkURL, err := parseURL(info)

 	if err != nil {

 		return nil, err

 	}

 	// Splunk Token is required parameter

-	splunkToken, ok := ctx.Config[splunkTokenKey]

+	splunkToken, ok := info.Config[splunkTokenKey]

 	if !ok {

 		return nil, fmt.Errorf("%s: %s is expected", driverName, splunkTokenKey)

 	}

@@ -162,7 +162,7 @@ func New(ctx logger.Context) (logger.Logger, error) {

 	// Splunk is using autogenerated certificates by default,

 	// allow users to trust them with skipping verification

-	if insecureSkipVerifyStr, ok := ctx.Config[splunkInsecureSkipVerifyKey]; ok {

+	if insecureSkipVerifyStr, ok := info.Config[splunkInsecureSkipVerifyKey]; ok {

 		insecureSkipVerify, err := strconv.ParseBool(insecureSkipVerifyStr)

 		if err != nil {

 			return nil, err

@@ -171,7 +171,7 @@ func New(ctx logger.Context) (logger.Logger, error) {

 	}

 	// If path to the root certificate is provided - load it

-	if caPath, ok := ctx.Config[splunkCAPathKey]; ok {

+	if caPath, ok := info.Config[splunkCAPathKey]; ok {

 		caCert, err := ioutil.ReadFile(caPath)

 		if err != nil {

 			return nil, err

@@ -181,12 +181,12 @@ func New(ctx logger.Context) (logger.Logger, error) {

 		tlsConfig.RootCAs = caPool

 	}

-	if caName, ok := ctx.Config[splunkCANameKey]; ok {

+	if caName, ok := info.Config[splunkCANameKey]; ok {

 		tlsConfig.ServerName = caName

 	}

 	gzipCompression := false

-	if gzipCompressionStr, ok := ctx.Config[splunkGzipCompressionKey]; ok {

+	if gzipCompressionStr, ok := info.Config[splunkGzipCompressionKey]; ok {

 		gzipCompression, err = strconv.ParseBool(gzipCompressionStr)

 		if err != nil {

 			return nil, err

@@ -194,7 +194,7 @@ func New(ctx logger.Context) (logger.Logger, error) {

 	}

 	gzipCompressionLevel := gzip.DefaultCompression

-	if gzipCompressionLevelStr, ok := ctx.Config[splunkGzipCompressionLevelKey]; ok {

+	if gzipCompressionLevelStr, ok := info.Config[splunkGzipCompressionLevelKey]; ok {

 		var err error

 		gzipCompressionLevel64, err := strconv.ParseInt(gzipCompressionLevelStr, 10, 32)

 		if err != nil {

@@ -215,9 +215,9 @@ func New(ctx logger.Context) (logger.Logger, error) {

 		Transport: transport,

 	}

-	source := ctx.Config[splunkSourceKey]

-	sourceType := ctx.Config[splunkSourceTypeKey]

-	index := ctx.Config[splunkIndexKey]

+	source := info.Config[splunkSourceKey]