@@ -1,11 +1,18 @@

 package client

 import (

+	"encoding/json"

+	"fmt"

+	"io"

+	"strings"

+	"time"

+

 	"github.com/docker/docker/api/types"

+	eventtypes "github.com/docker/docker/api/types/events"

 	"github.com/docker/docker/api/types/filters"

 	Cli "github.com/docker/docker/cli"

 	"github.com/docker/docker/opts"

-	"github.com/docker/docker/pkg/jsonmessage"

+	"github.com/docker/docker/pkg/jsonlog"

 	flag "github.com/docker/docker/pkg/mflag"

 )

@@ -46,5 +53,43 @@ func (cli *DockerCli) CmdEvents(args ...string) error {

 	}

 	defer responseBody.Close()

-	return jsonmessage.DisplayJSONMessagesStream(responseBody, cli.out, cli.outFd, cli.isTerminalOut)

+	return streamEvents(responseBody, cli.out)

+}

+

+// streamEvents decodes prints the incoming events in the provided output.

+func streamEvents(input io.Reader, output io.Writer) error {

+	dec := json.NewDecoder(input)

+	for {

+		var event eventtypes.Message

+		if err := dec.Decode(&event); err != nil {

+			if err == io.EOF {

+				break

+			}

+			return err

+		}

+		printOutput(event, output)

+	}

+	return nil

+}

+

+// printOutput prints all types of event information.

+// Each output includes the event type, actor id, name and action.

+// Actor attributes are printed at the end if the actor has any.

+func printOutput(event eventtypes.Message, output io.Writer) {

+	if event.TimeNano != 0 {

+		fmt.Fprintf(output, "%s ", time.Unix(0, event.TimeNano).Format(jsonlog.RFC3339NanoFixed))

+	} else if event.Time != 0 {

+		fmt.Fprintf(output, "%s ", time.Unix(event.Time, 0).Format(jsonlog.RFC3339NanoFixed))

+	}

+

+	fmt.Fprintf(output, "%s %s %s", event.Type, event.Action, event.Actor.ID)

+

+	if len(event.Actor.Attributes) > 0 {

+		var attrs []string

+		for k, v := range event.Actor.Attributes {

+			attrs = append(attrs, fmt.Sprintf("%s=%s", k, v))

+		}

+		fmt.Fprintf(output, " (%s)", strings.Join(attrs, ", "))

+	}

+	fmt.Fprint(output, "\n")

 }

@@ -2,8 +2,8 @@ package system

 import (

 	"github.com/docker/docker/api/types"

+	"github.com/docker/docker/api/types/events"

 	"github.com/docker/docker/api/types/filters"

-	"github.com/docker/docker/pkg/jsonmessage"

 )

 // Backend is the methods that need to be implemented to provide

@@ -11,7 +11,7 @@ import (

 type Backend interface {

 	SystemInfo() (*types.Info, error)

 	SystemVersion() types.Version

-	SubscribeToEvents(since, sinceNano int64, ef filters.Args) ([]*jsonmessage.JSONMessage, chan interface{})

+	SubscribeToEvents(since, sinceNano int64, ef filters.Args) ([]events.Message, chan interface{})

 	UnsubscribeFromEvents(chan interface{})

 	AuthenticateToRegistry(authConfig *types.AuthConfig) (string, error)

 }

@@ -9,10 +9,10 @@ import (

 	"github.com/docker/docker/api"

 	"github.com/docker/docker/api/server/httputils"

 	"github.com/docker/docker/api/types"

+	"github.com/docker/docker/api/types/events"

 	"github.com/docker/docker/api/types/filters"

 	timetypes "github.com/docker/docker/api/types/time"

 	"github.com/docker/docker/pkg/ioutils"

-	"github.com/docker/docker/pkg/jsonmessage"

 	"golang.org/x/net/context"

 )

@@ -98,8 +98,9 @@ func (s *systemRouter) getEvents(ctx context.Context, w http.ResponseWriter, r *

 	for {

 		select {

 		case ev := <-l:

-			jev, ok := ev.(*jsonmessage.JSONMessage)

+			jev, ok := ev.(events.Message)

 			if !ok {

+				logrus.Warnf("unexpected event message: %q", ev)

 				continue

 			}

 			if err := enc.Encode(jev); err != nil {

new file mode 100644

@@ -0,0 +1,38 @@

+package events

+

+const (

+	// ContainerEventType is the event type that containers generate

+	ContainerEventType = "container"

+	// ImageEventType is the event type that images generate

+	ImageEventType = "image"

+	// VolumeEventType is the event type that volumes generate

+	VolumeEventType = "volume"

+	// NetworkEventType is the event type that networks generate

+	NetworkEventType = "network"

+)

+

+// Actor describes something that generates events,

+// like a container, or a network, or a volume.

+// It has a defined name and a set or attributes.

+// The container attributes are its labels, other actors

+// can generate these attributes from other properties.

+type Actor struct {

+	ID         string

+	Attributes map[string]string

+}

+

+// Message represents the information an event contains

+type Message struct {

+	// Deprecated information from JSONMessage.

+	// With data only in container events.

+	Status string `json:"status,omitempty"`

+	ID     string `json:"id,omitempty"`

+	From   string `json:"from,omitempty"`

+

+	Type   string

+	Action string

+	Actor  Actor

+

+	Time     int64 `json:"time,omitempty"`

+	TimeNano int64 `json:"timeNano,omitempty"`

+}

@@ -197,6 +197,22 @@ func (filters Args) ExactMatch(field, source string) bool {

 	return false

 }

+// FuzzyMatch returns true if the source matches exactly one of the filters,

+// or the source has one of the filters as a prefix.

+func (filters Args) FuzzyMatch(field, source string) bool {

+	if filters.ExactMatch(field, source) {

+		return true

+	}

+

+	fieldValues := filters.fields[field]

+	for prefix := range fieldValues {

+		if strings.HasPrefix(source, prefix) {

+			return true

+		}

+	}

+	return false

+}

+

 // Include returns true if the name of the field to filter is in the filters.

 func (filters Args) Include(field string) bool {

 	_, ok := filters.fields[field]

@@ -349,3 +349,21 @@ func TestWalkValues(t *testing.T) {

 		t.Fatalf("Expected to not iterate when the field doesn't exist, got %v", err)

 	}

 }

+

+func TestFuzzyMatch(t *testing.T) {

+	f := NewArgs()

+	f.Add("container", "foo")

+

+	cases := map[string]bool{

+		"foo":    true,

+		"foobar": true,

+		"barfoo": false,

+		"bar":    false,

+	}

+	for source, match := range cases {

+		got := f.FuzzyMatch("container", source)

+		if got != match {

+			t.Fatalf("Expected %v, got %v: %s", match, got, source)

+		}

+	}

+}

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

 	"github.com/docker/docker/api"

 	"github.com/docker/docker/api/types"

 	containertypes "github.com/docker/docker/api/types/container"

+	eventtypes "github.com/docker/docker/api/types/events"

 	"github.com/docker/docker/api/types/filters"

 	registrytypes "github.com/docker/docker/api/types/registry"

 	"github.com/docker/docker/api/types/strslice"

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

 	"github.com/docker/docker/pkg/fileutils"

 	"github.com/docker/docker/pkg/graphdb"

 	"github.com/docker/docker/pkg/idtools"

-	"github.com/docker/docker/pkg/jsonmessage"

 	"github.com/docker/docker/pkg/mount"

 	"github.com/docker/docker/pkg/namesgenerator"

 	"github.com/docker/docker/pkg/progress"

@@ -554,23 +554,9 @@ func (daemon *Daemon) GetByName(name string) (*container.Container, error) {

 	return e, nil

 }

-// getEventFilter returns a filters.Filter for a set of filters

-func (daemon *Daemon) getEventFilter(filter filters.Args) *events.Filter {

-	// incoming container filter can be name, id or partial id, convert to

-	// a full container id

-	for _, cn := range filter.Get("container") {

-		c, err := daemon.GetContainer(cn)

-		filter.Del("container", cn)

-		if err == nil {

-			filter.Add("container", c.ID)

-		}

-	}

-	return events.NewFilter(filter, daemon.GetLabels)

-}

-

 // SubscribeToEvents returns the currently record of events, a channel to stream new events from, and a function to cancel the stream of events.

-func (daemon *Daemon) SubscribeToEvents(since, sinceNano int64, filter filters.Args) ([]*jsonmessage.JSONMessage, chan interface{}) {

-	ef := daemon.getEventFilter(filter)

+func (daemon *Daemon) SubscribeToEvents(since, sinceNano int64, filter filters.Args) ([]eventtypes.Message, chan interface{}) {

+	ef := events.NewFilter(filter)

 	return daemon.EventsService.SubscribeTopic(since, sinceNano, ef)

 }

@@ -580,21 +566,6 @@ func (daemon *Daemon) UnsubscribeFromEvents(listener chan interface{}) {

 	daemon.EventsService.Evict(listener)

 }

-// GetLabels for a container or image id

-func (daemon *Daemon) GetLabels(id string) map[string]string {

-	// TODO: TestCase

-	container := daemon.containers.Get(id)

-	if container != nil {

-		return container.Config.Labels

-	}

-

-	img, err := daemon.GetImage(id)

-	if err == nil {

-		return img.ContainerConfig.Labels

-	}

-	return nil

-}

-

 // children returns all child containers of the container with the

 // given name. The containers are returned as a map from the container

 // name to a pointer to Container.

@@ -1032,7 +1003,8 @@ func (daemon *Daemon) TagImage(newTag reference.Named, imageName string) error {

 	if err := daemon.referenceStore.AddTag(newTag, imageID, true); err != nil {

 		return err

 	}

-	daemon.EventsService.Log("tag", newTag.String(), "")

+

+	daemon.LogImageEvent(imageID.String(), newTag.String(), "tag")

 	return nil

 }

@@ -1068,15 +1040,15 @@ func (daemon *Daemon) PullImage(ref reference.Named, metaHeaders map[string][]st

 	}()

 	imagePullConfig := &distribution.ImagePullConfig{

-		MetaHeaders:     metaHeaders,

-		AuthConfig:      authConfig,

-		ProgressOutput:  progress.ChanOutput(progressChan),

-		RegistryService: daemon.RegistryService,

-		EventsService:   daemon.EventsService,

-		MetadataStore:   daemon.distributionMetadataStore,

-		ImageStore:      daemon.imageStore,

-		ReferenceStore:  daemon.referenceStore,

-		DownloadManager: daemon.downloadManager,

+		MetaHeaders:      metaHeaders,

+		AuthConfig:       authConfig,

+		ProgressOutput:   progress.ChanOutput(progressChan),

+		RegistryService:  daemon.RegistryService,

+		ImageEventLogger: daemon.LogImageEvent,

+		MetadataStore:    daemon.distributionMetadataStore,

+		ImageStore:       daemon.imageStore,

+		ReferenceStore:   daemon.referenceStore,

+		DownloadManager:  daemon.downloadManager,

 	}

 	err := distribution.Pull(ctx, ref, imagePullConfig)

@@ -1111,17 +1083,17 @@ func (daemon *Daemon) PushImage(ref reference.Named, metaHeaders map[string][]st

 	}()

 	imagePushConfig := &distribution.ImagePushConfig{

-		MetaHeaders:     metaHeaders,

-		AuthConfig:      authConfig,

-		ProgressOutput:  progress.ChanOutput(progressChan),

-		RegistryService: daemon.RegistryService,

-		EventsService:   daemon.EventsService,

-		MetadataStore:   daemon.distributionMetadataStore,

-		LayerStore:      daemon.layerStore,

-		ImageStore:      daemon.imageStore,

-		ReferenceStore:  daemon.referenceStore,

-		TrustKey:        daemon.trustKey,

-		UploadManager:   daemon.uploadManager,

+		MetaHeaders:      metaHeaders,

+		AuthConfig:       authConfig,

+		ProgressOutput:   progress.ChanOutput(progressChan),

+		RegistryService:  daemon.RegistryService,

+		ImageEventLogger: daemon.LogImageEvent,

+		MetadataStore:    daemon.distributionMetadataStore,

+		LayerStore:       daemon.layerStore,

+		ImageStore:       daemon.imageStore,

+		ReferenceStore:   daemon.referenceStore,

+		TrustKey:         daemon.trustKey,

+		UploadManager:    daemon.uploadManager,

 	}

 	err := distribution.Push(ctx, ref, imagePushConfig)

@@ -1,14 +1,82 @@

 package daemon

 import (

+	"strings"

+

+	"github.com/docker/docker/api/types/events"

 	"github.com/docker/docker/container"

+	"github.com/docker/libnetwork"

 )

 // LogContainerEvent generates an event related to a container.

 func (daemon *Daemon) LogContainerEvent(container *container.Container, action string) {

-	daemon.EventsService.Log(

-		action,

-		container.ID,

-		container.Config.Image,

-	)

+	attributes := copyAttributes(container.Config.Labels)

+	if container.Config.Image != "" {

+		attributes["image"] = container.Config.Image

+	}

+	attributes["name"] = strings.TrimLeft(container.Name, "/")

+

+	actor := events.Actor{

+		ID:         container.ID,

+		Attributes: attributes,

+	}

+	daemon.EventsService.Log(action, events.ContainerEventType, actor)

+}

+

+// LogImageEvent generates an event related to a container.

+func (daemon *Daemon) LogImageEvent(imageID, refName, action string) {

+	attributes := map[string]string{}

+	img, err := daemon.GetImage(imageID)

+	if err == nil && img.Config != nil {

+		// image has not been removed yet.

+		// it could be missing if the event is `delete`.

+		attributes = copyAttributes(img.Config.Labels)

+	}

+	if refName != "" {

+		attributes["name"] = refName

+	}

+	actor := events.Actor{

+		ID:         imageID,

+		Attributes: attributes,

+	}

+

+	daemon.EventsService.Log(action, events.ImageEventType, actor)

+}

+

+// LogVolumeEvent generates an event related to a volume.

+func (daemon *Daemon) LogVolumeEvent(volumeID, action string, attributes map[string]string) {

+	actor := events.Actor{

+		ID:         volumeID,

+		Attributes: attributes,

+	}

+	daemon.EventsService.Log(action, events.VolumeEventType, actor)

+}

+

+// LogNetworkEvent generates an event related to a network with only the default attributes.

+func (daemon *Daemon) LogNetworkEvent(nw libnetwork.Network, action string) {

+	daemon.LogNetworkEventWithAttributes(nw, action, map[string]string{})

+}

+

+// LogNetworkEventWithAttributes generates an event related to a network with specific given attributes.

+func (daemon *Daemon) LogNetworkEventWithAttributes(nw libnetwork.Network, action string, attributes map[string]string) {

+	attributes["name"] = nw.Name()

+	attributes["type"] = nw.Type()

+

+	actor := events.Actor{

+		ID:         nw.ID(),

+		Attributes: attributes,

+	}

+	daemon.EventsService.Log(action, events.NetworkEventType, actor)

+}

+

+// copyAttributes guarantees that labels are not mutated by event triggers.

+func copyAttributes(labels map[string]string) map[string]string {

+	attributes := map[string]string{}

+	if labels == nil {

+		return attributes

+	}

+	for k, v := range labels {

+		attributes[k] = v

+	}

+	return attributes

 }

@@ -4,7 +4,7 @@ import (

 	"sync"

 	"time"

-	"github.com/docker/docker/pkg/jsonmessage"

+	eventtypes "github.com/docker/docker/api/types/events"

 	"github.com/docker/docker/pkg/pubsub"

 )

@@ -13,17 +13,17 @@ const (

 	bufferSize  = 1024

 )

-// Events is pubsub channel for *jsonmessage.JSONMessage

+// Events is pubsub channel for events generated by the engine.

 type Events struct {

 	mu     sync.Mutex

-	events []*jsonmessage.JSONMessage

+	events []eventtypes.Message

 	pub    *pubsub.Publisher

 }

 // New returns new *Events instance

 func New() *Events {

 	return &Events{

-		events: make([]*jsonmessage.JSONMessage, 0, eventsLimit),

+		events: make([]eventtypes.Message, 0, eventsLimit),

 		pub:    pubsub.NewPublisher(100*time.Millisecond, bufferSize),

 	}

 }

@@ -32,9 +32,9 @@ func New() *Events {

 // last events, a channel in which you can expect new events (in form

 // of interface{}, so you need type assertion), and a function to call

 // to stop the stream of events.

-func (e *Events) Subscribe() ([]*jsonmessage.JSONMessage, chan interface{}, func()) {

+func (e *Events) Subscribe() ([]eventtypes.Message, chan interface{}, func()) {

 	e.mu.Lock()

-	current := make([]*jsonmessage.JSONMessage, len(e.events))

+	current := make([]eventtypes.Message, len(e.events))

 	copy(current, e.events)

 	l := e.pub.Subscribe()

 	e.mu.Unlock()

@@ -48,13 +48,13 @@ func (e *Events) Subscribe() ([]*jsonmessage.JSONMessage, chan interface{}, func

 // SubscribeTopic adds new listener to events, returns slice of 64 stored

 // last events, a channel in which you can expect new events (in form

 // of interface{}, so you need type assertion).

-func (e *Events) SubscribeTopic(since, sinceNano int64, ef *Filter) ([]*jsonmessage.JSONMessage, chan interface{}) {

+func (e *Events) SubscribeTopic(since, sinceNano int64, ef *Filter) ([]eventtypes.Message, chan interface{}) {

 	e.mu.Lock()

 	defer e.mu.Unlock()

-	var buffered []*jsonmessage.JSONMessage

+	var buffered []eventtypes.Message

 	topic := func(m interface{}) bool {

-		return ef.Include(m.(*jsonmessage.JSONMessage))

+		return ef.Include(m.(eventtypes.Message))

 	}

 	if since != -1 {

@@ -64,7 +64,7 @@ func (e *Events) SubscribeTopic(since, sinceNano int64, ef *Filter) ([]*jsonmess

 				break

 			}

 			if ef.filter.Len() == 0 || topic(ev) {

-				buffered = append([]*jsonmessage.JSONMessage{ev}, buffered...)

+				buffered = append([]eventtypes.Message{ev}, buffered...)

 			}

 		}

 	}

@@ -87,9 +87,27 @@ func (e *Events) Evict(l chan interface{}) {

 // Log broadcasts event to listeners. Each listener has 100 millisecond for

 // receiving event or it will be skipped.

-func (e *Events) Log(action, id, from string) {

+func (e *Events) Log(action, eventType string, actor eventtypes.Actor) {

 	now := time.Now().UTC()

-	jm := &jsonmessage.JSONMessage{Status: action, ID: id, From: from, Time: now.Unix(), TimeNano: now.UnixNano()}

+	jm := eventtypes.Message{

+		Action:   action,

+		Type:     eventType,

+		Actor:    actor,

+		Time:     now.Unix(),

+		TimeNano: now.UnixNano(),

+	}

+

+	// fill deprecated fields for container and images

+	switch eventType {

+	case eventtypes.ContainerEventType:

+		jm.ID = actor.ID

+		jm.Status = action

+		jm.From = actor.Attributes["image"]

+	case eventtypes.ImageEventType:

+		jm.ID = actor.ID

+		jm.Status = action

+	}

+

 	e.mu.Lock()

 	if len(e.events) == cap(e.events) {

 		// discard oldest event

@@ -5,7 +5,7 @@ import (

 	"testing"

 	"time"

-	"github.com/docker/docker/pkg/jsonmessage"

+	"github.com/docker/docker/api/types/events"

 )

 func TestEventsLog(t *testing.T) {

@@ -18,10 +18,14 @@ func TestEventsLog(t *testing.T) {

 	if count != 2 {

 		t.Fatalf("Must be 2 subscribers, got %d", count)

 	}

-	e.Log("test", "cont", "image")

+	actor := events.Actor{

+		ID:         "cont",

+		Attributes: map[string]string{"image": "image"},

+	}

+	e.Log("test", events.ContainerEventType, actor)

 	select {

 	case msg := <-l1:

-		jmsg, ok := msg.(*jsonmessage.JSONMessage)

+		jmsg, ok := msg.(events.Message)

 		if !ok {

 			t.Fatalf("Unexpected type %T", msg)

 		}

@@ -42,7 +46,7 @@ func TestEventsLog(t *testing.T) {

 	}

 	select {

 	case msg := <-l2:

-		jmsg, ok := msg.(*jsonmessage.JSONMessage)

+		jmsg, ok := msg.(events.Message)

 		if !ok {

 			t.Fatalf("Unexpected type %T", msg)

 		}

@@ -70,7 +74,10 @@ func TestEventsLogTimeout(t *testing.T) {

 	c := make(chan struct{})

 	go func() {

-		e.Log("test", "cont", "image")

+		actor := events.Actor{

+			ID: "image",

+		}

+		e.Log("test", events.ImageEventType, actor)

 		close(c)

 	}()

@@ -88,7 +95,12 @@ func TestLogEvents(t *testing.T) {

 		action := fmt.Sprintf("action_%d", i)

 		id := fmt.Sprintf("cont_%d", i)

 		from := fmt.Sprintf("image_%d", i)

-		e.Log(action, id, from)

+

+		actor := events.Actor{

+			ID:         id,

+			Attributes: map[string]string{"image": from},

+		}

+		e.Log(action, events.ContainerEventType, actor)

 	}

 	time.Sleep(50 * time.Millisecond)

 	current, l, _ := e.Subscribe()

@@ -97,16 +109,21 @@ func TestLogEvents(t *testing.T) {

 		action := fmt.Sprintf("action_%d", num)

 		id := fmt.Sprintf("cont_%d", num)

 		from := fmt.Sprintf("image_%d", num)

-		e.Log(action, id, from)

+

+		actor := events.Actor{

+			ID:         id,

+			Attributes: map[string]string{"image": from},

+		}

+		e.Log(action, events.ContainerEventType, actor)

 	}

 	if len(e.events) != eventsLimit {

 		t.Fatalf("Must be %d events, got %d", eventsLimit, len(e.events))

 	}

-	var msgs []*jsonmessage.JSONMessage

+	var msgs []events.Message

 	for len(msgs) < 10 {

 		m := <-l

-		jm, ok := (m).(*jsonmessage.JSONMessage)

+		jm, ok := (m).(events.Message)

 		if !ok {

 			t.Fatalf("Unexpected type %T", m)

 		}

@@ -1,46 +1,58 @@

 package events

 import (

+	"github.com/docker/docker/api/types/events"

 	"github.com/docker/docker/api/types/filters"

-	"github.com/docker/docker/pkg/jsonmessage"

 	"github.com/docker/docker/reference"

 )

 // Filter can filter out docker events from a stream

 type Filter struct {

-	filter    filters.Args

-	getLabels func(id string) map[string]string

+	filter filters.Args

 }

 // NewFilter creates a new Filter

-func NewFilter(filter filters.Args, getLabels func(id string) map[string]string) *Filter {

-	return &Filter{filter: filter, getLabels: getLabels}

+func NewFilter(filter filters.Args) *Filter {

+	return &Filter{filter: filter}

 }

 // Include returns true when the event ev is included by the filters

-func (ef *Filter) Include(ev *jsonmessage.JSONMessage) bool {

-	return ef.filter.ExactMatch("event", ev.Status) &&

-		ef.filter.ExactMatch("container", ev.ID) &&

-		ef.isImageIncluded(ev.ID, ev.From) &&

-		ef.isLabelFieldIncluded(ev.ID)

+func (ef *Filter) Include(ev events.Message) bool {

+	if ev.Type != events.ContainerEventType && ev.Type != events.ImageEventType {

+		return false

+	}

+	return ef.filter.ExactMatch("event", ev.Action) &&

+		ef.matchContainer(ev) &&

+		ef.isImageIncluded(ev) &&

+		ef.isLabelFieldIncluded(ev.Actor.Attributes)

 }

-func (ef *Filter) isLabelFieldIncluded(id string) bool {

+func (ef *Filter) isLabelFieldIncluded(attributes map[string]string) bool {

 	if !ef.filter.Include("label") {

 		return true

 	}

-	return ef.filter.MatchKVList("label", ef.getLabels(id))

+	return ef.filter.MatchKVList("label", attributes)

+}

+

+func (ef *Filter) matchContainer(ev events.Message) bool {

+	return ef.filter.FuzzyMatch("container", ev.Actor.ID) ||

+		ef.filter.FuzzyMatch("container", ev.Actor.Attributes["name"])

 }

 // The image filter will be matched against both event.ID (for image events)

 // and event.From (for container events), so that any container that was created

 // from an image will be included in the image events. Also compare both

 // against the stripped repo name without any tags.

-func (ef *Filter) isImageIncluded(eventID string, eventFrom string) bool {

-	return ef.filter.ExactMatch("image", eventID) ||

-		ef.filter.ExactMatch("image", eventFrom) ||

-		ef.filter.ExactMatch("image", stripTag(eventID)) ||

-		ef.filter.ExactMatch("image", stripTag(eventFrom))

+func (ef *Filter) isImageIncluded(ev events.Message) bool {

+	id := ev.ID

+	var imageName string

+	if n, ok := ev.Actor.Attributes["image"]; ok {

+		imageName = n

+	}

+	return ef.filter.ExactMatch("image", id) ||

+		ef.filter.ExactMatch("image", imageName) ||

+		ef.filter.ExactMatch("image", stripTag(id)) ||

+		ef.filter.ExactMatch("image", stripTag(imageName))

 }

 func stripTag(image string) string {

new file mode 100644

@@ -0,0 +1,36 @@

+package daemon

+

+import (

+	"testing"

+

+	containertypes "github.com/docker/docker/api/types/container"

+	"github.com/docker/docker/container"

+	"github.com/docker/docker/daemon/events"

+)

+

+func TestLogContainerCopyLabels(t *testing.T) {

+	e := events.New()

+	_, l, _ := e.Subscribe()

+	defer e.Evict(l)

+

+	container := &container.Container{

+		CommonContainer: container.CommonContainer{

+			ID:   "container_id",

+			Name: "container_name",

+			Config: &containertypes.Config{

+				Labels: map[string]string{

+					"node": "1",

+					"os":   "alpine",

+				},

+			},

+		},

+	}

+	daemon := &Daemon{

+		EventsService: e,

+	}

+	daemon.LogContainerEvent(container, "create")

+

+	if _, mutated := container.Config.Labels["image"]; mutated {

+		t.Fatalf("Expected to not mutate the container labels, got %q", container.Config.Labels)

+	}

+}

@@ -87,7 +87,7 @@ func (daemon *Daemon) ImageDelete(imageRef string, force, prune bool) ([]types.I

 		untaggedRecord := types.ImageDelete{Untagged: parsedRef.String()}

-		daemon.EventsService.Log("untag", imgID.String(), "")

+		daemon.LogImageEvent(imgID.String(), imgID.String(), "untag")

 		records = append(records, untaggedRecord)

 		// If has remaining references then untag finishes the remove

@@ -109,7 +109,7 @@ func (daemon *Daemon) ImageDelete(imageRef string, force, prune bool) ([]types.I

 			untaggedRecord := types.ImageDelete{Untagged: parsedRef.String()}

-			daemon.EventsService.Log("untag", imgID.String(), "")

+			daemon.LogImageEvent(imgID.String(), imgID.String(), "untag")

 			records = append(records, untaggedRecord)

 		}

 	}

@@ -174,7 +174,7 @@ func (daemon *Daemon) removeAllReferencesToImageID(imgID image.ID, records *[]ty

 		untaggedRecord := types.ImageDelete{Untagged: parsedRef.String()}

-		daemon.EventsService.Log("untag", imgID.String(), "")

+		daemon.LogImageEvent(imgID.String(), imgID.String(), "untag")

 		*records = append(*records, untaggedRecord)

 	}

@@ -243,7 +243,7 @@ func (daemon *Daemon) imageDeleteHelper(imgID image.ID, records *[]types.ImageDe

 		return err

 	}

-	daemon.EventsService.Log("delete", imgID.String(), "")

+	daemon.LogImageEvent(imgID.String(), imgID.String(), "delete")

 	*records = append(*records, types.ImageDelete{Deleted: imgID.String()})

 	for _, removedLayer := range removedLayers {

 		*records = append(*records, types.ImageDelete{Deleted: removedLayer.ChainID.String()})

@@ -97,7 +97,7 @@ func (daemon *Daemon) ImportImage(src string, newRef reference.Named, msg string

 		}

 	}

-	daemon.EventsService.Log("import", id.String(), "")

+	daemon.LogImageEvent(id.String(), id.String(), "import")

 	outStream.Write(sf.FormatStatus("", id.String()))

 	return nil

 }

@@ -54,5 +54,7 @@ func (daemon *Daemon) update(name string, hostConfig *container.HostConfig) erro

 		}

 	}

+	daemon.LogContainerEvent(container, "update")

+

 	return nil

 }

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

 	"github.com/Sirupsen/logrus"

 	"github.com/docker/docker/api/types"

-	"github.com/docker/docker/daemon/events"

 	"github.com/docker/docker/distribution/metadata"

 	"github.com/docker/docker/distribution/xfer"

 	"github.com/docker/docker/image"

@@ -31,8 +30,8 @@ type ImagePullConfig struct {

 	// RegistryService is the registry service to use for TLS configuration

 	// and endpoint lookup.

 	RegistryService *registry.Service

-	// EventsService is the events service to use for logging.

-	EventsService *events.Events

+	// ImageEventLogger notifies events for a given image

+	ImageEventLogger func(id, name, action string)

 	// MetadataStore is the storage backend for distribution-specific

 	// metadata.

 	MetadataStore metadata.Store

@@ -160,7 +159,7 @@ func Pull(ctx context.Context, ref reference.Named, imagePullConfig *ImagePullCo

 			}

 		}

-		imagePullConfig.EventsService.Log("pull", ref.String(), "")

+		imagePullConfig.ImageEventLogger(ref.String(), repoInfo.Name(), "pull")

 		return nil

 	}

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

 	"github.com/Sirupsen/logrus"

 	"github.com/docker/distribution/digest"

 	"github.com/docker/docker/api/types"

-	"github.com/docker/docker/daemon/events"

 	"github.com/docker/docker/distribution/metadata"

 	"github.com/docker/docker/distribution/xfer"

 	"github.com/docker/docker/image"

@@ -35,8 +34,8 @@ type ImagePushConfig struct {

 	// RegistryService is the registry service to use for TLS configuration

 	// and endpoint lookup.

 	RegistryService *registry.Service

-	// EventsService is the events service to use for logging.

-	EventsService *events.Events

+	// ImageEventLogger notifies events for a given image

+	ImageEventLogger func(id, name, action string)

 	// MetadataStore is the storage backend for distribution-specific

 	// metadata.

 	MetadataStore metadata.Store

@@ -156,7 +155,7 @@ func Push(ctx context.Context, ref reference.Named, imagePushConfig *ImagePushCo

 			return err

 		}

-		imagePushConfig.EventsService.Log("push", repoInfo.Name(), "")

+		imagePushConfig.ImageEventLogger(ref.String(), repoInfo.Name(), "push")

 		return nil

 	}

@@ -1,10 +1,16 @@

 package main

 import (

+	"encoding/json"

+	"io"

 	"net/http"

+	"net/url"

+	"strconv"

+	"strings"

 	"time"

 	"github.com/docker/docker/pkg/integration/checker"

+	"github.com/docker/docker/pkg/jsonmessage"

 	"github.com/go-check/check"

 )

@@ -28,3 +34,40 @@ func (s *DockerSuite) TestEventsApiEmptyOutput(c *check.C) {

 		c.Fatal("timeout waiting for events api to respond, should have responded immediately")

 	}

 }

+

+func (s *DockerSuite) TestEventsApiBackwardsCompatible(c *check.C) {

+	since := daemonTime(c).Unix()

+	ts := strconv.FormatInt(since, 10)

+

+	out, _ := dockerCmd(c, "run", "--name=foo", "-d", "busybox", "top")

+	containerID := strings.TrimSpace(out)

+	c.Assert(waitRun(containerID), checker.IsNil)

+

+	q := url.Values{}

+	q.Set("since", ts)

+

+	_, body, err := sockRequestRaw("GET", "/events?"+q.Encode(), nil, "")

+	c.Assert(err, checker.IsNil)

+	defer body.Close()

+

+	dec := json.NewDecoder(body)

+	var containerCreateEvent *jsonmessage.JSONMessage

+	for {

+		var event jsonmessage.JSONMessage

+		if err := dec.Decode(&event); err != nil {

+			if err == io.EOF {

+				break

+			}

+			c.Fatal(err)

+		}

+		if event.Status == "create" && event.ID == containerID {

+			containerCreateEvent = &event

+			break

+		}