diff --git a/doc/index.html b/doc/index.html
index fd0764d4..f64bd5bf 100644
--- a/doc/index.html
+++ b/doc/index.html
@@ -1945,6 +1945,41 @@ <h2>Table of Contents</h2>
           </li>
         
           
+          <li>
+            <a href="#metalstack%2finfra%2fv2%2fevent.proto">metalstack/infra/v2/event.proto</a>
+            <ul>
+              
+                <li>
+                  <a href="#metalstack.infra.v2.EventServiceSendRequest"><span class="badge">M</span>EventServiceSendRequest</a>
+                </li>
+              
+                <li>
+                  <a href="#metalstack.infra.v2.EventServiceSendRequest.EventsEntry"><span class="badge">M</span>EventServiceSendRequest.EventsEntry</a>
+                </li>
+              
+                <li>
+                  <a href="#metalstack.infra.v2.EventServiceSendResponse"><span class="badge">M</span>EventServiceSendResponse</a>
+                </li>
+              
+                <li>
+                  <a href="#metalstack.infra.v2.MachineProvisioningEvent"><span class="badge">M</span>MachineProvisioningEvent</a>
+                </li>
+              
+              
+                <li>
+                  <a href="#metalstack.infra.v2.ProvisioningEventType"><span class="badge">E</span>ProvisioningEventType</a>
+                </li>
+              
+              
+              
+                <li>
+                  <a href="#metalstack.infra.v2.EventService"><span class="badge">S</span>EventService</a>
+                </li>
+              
+            </ul>
+          </li>
+        
+          
           <li>
             <a href="#metalstack%2finfra%2fv2%2fswitch.proto">metalstack/infra/v2/switch.proto</a>
             <ul>
@@ -15317,6 +15352,246 @@ <h3 id="metalstack.infra.v2.BMCService">BMCService</h3>
         
     
       
+      <div class="file-heading">
+        <h2 id="metalstack/infra/v2/event.proto">metalstack/infra/v2/event.proto</h2><a href="#title">Top</a>
+      </div>
+      <p></p>
+
+      
+        <h3 id="metalstack.infra.v2.EventServiceSendRequest">EventServiceSendRequest</h3>
+        <p>EventServiceSendRequest.</p>
+
+        
+          <table class="field-table">
+            <thead>
+              <tr><td>Field</td><td>Type</td><td>Label</td><td>Description</td></tr>
+            </thead>
+            <tbody>
+              
+                <tr>
+                  <td>events</td>
+                  <td><a href="#metalstack.infra.v2.EventServiceSendRequest.EventsEntry">EventServiceSendRequest.EventsEntry</a></td>
+                  <td>repeated</td>
+                  <td><p>Events grouped by machine IDs. </p></td>
+                </tr>
+              
+            </tbody>
+          </table>
+
+          
+
+        
+      
+        <h3 id="metalstack.infra.v2.EventServiceSendRequest.EventsEntry">EventServiceSendRequest.EventsEntry</h3>
+        <p></p>
+
+        
+          <table class="field-table">
+            <thead>
+              <tr><td>Field</td><td>Type</td><td>Label</td><td>Description</td></tr>
+            </thead>
+            <tbody>
+              
+                <tr>
+                  <td>key</td>
+                  <td><a href="#string">string</a></td>
+                  <td></td>
+                  <td><p> </p></td>
+                </tr>
+              
+                <tr>
+                  <td>value</td>
+                  <td><a href="#metalstack.infra.v2.MachineProvisioningEvent">MachineProvisioningEvent</a></td>
+                  <td></td>
+                  <td><p> </p></td>
+                </tr>
+              
+            </tbody>
+          </table>
+
+          
+
+        
+      
+        <h3 id="metalstack.infra.v2.EventServiceSendResponse">EventServiceSendResponse</h3>
+        <p>EventServiceSendResponse.</p>
+
+        
+          <table class="field-table">
+            <thead>
+              <tr><td>Field</td><td>Type</td><td>Label</td><td>Description</td></tr>
+            </thead>
+            <tbody>
+              
+                <tr>
+                  <td>events</td>
+                  <td><a href="#uint64">uint64</a></td>
+                  <td></td>
+                  <td><p>Events counts the number of events successfully stored in the database. </p></td>
+                </tr>
+              
+                <tr>
+                  <td>failed</td>
+                  <td><a href="#string">string</a></td>
+                  <td>repeated</td>
+                  <td><p>Failed contains IDs of all machines whose events could not be stored in the database. </p></td>
+                </tr>
+              
+            </tbody>
+          </table>
+
+          
+
+        
+      
+        <h3 id="metalstack.infra.v2.MachineProvisioningEvent">MachineProvisioningEvent</h3>
+        <p>MachineProvisioningEvent contains details about an event.</p>
+
+        
+          <table class="field-table">
+            <thead>
+              <tr><td>Field</td><td>Type</td><td>Label</td><td>Description</td></tr>
+            </thead>
+            <tbody>
+              
+                <tr>
+                  <td>time</td>
+                  <td><a href="#google.protobuf.Timestamp">google.protobuf.Timestamp</a></td>
+                  <td></td>
+                  <td><p>Time the event occurred at. </p></td>
+                </tr>
+              
+                <tr>
+                  <td>event</td>
+                  <td><a href="#metalstack.infra.v2.ProvisioningEventType">ProvisioningEventType</a></td>
+                  <td></td>
+                  <td><p>Event that occurred. </p></td>
+                </tr>
+              
+                <tr>
+                  <td>message</td>
+                  <td><a href="#string">string</a></td>
+                  <td></td>
+                  <td><p>Message describing the event in more detail. </p></td>
+                </tr>
+              
+            </tbody>
+          </table>
+
+          
+
+        
+      
+
+      
+        <h3 id="metalstack.infra.v2.ProvisioningEventType">ProvisioningEventType</h3>
+        <p>ProvisioningEventType is a short description of a machine event.</p>
+        <table class="enum-table">
+          <thead>
+            <tr><td>Name</td><td>Number</td><td>Description</td></tr>
+          </thead>
+          <tbody>
+            
+              <tr>
+                <td>PROVISIONING_EVENT_TYPE_UNSPECIFIED</td>
+                <td>0</td>
+                <td><p>PROVISIONING_EVENT_TYPE_UNSPECIFIED is unspecified.</p></td>
+              </tr>
+            
+              <tr>
+                <td>PROVISIONING_EVENT_TYPE_ALIVE</td>
+                <td>1</td>
+                <td><p>PROVISIONING_EVENT_TYPE_ALIVE means the machine has reported itself to the API not long ago.</p></td>
+              </tr>
+            
+              <tr>
+                <td>PROVISIONING_EVENT_TYPE_CRASHED</td>
+                <td>2</td>
+                <td><p>PROVISIONING_EVENT_TYPE_CRASHED means an irregularity in the machine&#39;s lifecycle.</p></td>
+              </tr>
+            
+              <tr>
+                <td>PROVISIONING_EVENT_TYPE_PXE_BOOTING</td>
+                <td>3</td>
+                <td><p>PROVISIONING_EVENT_TYPE_PXE_BOOTING is sent when an unprovisioned machine requests a boot image via PXE.</p></td>
+              </tr>
+            
+              <tr>
+                <td>PROVISIONING_EVENT_TYPE_PLANNED_REBOOT</td>
+                <td>4</td>
+                <td><p>PROVISIONING_EVENT_TYPE_PLANNED_REBOOT means the machine was scheduled for reboot.</p></td>
+              </tr>
+            
+              <tr>
+                <td>PROVISIONING_EVENT_TYPE_PREPARING</td>
+                <td>5</td>
+                <td><p>PROVISIONING_EVENT_TYPE_PREPARING means the metal-hammer has started.</p></td>
+              </tr>
+            
+              <tr>
+                <td>PROVISIONING_EVENT_TYPE_REGISTERING</td>
+                <td>6</td>
+                <td><p>PROVISIONING_EVENT_TYPE_REGISTERING means the metal-hammer is attempting to register the machine at the API.</p></td>
+              </tr>
+            
+              <tr>
+                <td>PROVISIONING_EVENT_TYPE_WAITING</td>
+                <td>7</td>
+                <td><p>PROVISIONING_EVENT_TYPE_WAITING means the machine has successfully reached the state where it is waiting for allocation.</p></td>
+              </tr>
+            
+              <tr>
+                <td>PROVISIONING_EVENT_TYPE_INSTALLING</td>
+                <td>8</td>
+                <td><p>PROVISIONING_EVENT_TYPE_INSTALLING means the machine was allocated and the requested OS is being installed.</p></td>
+              </tr>
+            
+              <tr>
+                <td>PROVISIONING_EVENT_TYPE_BOOTING_NEW_KERNEL</td>
+                <td>9</td>
+                <td><p>PROVISIONING_EVENT_TYPE_BOOTING_NEW_KERNEL means the machine has successfully been installed and is now booting into the new OS.</p></td>
+              </tr>
+            
+              <tr>
+                <td>PROVISIONING_EVENT_TYPE_PHONED_HOME</td>
+                <td>10</td>
+                <td><p>PROVISIONING_EVENT_TYPE_PHONED_HOME is sent periodically by an allocated machine to indicate its liveliness.</p></td>
+              </tr>
+            
+              <tr>
+                <td>PROVISIONING_EVENT_TYPE_MACHINE_RECLAIM</td>
+                <td>11</td>
+                <td><p>PROVISIONING_EVENT_TYPE_MACHINE_RECLAIM means the machine was freed and is about to return into the pool of waiting machines.</p></td>
+              </tr>
+            
+          </tbody>
+        </table>
+      
+
+      
+
+      
+        <h3 id="metalstack.infra.v2.EventService">EventService</h3>
+        <p>EventService serves event related functions.</p>
+        <table class="enum-table">
+          <thead>
+            <tr><td>Method Name</td><td>Request Type</td><td>Response Type</td><td>Description</td></tr>
+          </thead>
+          <tbody>
+            
+              <tr>
+                <td>Send</td>
+                <td><a href="#metalstack.infra.v2.EventServiceSendRequest">EventServiceSendRequest</a></td>
+                <td><a href="#metalstack.infra.v2.EventServiceSendResponse">EventServiceSendResponse</a></td>
+                <td><p>Send a series of machine provisioning events.</p></td>
+              </tr>
+            
+          </tbody>
+        </table>
+
+        
+    
+      
       <div class="file-heading">
         <h2 id="metalstack/infra/v2/switch.proto">metalstack/infra/v2/switch.proto</h2><a href="#title">Top</a>
       </div>
diff --git a/go/client/client.go b/go/client/client.go
index 47ccc67d..a28cb156 100755
--- a/go/client/client.go
+++ b/go/client/client.go
@@ -90,11 +90,13 @@ type (
 
 	Infrav2 interface {
 		BMC() infrav2connect.BMCServiceClient
+		Event() infrav2connect.EventServiceClient
 		Switch() infrav2connect.SwitchServiceClient
 	}
 
 	infrav2 struct {
 		bmcservice    infrav2connect.BMCServiceClient
+		eventservice  infrav2connect.EventServiceClient
 		switchservice infrav2connect.SwitchServiceClient
 	}
 )
@@ -389,6 +391,12 @@ func (c *client) Infrav2() Infrav2 {
 			connect.WithInterceptors(c.interceptors...),
 			compress.WithAll(compress.LevelBalanced),
 		),
+		eventservice: infrav2connect.NewEventServiceClient(
+			c.config.HttpClient(),
+			c.config.BaseURL,
+			connect.WithInterceptors(c.interceptors...),
+			compress.WithAll(compress.LevelBalanced),
+		),
 		switchservice: infrav2connect.NewSwitchServiceClient(
 			c.config.HttpClient(),
 			c.config.BaseURL,
@@ -402,6 +410,9 @@ func (c *client) Infrav2() Infrav2 {
 func (c *infrav2) BMC() infrav2connect.BMCServiceClient {
 	return c.bmcservice
 }
+func (c *infrav2) Event() infrav2connect.EventServiceClient {
+	return c.eventservice
+}
 func (c *infrav2) Switch() infrav2connect.SwitchServiceClient {
 	return c.switchservice
 }
diff --git a/go/metalstack/infra/v2/event.pb.go b/go/metalstack/infra/v2/event.pb.go
new file mode 100644
index 00000000..90118aeb
--- /dev/null
+++ b/go/metalstack/infra/v2/event.pb.go
@@ -0,0 +1,377 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.10
+// 	protoc        (unknown)
+// source: metalstack/infra/v2/event.proto
+
+package infrav2
+
+import (
+	_ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate"
+	_ "github.com/metal-stack/api/go/metalstack/api/v2"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+	reflect "reflect"
+	sync "sync"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// ProvisioningEventType is a short description of a machine event.
+type ProvisioningEventType int32
+
+const (
+	// PROVISIONING_EVENT_TYPE_UNSPECIFIED is unspecified.
+	ProvisioningEventType_PROVISIONING_EVENT_TYPE_UNSPECIFIED ProvisioningEventType = 0
+	// PROVISIONING_EVENT_TYPE_ALIVE means the machine has reported itself to the API not long ago.
+	ProvisioningEventType_PROVISIONING_EVENT_TYPE_ALIVE ProvisioningEventType = 1
+	// PROVISIONING_EVENT_TYPE_CRASHED means an irregularity in the machine's lifecycle.
+	ProvisioningEventType_PROVISIONING_EVENT_TYPE_CRASHED ProvisioningEventType = 2
+	// PROVISIONING_EVENT_TYPE_PXE_BOOTING is sent when an unprovisioned machine requests a boot image via PXE.
+	ProvisioningEventType_PROVISIONING_EVENT_TYPE_PXE_BOOTING ProvisioningEventType = 3
+	// PROVISIONING_EVENT_TYPE_PLANNED_REBOOT means the machine was scheduled for reboot.
+	ProvisioningEventType_PROVISIONING_EVENT_TYPE_PLANNED_REBOOT ProvisioningEventType = 4
+	// PROVISIONING_EVENT_TYPE_PREPARING means the metal-hammer has started.
+	ProvisioningEventType_PROVISIONING_EVENT_TYPE_PREPARING ProvisioningEventType = 5
+	// PROVISIONING_EVENT_TYPE_REGISTERING means the metal-hammer is attempting to register the machine at the API.
+	ProvisioningEventType_PROVISIONING_EVENT_TYPE_REGISTERING ProvisioningEventType = 6
+	// PROVISIONING_EVENT_TYPE_WAITING means the machine has successfully reached the state where it is waiting for allocation.
+	ProvisioningEventType_PROVISIONING_EVENT_TYPE_WAITING ProvisioningEventType = 7
+	// PROVISIONING_EVENT_TYPE_INSTALLING means the machine was allocated and the requested OS is being installed.
+	ProvisioningEventType_PROVISIONING_EVENT_TYPE_INSTALLING ProvisioningEventType = 8
+	// PROVISIONING_EVENT_TYPE_BOOTING_NEW_KERNEL means the machine has successfully been installed and is now booting into the new OS.
+	ProvisioningEventType_PROVISIONING_EVENT_TYPE_BOOTING_NEW_KERNEL ProvisioningEventType = 9
+	// PROVISIONING_EVENT_TYPE_PHONED_HOME is sent periodically by an allocated machine to indicate its liveliness.
+	ProvisioningEventType_PROVISIONING_EVENT_TYPE_PHONED_HOME ProvisioningEventType = 10
+	// PROVISIONING_EVENT_TYPE_MACHINE_RECLAIM means the machine was freed and is about to return into the pool of waiting machines.
+	ProvisioningEventType_PROVISIONING_EVENT_TYPE_MACHINE_RECLAIM ProvisioningEventType = 11
+)
+
+// Enum value maps for ProvisioningEventType.
+var (
+	ProvisioningEventType_name = map[int32]string{
+		0:  "PROVISIONING_EVENT_TYPE_UNSPECIFIED",
+		1:  "PROVISIONING_EVENT_TYPE_ALIVE",
+		2:  "PROVISIONING_EVENT_TYPE_CRASHED",
+		3:  "PROVISIONING_EVENT_TYPE_PXE_BOOTING",
+		4:  "PROVISIONING_EVENT_TYPE_PLANNED_REBOOT",
+		5:  "PROVISIONING_EVENT_TYPE_PREPARING",
+		6:  "PROVISIONING_EVENT_TYPE_REGISTERING",
+		7:  "PROVISIONING_EVENT_TYPE_WAITING",
+		8:  "PROVISIONING_EVENT_TYPE_INSTALLING",
+		9:  "PROVISIONING_EVENT_TYPE_BOOTING_NEW_KERNEL",
+		10: "PROVISIONING_EVENT_TYPE_PHONED_HOME",
+		11: "PROVISIONING_EVENT_TYPE_MACHINE_RECLAIM",
+	}
+	ProvisioningEventType_value = map[string]int32{
+		"PROVISIONING_EVENT_TYPE_UNSPECIFIED":        0,
+		"PROVISIONING_EVENT_TYPE_ALIVE":              1,
+		"PROVISIONING_EVENT_TYPE_CRASHED":            2,
+		"PROVISIONING_EVENT_TYPE_PXE_BOOTING":        3,
+		"PROVISIONING_EVENT_TYPE_PLANNED_REBOOT":     4,
+		"PROVISIONING_EVENT_TYPE_PREPARING":          5,
+		"PROVISIONING_EVENT_TYPE_REGISTERING":        6,
+		"PROVISIONING_EVENT_TYPE_WAITING":            7,
+		"PROVISIONING_EVENT_TYPE_INSTALLING":         8,
+		"PROVISIONING_EVENT_TYPE_BOOTING_NEW_KERNEL": 9,
+		"PROVISIONING_EVENT_TYPE_PHONED_HOME":        10,
+		"PROVISIONING_EVENT_TYPE_MACHINE_RECLAIM":    11,
+	}
+)
+
+func (x ProvisioningEventType) Enum() *ProvisioningEventType {
+	p := new(ProvisioningEventType)
+	*p = x
+	return p
+}
+
+func (x ProvisioningEventType) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (ProvisioningEventType) Descriptor() protoreflect.EnumDescriptor {
+	return file_metalstack_infra_v2_event_proto_enumTypes[0].Descriptor()
+}
+
+func (ProvisioningEventType) Type() protoreflect.EnumType {
+	return &file_metalstack_infra_v2_event_proto_enumTypes[0]
+}
+
+func (x ProvisioningEventType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use ProvisioningEventType.Descriptor instead.
+func (ProvisioningEventType) EnumDescriptor() ([]byte, []int) {
+	return file_metalstack_infra_v2_event_proto_rawDescGZIP(), []int{0}
+}
+
+// EventServiceSendRequest.
+type EventServiceSendRequest struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// Events grouped by machine IDs.
+	Events        map[string]*MachineProvisioningEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *EventServiceSendRequest) Reset() {
+	*x = EventServiceSendRequest{}
+	mi := &file_metalstack_infra_v2_event_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *EventServiceSendRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EventServiceSendRequest) ProtoMessage() {}
+
+func (x *EventServiceSendRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_metalstack_infra_v2_event_proto_msgTypes[0]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use EventServiceSendRequest.ProtoReflect.Descriptor instead.
+func (*EventServiceSendRequest) Descriptor() ([]byte, []int) {
+	return file_metalstack_infra_v2_event_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *EventServiceSendRequest) GetEvents() map[string]*MachineProvisioningEvent {
+	if x != nil {
+		return x.Events
+	}
+	return nil
+}
+
+// EventServiceSendResponse.
+type EventServiceSendResponse struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// Events counts the number of events successfully stored in the database.
+	Events uint64 `protobuf:"varint,1,opt,name=events,proto3" json:"events,omitempty"`
+	// Failed contains IDs of all machines whose events could not be stored in the database.
+	Failed        []string `protobuf:"bytes,2,rep,name=failed,proto3" json:"failed,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *EventServiceSendResponse) Reset() {
+	*x = EventServiceSendResponse{}
+	mi := &file_metalstack_infra_v2_event_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *EventServiceSendResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EventServiceSendResponse) ProtoMessage() {}
+
+func (x *EventServiceSendResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_metalstack_infra_v2_event_proto_msgTypes[1]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use EventServiceSendResponse.ProtoReflect.Descriptor instead.
+func (*EventServiceSendResponse) Descriptor() ([]byte, []int) {
+	return file_metalstack_infra_v2_event_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *EventServiceSendResponse) GetEvents() uint64 {
+	if x != nil {
+		return x.Events
+	}
+	return 0
+}
+
+func (x *EventServiceSendResponse) GetFailed() []string {
+	if x != nil {
+		return x.Failed
+	}
+	return nil
+}
+
+// MachineProvisioningEvent contains details about an event.
+type MachineProvisioningEvent struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// Time the event occurred at.
+	Time *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"`
+	// Event that occurred.
+	Event ProvisioningEventType `protobuf:"varint,2,opt,name=event,proto3,enum=metalstack.infra.v2.ProvisioningEventType" json:"event,omitempty"`
+	// Message describing the event in more detail.
+	Message       string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *MachineProvisioningEvent) Reset() {
+	*x = MachineProvisioningEvent{}
+	mi := &file_metalstack_infra_v2_event_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *MachineProvisioningEvent) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MachineProvisioningEvent) ProtoMessage() {}
+
+func (x *MachineProvisioningEvent) ProtoReflect() protoreflect.Message {
+	mi := &file_metalstack_infra_v2_event_proto_msgTypes[2]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MachineProvisioningEvent.ProtoReflect.Descriptor instead.
+func (*MachineProvisioningEvent) Descriptor() ([]byte, []int) {
+	return file_metalstack_infra_v2_event_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *MachineProvisioningEvent) GetTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.Time
+	}
+	return nil
+}
+
+func (x *MachineProvisioningEvent) GetEvent() ProvisioningEventType {
+	if x != nil {
+		return x.Event
+	}
+	return ProvisioningEventType_PROVISIONING_EVENT_TYPE_UNSPECIFIED
+}
+
+func (x *MachineProvisioningEvent) GetMessage() string {
+	if x != nil {
+		return x.Message
+	}
+	return ""
+}
+
+var File_metalstack_infra_v2_event_proto protoreflect.FileDescriptor
+
+const file_metalstack_infra_v2_event_proto_rawDesc = "" +
+	"\n" +
+	"\x1fmetalstack/infra/v2/event.proto\x12\x13metalstack.infra.v2\x1a\x1bbuf/validate/validate.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1emetalstack/api/v2/common.proto\"\xd5\x01\n" +
+	"\x17EventServiceSendRequest\x12P\n" +
+	"\x06events\x18\x01 \x03(\v28.metalstack.infra.v2.EventServiceSendRequest.EventsEntryR\x06events\x1ah\n" +
+	"\vEventsEntry\x12\x10\n" +
+	"\x03key\x18\x01 \x01(\tR\x03key\x12C\n" +
+	"\x05value\x18\x02 \x01(\v2-.metalstack.infra.v2.MachineProvisioningEventR\x05value:\x028\x01\"J\n" +
+	"\x18EventServiceSendResponse\x12\x16\n" +
+	"\x06events\x18\x01 \x01(\x04R\x06events\x12\x16\n" +
+	"\x06failed\x18\x02 \x03(\tR\x06failed\"\xb0\x01\n" +
+	"\x18MachineProvisioningEvent\x12.\n" +
+	"\x04time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\x04time\x12J\n" +
+	"\x05event\x18\x02 \x01(\x0e2*.metalstack.infra.v2.ProvisioningEventTypeB\b\xbaH\x05\x82\x01\x02\x10\x01R\x05event\x12\x18\n" +
+	"\amessage\x18\x03 \x01(\tR\amessage*\xb8\x05\n" +
+	"\x15ProvisioningEventType\x12'\n" +
+	"#PROVISIONING_EVENT_TYPE_UNSPECIFIED\x10\x00\x12,\n" +
+	"\x1dPROVISIONING_EVENT_TYPE_ALIVE\x10\x01\x1a\t\x82\xb2\x19\x05Alive\x120\n" +
+	"\x1fPROVISIONING_EVENT_TYPE_CRASHED\x10\x02\x1a\v\x82\xb2\x19\aCrashed\x128\n" +
+	"#PROVISIONING_EVENT_TYPE_PXE_BOOTING\x10\x03\x1a\x0f\x82\xb2\x19\vPXE Booting\x12>\n" +
+	"&PROVISIONING_EVENT_TYPE_PLANNED_REBOOT\x10\x04\x1a\x12\x82\xb2\x19\x0ePlanned Reboot\x124\n" +
+	"!PROVISIONING_EVENT_TYPE_PREPARING\x10\x05\x1a\r\x82\xb2\x19\tPreparing\x128\n" +
+	"#PROVISIONING_EVENT_TYPE_REGISTERING\x10\x06\x1a\x0f\x82\xb2\x19\vRegistering\x120\n" +
+	"\x1fPROVISIONING_EVENT_TYPE_WAITING\x10\a\x1a\v\x82\xb2\x19\aWaiting\x126\n" +
+	"\"PROVISIONING_EVENT_TYPE_INSTALLING\x10\b\x1a\x0e\x82\xb2\x19\n" +
+	"Installing\x12F\n" +
+	"*PROVISIONING_EVENT_TYPE_BOOTING_NEW_KERNEL\x10\t\x1a\x16\x82\xb2\x19\x12Booting New Kernel\x128\n" +
+	"#PROVISIONING_EVENT_TYPE_PHONED_HOME\x10\n" +
+	"\x1a\x0f\x82\xb2\x19\vPhoned Home\x12@\n" +
+	"'PROVISIONING_EVENT_TYPE_MACHINE_RECLAIM\x10\v\x1a\x13\x82\xb2\x19\x0fMachine Reclaim2~\n" +
+	"\fEventService\x12n\n" +
+	"\x04Send\x12,.metalstack.infra.v2.EventServiceSendRequest\x1a-.metalstack.infra.v2.EventServiceSendResponse\"\t\xe0\xf3\x18\x02\xea\xf3\x18\x01\x01B\xce\x01\n" +
+	"\x17com.metalstack.infra.v2B\n" +
+	"EventProtoP\x01Z9github.com/metal-stack/api/go/metalstack/infra/v2;infrav2\xa2\x02\x03MIX\xaa\x02\x13Metalstack.Infra.V2\xca\x02\x13Metalstack\\Infra\\V2\xe2\x02\x1fMetalstack\\Infra\\V2\\GPBMetadata\xea\x02\x15Metalstack::Infra::V2b\x06proto3"
+
+var (
+	file_metalstack_infra_v2_event_proto_rawDescOnce sync.Once
+	file_metalstack_infra_v2_event_proto_rawDescData []byte
+)
+
+func file_metalstack_infra_v2_event_proto_rawDescGZIP() []byte {
+	file_metalstack_infra_v2_event_proto_rawDescOnce.Do(func() {
+		file_metalstack_infra_v2_event_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_metalstack_infra_v2_event_proto_rawDesc), len(file_metalstack_infra_v2_event_proto_rawDesc)))
+	})
+	return file_metalstack_infra_v2_event_proto_rawDescData
+}
+
+var file_metalstack_infra_v2_event_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_metalstack_infra_v2_event_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
+var file_metalstack_infra_v2_event_proto_goTypes = []any{
+	(ProvisioningEventType)(0),       // 0: metalstack.infra.v2.ProvisioningEventType
+	(*EventServiceSendRequest)(nil),  // 1: metalstack.infra.v2.EventServiceSendRequest
+	(*EventServiceSendResponse)(nil), // 2: metalstack.infra.v2.EventServiceSendResponse
+	(*MachineProvisioningEvent)(nil), // 3: metalstack.infra.v2.MachineProvisioningEvent
+	nil,                              // 4: metalstack.infra.v2.EventServiceSendRequest.EventsEntry
+	(*timestamppb.Timestamp)(nil),    // 5: google.protobuf.Timestamp
+}
+var file_metalstack_infra_v2_event_proto_depIdxs = []int32{
+	4, // 0: metalstack.infra.v2.EventServiceSendRequest.events:type_name -> metalstack.infra.v2.EventServiceSendRequest.EventsEntry
+	5, // 1: metalstack.infra.v2.MachineProvisioningEvent.time:type_name -> google.protobuf.Timestamp
+	0, // 2: metalstack.infra.v2.MachineProvisioningEvent.event:type_name -> metalstack.infra.v2.ProvisioningEventType
+	3, // 3: metalstack.infra.v2.EventServiceSendRequest.EventsEntry.value:type_name -> metalstack.infra.v2.MachineProvisioningEvent
+	1, // 4: metalstack.infra.v2.EventService.Send:input_type -> metalstack.infra.v2.EventServiceSendRequest
+	2, // 5: metalstack.infra.v2.EventService.Send:output_type -> metalstack.infra.v2.EventServiceSendResponse
+	5, // [5:6] is the sub-list for method output_type
+	4, // [4:5] is the sub-list for method input_type
+	4, // [4:4] is the sub-list for extension type_name
+	4, // [4:4] is the sub-list for extension extendee
+	0, // [0:4] is the sub-list for field type_name
+}
+
+func init() { file_metalstack_infra_v2_event_proto_init() }
+func file_metalstack_infra_v2_event_proto_init() {
+	if File_metalstack_infra_v2_event_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_metalstack_infra_v2_event_proto_rawDesc), len(file_metalstack_infra_v2_event_proto_rawDesc)),
+			NumEnums:      1,
+			NumMessages:   4,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_metalstack_infra_v2_event_proto_goTypes,
+		DependencyIndexes: file_metalstack_infra_v2_event_proto_depIdxs,
+		EnumInfos:         file_metalstack_infra_v2_event_proto_enumTypes,
+		MessageInfos:      file_metalstack_infra_v2_event_proto_msgTypes,
+	}.Build()
+	File_metalstack_infra_v2_event_proto = out.File
+	file_metalstack_infra_v2_event_proto_goTypes = nil
+	file_metalstack_infra_v2_event_proto_depIdxs = nil
+}
diff --git a/go/metalstack/infra/v2/infrav2connect/event.connect.go b/go/metalstack/infra/v2/infrav2connect/event.connect.go
new file mode 100644
index 00000000..2deb182e
--- /dev/null
+++ b/go/metalstack/infra/v2/infrav2connect/event.connect.go
@@ -0,0 +1,114 @@
+// Code generated by protoc-gen-connect-go. DO NOT EDIT.
+//
+// Source: metalstack/infra/v2/event.proto
+
+package infrav2connect
+
+import (
+	connect "connectrpc.com/connect"
+	context "context"
+	errors "errors"
+	v2 "github.com/metal-stack/api/go/metalstack/infra/v2"
+	http "net/http"
+	strings "strings"
+)
+
+// This is a compile-time assertion to ensure that this generated file and the connect package are
+// compatible. If you get a compiler error that this constant is not defined, this code was
+// generated with a version of connect newer than the one compiled into your binary. You can fix the
+// problem by either regenerating this code with an older version of connect or updating the connect
+// version compiled into your binary.
+const _ = connect.IsAtLeastVersion1_13_0
+
+const (
+	// EventServiceName is the fully-qualified name of the EventService service.
+	EventServiceName = "metalstack.infra.v2.EventService"
+)
+
+// These constants are the fully-qualified names of the RPCs defined in this package. They're
+// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+//
+// Note that these are different from the fully-qualified method names used by
+// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
+// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
+// period.
+const (
+	// EventServiceSendProcedure is the fully-qualified name of the EventService's Send RPC.
+	EventServiceSendProcedure = "/metalstack.infra.v2.EventService/Send"
+)
+
+// EventServiceClient is a client for the metalstack.infra.v2.EventService service.
+type EventServiceClient interface {
+	// Send a series of machine provisioning events.
+	Send(context.Context, *v2.EventServiceSendRequest) (*v2.EventServiceSendResponse, error)
+}
+
+// NewEventServiceClient constructs a client for the metalstack.infra.v2.EventService service. By
+// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
+// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
+// connect.WithGRPC() or connect.WithGRPCWeb() options.
+//
+// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
+// http://api.acme.com or https://acme.com/grpc).
+func NewEventServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) EventServiceClient {
+	baseURL = strings.TrimRight(baseURL, "/")
+	eventServiceMethods := v2.File_metalstack_infra_v2_event_proto.Services().ByName("EventService").Methods()
+	return &eventServiceClient{
+		send: connect.NewClient[v2.EventServiceSendRequest, v2.EventServiceSendResponse](
+			httpClient,
+			baseURL+EventServiceSendProcedure,
+			connect.WithSchema(eventServiceMethods.ByName("Send")),
+			connect.WithClientOptions(opts...),
+		),
+	}
+}
+
+// eventServiceClient implements EventServiceClient.
+type eventServiceClient struct {
+	send *connect.Client[v2.EventServiceSendRequest, v2.EventServiceSendResponse]
+}
+
+// Send calls metalstack.infra.v2.EventService.Send.
+func (c *eventServiceClient) Send(ctx context.Context, req *v2.EventServiceSendRequest) (*v2.EventServiceSendResponse, error) {
+	response, err := c.send.CallUnary(ctx, connect.NewRequest(req))
+	if response != nil {
+		return response.Msg, err
+	}
+	return nil, err
+}
+
+// EventServiceHandler is an implementation of the metalstack.infra.v2.EventService service.
+type EventServiceHandler interface {
+	// Send a series of machine provisioning events.
+	Send(context.Context, *v2.EventServiceSendRequest) (*v2.EventServiceSendResponse, error)
+}
+
+// NewEventServiceHandler builds an HTTP handler from the service implementation. It returns the
+// path on which to mount the handler and the handler itself.
+//
+// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
+// and JSON codecs. They also support gzip compression.
+func NewEventServiceHandler(svc EventServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) {
+	eventServiceMethods := v2.File_metalstack_infra_v2_event_proto.Services().ByName("EventService").Methods()
+	eventServiceSendHandler := connect.NewUnaryHandlerSimple(
+		EventServiceSendProcedure,
+		svc.Send,
+		connect.WithSchema(eventServiceMethods.ByName("Send")),
+		connect.WithHandlerOptions(opts...),
+	)
+	return "/metalstack.infra.v2.EventService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case EventServiceSendProcedure:
+			eventServiceSendHandler.ServeHTTP(w, r)
+		default:
+			http.NotFound(w, r)
+		}
+	})
+}
+
+// UnimplementedEventServiceHandler returns CodeUnimplemented from all methods.
+type UnimplementedEventServiceHandler struct{}
+
+func (UnimplementedEventServiceHandler) Send(context.Context, *v2.EventServiceSendRequest) (*v2.EventServiceSendResponse, error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("metalstack.infra.v2.EventService.Send is not implemented"))
+}
diff --git a/go/permissions/servicepermissions.go b/go/permissions/servicepermissions.go
index 553e2146..df3708e1 100755
--- a/go/permissions/servicepermissions.go
+++ b/go/permissions/servicepermissions.go
@@ -33,6 +33,7 @@ func GetServices() []string {
 		"metalstack.api.v2.UserService",
 		"metalstack.api.v2.VersionService",
 		"metalstack.infra.v2.BMCService",
+		"metalstack.infra.v2.EventService",
 		"metalstack.infra.v2.SwitchService",
 	}
 }
@@ -95,6 +96,7 @@ func GetServicePermissions() *ServicePermissions {
 			Infra: Infra{
 				"INFRA_ROLE_EDITOR": []string{
 					"/metalstack.infra.v2.BMCService/UpdateBMCInfo",
+					"/metalstack.infra.v2.EventService/Send",
 					"/metalstack.infra.v2.SwitchService/Get",
 					"/metalstack.infra.v2.SwitchService/Register",
 					"/metalstack.infra.v2.SwitchService/Heartbeat",
@@ -290,6 +292,7 @@ func GetServicePermissions() *ServicePermissions {
 			"/metalstack.api.v2.UserService/Get":                             true,
 			"/metalstack.api.v2.VersionService/Get":                          true,
 			"/metalstack.infra.v2.BMCService/UpdateBMCInfo":                  true,
+			"/metalstack.infra.v2.EventService/Send":                         true,
 			"/metalstack.infra.v2.SwitchService/Get":                         true,
 			"/metalstack.infra.v2.SwitchService/Heartbeat":                   true,
 			"/metalstack.infra.v2.SwitchService/Register":                    true,
@@ -367,6 +370,7 @@ func GetServicePermissions() *ServicePermissions {
 			},
 			Infra: map[string]bool{
 				"/metalstack.infra.v2.BMCService/UpdateBMCInfo": true,
+				"/metalstack.infra.v2.EventService/Send":        true,
 				"/metalstack.infra.v2.SwitchService/Get":        true,
 				"/metalstack.infra.v2.SwitchService/Heartbeat":  true,
 				"/metalstack.infra.v2.SwitchService/Register":   true,
@@ -510,6 +514,7 @@ func GetServicePermissions() *ServicePermissions {
 			"/metalstack.api.v2.UserService/Get":                 true,
 			"/metalstack.api.v2.VersionService/Get":              false,
 			"/metalstack.infra.v2.BMCService/UpdateBMCInfo":      false,
+			"/metalstack.infra.v2.EventService/Send":             false,
 			"/metalstack.infra.v2.SwitchService/Get":             false,
 			"/metalstack.infra.v2.SwitchService/Heartbeat":       false,
 			"/metalstack.infra.v2.SwitchService/Register":        false,
diff --git a/go/tests/mock_clients.go b/go/tests/mock_clients.go
index b5ebec8d..df85cdfd 100755
--- a/go/tests/mock_clients.go
+++ b/go/tests/mock_clients.go
@@ -93,11 +93,13 @@ type (
 	}
 	infrav2 struct {
 		bmcservice    *infrav2mocks.BMCServiceClient
+		eventservice  *infrav2mocks.EventServiceClient
 		switchservice *infrav2mocks.SwitchServiceClient
 	}
 
 	Infrav2MockFns struct {
 		BMC    func(m *mock.Mock)
+		Event  func(m *mock.Mock)
 		Switch func(m *mock.Mock)
 	}
 )
@@ -338,6 +340,7 @@ func (w wrapper) Infrav2(fns *Infrav2MockFns) *infrav2 {
 func newinfrav2(t *testing.T, fns *Infrav2MockFns) *infrav2 {
 	a := &infrav2{
 		bmcservice:    infrav2mocks.NewBMCServiceClient(t),
+		eventservice:  infrav2mocks.NewEventServiceClient(t),
 		switchservice: infrav2mocks.NewSwitchServiceClient(t),
 	}
 
@@ -345,6 +348,9 @@ func newinfrav2(t *testing.T, fns *Infrav2MockFns) *infrav2 {
 		if fns.BMC != nil {
 			fns.BMC(&a.bmcservice.Mock)
 		}
+		if fns.Event != nil {
+			fns.Event(&a.eventservice.Mock)
+		}
 		if fns.Switch != nil {
 			fns.Switch(&a.switchservice.Mock)
 		}
@@ -357,6 +363,9 @@ func newinfrav2(t *testing.T, fns *Infrav2MockFns) *infrav2 {
 func (c *infrav2) BMC() infrav2connect.BMCServiceClient {
 	return c.bmcservice
 }
+func (c *infrav2) Event() infrav2connect.EventServiceClient {
+	return c.eventservice
+}
 func (c *infrav2) Switch() infrav2connect.SwitchServiceClient {
 	return c.switchservice
 }
diff --git a/go/tests/mocks/client/Infrav2.go b/go/tests/mocks/client/Infrav2.go
index 577f31b2..5c1e2341 100644
--- a/go/tests/mocks/client/Infrav2.go
+++ b/go/tests/mocks/client/Infrav2.go
@@ -82,6 +82,52 @@ func (_c *Infrav2_BMC_Call) RunAndReturn(run func() infrav2connect.BMCServiceCli
 	return _c
 }
 
+// Event provides a mock function for the type Infrav2
+func (_mock *Infrav2) Event() infrav2connect.EventServiceClient {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Event")
+	}
+
+	var r0 infrav2connect.EventServiceClient
+	if returnFunc, ok := ret.Get(0).(func() infrav2connect.EventServiceClient); ok {
+		r0 = returnFunc()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(infrav2connect.EventServiceClient)
+		}
+	}
+	return r0
+}
+
+// Infrav2_Event_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Event'
+type Infrav2_Event_Call struct {
+	*mock.Call
+}
+
+// Event is a helper method to define mock.On call
+func (_e *Infrav2_Expecter) Event() *Infrav2_Event_Call {
+	return &Infrav2_Event_Call{Call: _e.mock.On("Event")}
+}
+
+func (_c *Infrav2_Event_Call) Run(run func()) *Infrav2_Event_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Infrav2_Event_Call) Return(eventServiceClient infrav2connect.EventServiceClient) *Infrav2_Event_Call {
+	_c.Call.Return(eventServiceClient)
+	return _c
+}
+
+func (_c *Infrav2_Event_Call) RunAndReturn(run func() infrav2connect.EventServiceClient) *Infrav2_Event_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // Switch provides a mock function for the type Infrav2
 func (_mock *Infrav2) Switch() infrav2connect.SwitchServiceClient {
 	ret := _mock.Called()
diff --git a/go/tests/mocks/metalstack/infra/v2/infrav2connect/EventServiceClient.go b/go/tests/mocks/metalstack/infra/v2/infrav2connect/EventServiceClient.go
new file mode 100644
index 00000000..e8f619da
--- /dev/null
+++ b/go/tests/mocks/metalstack/infra/v2/infrav2connect/EventServiceClient.go
@@ -0,0 +1,107 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package infrav2connect
+
+import (
+	"context"
+
+	"github.com/metal-stack/api/go/metalstack/infra/v2"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewEventServiceClient creates a new instance of EventServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewEventServiceClient(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *EventServiceClient {
+	mock := &EventServiceClient{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// EventServiceClient is an autogenerated mock type for the EventServiceClient type
+type EventServiceClient struct {
+	mock.Mock
+}
+
+type EventServiceClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *EventServiceClient) EXPECT() *EventServiceClient_Expecter {
+	return &EventServiceClient_Expecter{mock: &_m.Mock}
+}
+
+// Send provides a mock function for the type EventServiceClient
+func (_mock *EventServiceClient) Send(context1 context.Context, eventServiceSendRequest *infrav2.EventServiceSendRequest) (*infrav2.EventServiceSendResponse, error) {
+	ret := _mock.Called(context1, eventServiceSendRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Send")
+	}
+
+	var r0 *infrav2.EventServiceSendResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *infrav2.EventServiceSendRequest) (*infrav2.EventServiceSendResponse, error)); ok {
+		return returnFunc(context1, eventServiceSendRequest)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *infrav2.EventServiceSendRequest) *infrav2.EventServiceSendResponse); ok {
+		r0 = returnFunc(context1, eventServiceSendRequest)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*infrav2.EventServiceSendResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *infrav2.EventServiceSendRequest) error); ok {
+		r1 = returnFunc(context1, eventServiceSendRequest)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// EventServiceClient_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
+type EventServiceClient_Send_Call struct {
+	*mock.Call
+}
+
+// Send is a helper method to define mock.On call
+//   - context1 context.Context
+//   - eventServiceSendRequest *infrav2.EventServiceSendRequest
+func (_e *EventServiceClient_Expecter) Send(context1 interface{}, eventServiceSendRequest interface{}) *EventServiceClient_Send_Call {
+	return &EventServiceClient_Send_Call{Call: _e.mock.On("Send", context1, eventServiceSendRequest)}
+}
+
+func (_c *EventServiceClient_Send_Call) Run(run func(context1 context.Context, eventServiceSendRequest *infrav2.EventServiceSendRequest)) *EventServiceClient_Send_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 *infrav2.EventServiceSendRequest
+		if args[1] != nil {
+			arg1 = args[1].(*infrav2.EventServiceSendRequest)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *EventServiceClient_Send_Call) Return(eventServiceSendResponse *infrav2.EventServiceSendResponse, err error) *EventServiceClient_Send_Call {
+	_c.Call.Return(eventServiceSendResponse, err)
+	return _c
+}
+
+func (_c *EventServiceClient_Send_Call) RunAndReturn(run func(context1 context.Context, eventServiceSendRequest *infrav2.EventServiceSendRequest) (*infrav2.EventServiceSendResponse, error)) *EventServiceClient_Send_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/go/tests/mocks/metalstack/infra/v2/infrav2connect/EventServiceHandler.go b/go/tests/mocks/metalstack/infra/v2/infrav2connect/EventServiceHandler.go
new file mode 100644
index 00000000..5a416efd
--- /dev/null
+++ b/go/tests/mocks/metalstack/infra/v2/infrav2connect/EventServiceHandler.go
@@ -0,0 +1,107 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package infrav2connect
+
+import (
+	"context"
+
+	"github.com/metal-stack/api/go/metalstack/infra/v2"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewEventServiceHandler creates a new instance of EventServiceHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewEventServiceHandler(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *EventServiceHandler {
+	mock := &EventServiceHandler{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// EventServiceHandler is an autogenerated mock type for the EventServiceHandler type
+type EventServiceHandler struct {
+	mock.Mock
+}
+
+type EventServiceHandler_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *EventServiceHandler) EXPECT() *EventServiceHandler_Expecter {
+	return &EventServiceHandler_Expecter{mock: &_m.Mock}
+}
+
+// Send provides a mock function for the type EventServiceHandler
+func (_mock *EventServiceHandler) Send(context1 context.Context, eventServiceSendRequest *infrav2.EventServiceSendRequest) (*infrav2.EventServiceSendResponse, error) {
+	ret := _mock.Called(context1, eventServiceSendRequest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Send")
+	}
+
+	var r0 *infrav2.EventServiceSendResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *infrav2.EventServiceSendRequest) (*infrav2.EventServiceSendResponse, error)); ok {
+		return returnFunc(context1, eventServiceSendRequest)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *infrav2.EventServiceSendRequest) *infrav2.EventServiceSendResponse); ok {
+		r0 = returnFunc(context1, eventServiceSendRequest)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*infrav2.EventServiceSendResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *infrav2.EventServiceSendRequest) error); ok {
+		r1 = returnFunc(context1, eventServiceSendRequest)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// EventServiceHandler_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
+type EventServiceHandler_Send_Call struct {
+	*mock.Call
+}
+
+// Send is a helper method to define mock.On call
+//   - context1 context.Context
+//   - eventServiceSendRequest *infrav2.EventServiceSendRequest
+func (_e *EventServiceHandler_Expecter) Send(context1 interface{}, eventServiceSendRequest interface{}) *EventServiceHandler_Send_Call {
+	return &EventServiceHandler_Send_Call{Call: _e.mock.On("Send", context1, eventServiceSendRequest)}
+}
+
+func (_c *EventServiceHandler_Send_Call) Run(run func(context1 context.Context, eventServiceSendRequest *infrav2.EventServiceSendRequest)) *EventServiceHandler_Send_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 *infrav2.EventServiceSendRequest
+		if args[1] != nil {
+			arg1 = args[1].(*infrav2.EventServiceSendRequest)
+		}
+		run(
+			arg0,
+			arg1,
+		)
+	})
+	return _c
+}
+
+func (_c *EventServiceHandler_Send_Call) Return(eventServiceSendResponse *infrav2.EventServiceSendResponse, err error) *EventServiceHandler_Send_Call {
+	_c.Call.Return(eventServiceSendResponse, err)
+	return _c
+}
+
+func (_c *EventServiceHandler_Send_Call) RunAndReturn(run func(context1 context.Context, eventServiceSendRequest *infrav2.EventServiceSendRequest) (*infrav2.EventServiceSendResponse, error)) *EventServiceHandler_Send_Call {
+	_c.Call.Return(run)
+	return _c
+}
diff --git a/proto/metalstack/infra/v2/event.proto b/proto/metalstack/infra/v2/event.proto
new file mode 100644
index 00000000..e102f9fb
--- /dev/null
+++ b/proto/metalstack/infra/v2/event.proto
@@ -0,0 +1,68 @@
+syntax = "proto3";
+
+package metalstack.infra.v2;
+
+import "buf/validate/validate.proto";
+import "google/protobuf/timestamp.proto";
+import "metalstack/api/v2/common.proto";
+
+// EventService serves event related functions.
+service EventService {
+  // Send a series of machine provisioning events.
+  rpc Send(EventServiceSendRequest) returns (EventServiceSendResponse) {
+    option (metalstack.api.v2.infra_roles) = INFRA_ROLE_EDITOR;
+    option (metalstack.api.v2.auditing) = AUDITING_EXCLUDED;
+  }
+}
+
+// EventServiceSendRequest.
+message EventServiceSendRequest {
+  // Events grouped by machine IDs.
+  map<string, MachineProvisioningEvent> events = 1;
+}
+
+// EventServiceSendResponse.
+message EventServiceSendResponse {
+  // Events counts the number of events successfully stored in the database.
+  uint64 events = 1;
+  // Failed contains IDs of all machines whose events could not be stored in the database.
+  repeated string failed = 2;
+}
+
+// MachineProvisioningEvent contains details about an event.
+message MachineProvisioningEvent {
+  // Time the event occurred at.
+  google.protobuf.Timestamp time = 1;
+  // Event that occurred.
+  ProvisioningEventType event = 2 [(buf.validate.field).enum.defined_only = true];
+  // Message describing the event in more detail.
+  string message = 3;
+}
+
+// ProvisioningEventType is a short description of a machine event.
+enum ProvisioningEventType {
+  // PROVISIONING_EVENT_TYPE_UNSPECIFIED is unspecified.
+  PROVISIONING_EVENT_TYPE_UNSPECIFIED = 0;
+  // PROVISIONING_EVENT_TYPE_ALIVE means the machine has reported itself to the API not long ago.
+  PROVISIONING_EVENT_TYPE_ALIVE = 1 [(metalstack.api.v2.enum_string_value) = "Alive"];
+  // PROVISIONING_EVENT_TYPE_CRASHED means an irregularity in the machine's lifecycle.
+  PROVISIONING_EVENT_TYPE_CRASHED = 2 [(metalstack.api.v2.enum_string_value) = "Crashed"];
+  // PROVISIONING_EVENT_TYPE_PXE_BOOTING is sent when an unprovisioned machine requests a boot image via PXE.
+  PROVISIONING_EVENT_TYPE_PXE_BOOTING = 3 [(metalstack.api.v2.enum_string_value) = "PXE Booting"];
+  // PROVISIONING_EVENT_TYPE_PLANNED_REBOOT means the machine was scheduled for reboot.
+  PROVISIONING_EVENT_TYPE_PLANNED_REBOOT = 4 [(metalstack.api.v2.enum_string_value) = "Planned Reboot"];
+  // PROVISIONING_EVENT_TYPE_PREPARING means the metal-hammer has started.
+  PROVISIONING_EVENT_TYPE_PREPARING = 5 [(metalstack.api.v2.enum_string_value) = "Preparing"];
+  // PROVISIONING_EVENT_TYPE_REGISTERING means the metal-hammer is attempting to register the machine at the API.
+  PROVISIONING_EVENT_TYPE_REGISTERING = 6 [(metalstack.api.v2.enum_string_value) = "Registering"];
+  // PROVISIONING_EVENT_TYPE_WAITING means the machine has successfully reached the state where it is waiting for allocation.
+  PROVISIONING_EVENT_TYPE_WAITING = 7 [(metalstack.api.v2.enum_string_value) = "Waiting"];
+  // PROVISIONING_EVENT_TYPE_INSTALLING means the machine was allocated and the requested OS is being installed.
+  PROVISIONING_EVENT_TYPE_INSTALLING = 8 [(metalstack.api.v2.enum_string_value) = "Installing"];
+  // PROVISIONING_EVENT_TYPE_BOOTING_NEW_KERNEL means the machine has successfully been installed and is now booting into the new OS.
+  PROVISIONING_EVENT_TYPE_BOOTING_NEW_KERNEL = 9 [(metalstack.api.v2.enum_string_value) = "Booting New Kernel"];
+  // PROVISIONING_EVENT_TYPE_PHONED_HOME is sent periodically by an allocated machine to indicate its liveliness.
+  PROVISIONING_EVENT_TYPE_PHONED_HOME = 10 [(metalstack.api.v2.enum_string_value) = "Phoned Home"];
+  // PROVISIONING_EVENT_TYPE_MACHINE_RECLAIM means the machine was freed and is about to return into the pool of waiting machines.
+  PROVISIONING_EVENT_TYPE_MACHINE_RECLAIM = 11 [(metalstack.api.v2.enum_string_value) = "Machine Reclaim"];
+}
diff --git a/python/metalstack/client/client.py b/python/metalstack/client/client.py
index 75f7d338..d1e42027 100755
--- a/python/metalstack/client/client.py
+++ b/python/metalstack/client/client.py
@@ -30,6 +30,7 @@
 import metalstack.api.v2.version_connect as api_version_connect
 
 import metalstack.infra.v2.bmc_connect as infra_bmc_connect
+import metalstack.infra.v2.event_connect as infra_event_connect
 import metalstack.infra.v2.switch_connect as infra_switch_connect
 
 
@@ -154,6 +155,9 @@ def __init__(self, baseurl: str, session=None):
         def bmc(self):
             return infra_bmc_connect.BMCServiceClientSync(address=self._baseurl, session=self._session)
 
+        def event(self):
+            return infra_event_connect.EventServiceClientSync(address=self._baseurl, session=self._session)
+
         def switch(self):
             return infra_switch_connect.SwitchServiceClientSync(address=self._baseurl, session=self._session)
 
diff --git a/python/metalstack/infra/v2/event_connect.py b/python/metalstack/infra/v2/event_connect.py
new file mode 100644
index 00000000..2cbfdb39
--- /dev/null
+++ b/python/metalstack/infra/v2/event_connect.py
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+# Generated by https://github.com/connectrpc/connect-python.  DO NOT EDIT!
+# source: metalstack/infra/v2/event.proto
+
+from collections.abc import AsyncIterator, Iterable, Iterator, Mapping
+from typing import Protocol
+
+from connectrpc.client import ConnectClient, ConnectClientSync
+from connectrpc.code import Code
+from connectrpc.errors import ConnectError
+from connectrpc.interceptor import Interceptor, InterceptorSync
+from connectrpc.method import IdempotencyLevel, MethodInfo
+from connectrpc.request import Headers, RequestContext
+from connectrpc.server import ConnectASGIApplication, ConnectWSGIApplication, Endpoint, EndpointSync
+import metalstack.infra.v2.event_pb2 as metalstack_dot_infra_dot_v2_dot_event__pb2
+
+
+class EventService(Protocol):
+    async def send(self, request: metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendRequest, ctx: RequestContext) -> metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendResponse:
+        raise ConnectError(Code.UNIMPLEMENTED, "Not implemented")
+
+
+class EventServiceASGIApplication(ConnectASGIApplication):
+    def __init__(self, service: EventService, *, interceptors: Iterable[Interceptor]=(), read_max_bytes: int | None = None) -> None:
+        super().__init__(
+            endpoints={
+                "/metalstack.infra.v2.EventService/Send": Endpoint.unary(
+                    method=MethodInfo(
+                        name="Send",
+                        service_name="metalstack.infra.v2.EventService",
+                        input=metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendRequest,
+                        output=metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendResponse,
+                        idempotency_level=IdempotencyLevel.UNKNOWN,
+                    ),
+                    function=service.send,
+                ),
+            },
+            interceptors=interceptors,
+            read_max_bytes=read_max_bytes,
+        )
+
+    @property
+    def path(self) -> str:
+        """Returns the URL path to mount the application to when serving multiple applications."""
+        return "/metalstack.infra.v2.EventService"
+
+
+class EventServiceClient(ConnectClient):
+    async def send(
+        self,
+        request: metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendRequest,
+        *,
+        headers: Headers | Mapping[str, str] | None = None,
+        timeout_ms: int | None = None,
+    ) -> metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendResponse:
+        return await self.execute_unary(
+            request=request,
+            method=MethodInfo(
+                name="Send",
+                service_name="metalstack.infra.v2.EventService",
+                input=metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendRequest,
+                output=metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendResponse,
+                idempotency_level=IdempotencyLevel.UNKNOWN,
+            ),
+            headers=headers,
+            timeout_ms=timeout_ms,
+        )
+
+
+class EventServiceSync(Protocol):
+    def send(self, request: metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendRequest, ctx: RequestContext) -> metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendResponse:
+        raise ConnectError(Code.UNIMPLEMENTED, "Not implemented")
+
+
+class EventServiceWSGIApplication(ConnectWSGIApplication):
+    def __init__(self, service: EventServiceSync, interceptors: Iterable[InterceptorSync]=(), read_max_bytes: int | None = None) -> None:
+        super().__init__(
+            endpoints={
+                "/metalstack.infra.v2.EventService/Send": EndpointSync.unary(
+                    method=MethodInfo(
+                        name="Send",
+                        service_name="metalstack.infra.v2.EventService",
+                        input=metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendRequest,
+                        output=metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendResponse,
+                        idempotency_level=IdempotencyLevel.UNKNOWN,
+                    ),
+                    function=service.send,
+                ),
+            },
+            interceptors=interceptors,
+            read_max_bytes=read_max_bytes,
+        )
+
+    @property
+    def path(self) -> str:
+        """Returns the URL path to mount the application to when serving multiple applications."""
+        return "/metalstack.infra.v2.EventService"
+
+
+class EventServiceClientSync(ConnectClientSync):
+    def send(
+        self,
+        request: metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendRequest,
+        *,
+        headers: Headers | Mapping[str, str] | None = None,
+        timeout_ms: int | None = None,
+    ) -> metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendResponse:
+        return self.execute_unary(
+            request=request,
+            method=MethodInfo(
+                name="Send",
+                service_name="metalstack.infra.v2.EventService",
+                input=metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendRequest,
+                output=metalstack_dot_infra_dot_v2_dot_event__pb2.EventServiceSendResponse,
+                idempotency_level=IdempotencyLevel.UNKNOWN,
+            ),
+            headers=headers,
+            timeout_ms=timeout_ms,
+        )
diff --git a/python/metalstack/infra/v2/event_pb2.py b/python/metalstack/infra/v2/event_pb2.py
new file mode 100644
index 00000000..a0003be4
--- /dev/null
+++ b/python/metalstack/infra/v2/event_pb2.py
@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: metalstack/infra/v2/event.proto
+# Protobuf Python Version: 6.32.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    32,
+    1,
+    '',
+    'metalstack/infra/v2/event.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2
+from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2
+from metalstack.api.v2 import common_pb2 as metalstack_dot_api_dot_v2_dot_common__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1fmetalstack/infra/v2/event.proto\x12\x13metalstack.infra.v2\x1a\x1b\x62uf/validate/validate.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1emetalstack/api/v2/common.proto\"\xd5\x01\n\x17\x45ventServiceSendRequest\x12P\n\x06\x65vents\x18\x01 \x03(\x0b\x32\x38.metalstack.infra.v2.EventServiceSendRequest.EventsEntryR\x06\x65vents\x1ah\n\x0b\x45ventsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x43\n\x05value\x18\x02 \x01(\x0b\x32-.metalstack.infra.v2.MachineProvisioningEventR\x05value:\x02\x38\x01\"J\n\x18\x45ventServiceSendResponse\x12\x16\n\x06\x65vents\x18\x01 \x01(\x04R\x06\x65vents\x12\x16\n\x06\x66\x61iled\x18\x02 \x03(\tR\x06\x66\x61iled\"\xb0\x01\n\x18MachineProvisioningEvent\x12.\n\x04time\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x04time\x12J\n\x05\x65vent\x18\x02 \x01(\x0e\x32*.metalstack.infra.v2.ProvisioningEventTypeB\x08\xbaH\x05\x82\x01\x02\x10\x01R\x05\x65vent\x12\x18\n\x07message\x18\x03 \x01(\tR\x07message*\xb8\x05\n\x15ProvisioningEventType\x12\'\n#PROVISIONING_EVENT_TYPE_UNSPECIFIED\x10\x00\x12,\n\x1dPROVISIONING_EVENT_TYPE_ALIVE\x10\x01\x1a\t\x82\xb2\x19\x05\x41live\x12\x30\n\x1fPROVISIONING_EVENT_TYPE_CRASHED\x10\x02\x1a\x0b\x82\xb2\x19\x07\x43rashed\x12\x38\n#PROVISIONING_EVENT_TYPE_PXE_BOOTING\x10\x03\x1a\x0f\x82\xb2\x19\x0bPXE Booting\x12>\n&PROVISIONING_EVENT_TYPE_PLANNED_REBOOT\x10\x04\x1a\x12\x82\xb2\x19\x0ePlanned Reboot\x12\x34\n!PROVISIONING_EVENT_TYPE_PREPARING\x10\x05\x1a\r\x82\xb2\x19\tPreparing\x12\x38\n#PROVISIONING_EVENT_TYPE_REGISTERING\x10\x06\x1a\x0f\x82\xb2\x19\x0bRegistering\x12\x30\n\x1fPROVISIONING_EVENT_TYPE_WAITING\x10\x07\x1a\x0b\x82\xb2\x19\x07Waiting\x12\x36\n\"PROVISIONING_EVENT_TYPE_INSTALLING\x10\x08\x1a\x0e\x82\xb2\x19\nInstalling\x12\x46\n*PROVISIONING_EVENT_TYPE_BOOTING_NEW_KERNEL\x10\t\x1a\x16\x82\xb2\x19\x12\x42ooting New Kernel\x12\x38\n#PROVISIONING_EVENT_TYPE_PHONED_HOME\x10\n\x1a\x0f\x82\xb2\x19\x0bPhoned Home\x12@\n\'PROVISIONING_EVENT_TYPE_MACHINE_RECLAIM\x10\x0b\x1a\x13\x82\xb2\x19\x0fMachine Reclaim2~\n\x0c\x45ventService\x12n\n\x04Send\x12,.metalstack.infra.v2.EventServiceSendRequest\x1a-.metalstack.infra.v2.EventServiceSendResponse\"\t\xe0\xf3\x18\x02\xea\xf3\x18\x01\x01\x42\xce\x01\n\x17\x63om.metalstack.infra.v2B\nEventProtoP\x01Z9github.com/metal-stack/api/go/metalstack/infra/v2;infrav2\xa2\x02\x03MIX\xaa\x02\x13Metalstack.Infra.V2\xca\x02\x13Metalstack\\Infra\\V2\xe2\x02\x1fMetalstack\\Infra\\V2\\GPBMetadata\xea\x02\x15Metalstack::Infra::V2b\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'metalstack.infra.v2.event_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n\027com.metalstack.infra.v2B\nEventProtoP\001Z9github.com/metal-stack/api/go/metalstack/infra/v2;infrav2\242\002\003MIX\252\002\023Metalstack.Infra.V2\312\002\023Metalstack\\Infra\\V2\342\002\037Metalstack\\Infra\\V2\\GPBMetadata\352\002\025Metalstack::Infra::V2'
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_ALIVE"]._loaded_options = None
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_ALIVE"]._serialized_options = b'\202\262\031\005Alive'
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_CRASHED"]._loaded_options = None
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_CRASHED"]._serialized_options = b'\202\262\031\007Crashed'
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_PXE_BOOTING"]._loaded_options = None
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_PXE_BOOTING"]._serialized_options = b'\202\262\031\013PXE Booting'
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_PLANNED_REBOOT"]._loaded_options = None
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_PLANNED_REBOOT"]._serialized_options = b'\202\262\031\016Planned Reboot'
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_PREPARING"]._loaded_options = None
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_PREPARING"]._serialized_options = b'\202\262\031\tPreparing'
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_REGISTERING"]._loaded_options = None
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_REGISTERING"]._serialized_options = b'\202\262\031\013Registering'
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_WAITING"]._loaded_options = None
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_WAITING"]._serialized_options = b'\202\262\031\007Waiting'
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_INSTALLING"]._loaded_options = None
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_INSTALLING"]._serialized_options = b'\202\262\031\nInstalling'
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_BOOTING_NEW_KERNEL"]._loaded_options = None
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_BOOTING_NEW_KERNEL"]._serialized_options = b'\202\262\031\022Booting New Kernel'
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_PHONED_HOME"]._loaded_options = None
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_PHONED_HOME"]._serialized_options = b'\202\262\031\013Phoned Home'
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_MACHINE_RECLAIM"]._loaded_options = None
+  _globals['_PROVISIONINGEVENTTYPE'].values_by_name["PROVISIONING_EVENT_TYPE_MACHINE_RECLAIM"]._serialized_options = b'\202\262\031\017Machine Reclaim'
+  _globals['_EVENTSERVICESENDREQUEST_EVENTSENTRY']._loaded_options = None
+  _globals['_EVENTSERVICESENDREQUEST_EVENTSENTRY']._serialized_options = b'8\001'
+  _globals['_MACHINEPROVISIONINGEVENT'].fields_by_name['event']._loaded_options = None
+  _globals['_MACHINEPROVISIONINGEVENT'].fields_by_name['event']._serialized_options = b'\272H\005\202\001\002\020\001'
+  _globals['_EVENTSERVICE'].methods_by_name['Send']._loaded_options = None
+  _globals['_EVENTSERVICE'].methods_by_name['Send']._serialized_options = b'\340\363\030\002\352\363\030\001\001'
+  _globals['_PROVISIONINGEVENTTYPE']._serialized_start=622
+  _globals['_PROVISIONINGEVENTTYPE']._serialized_end=1318
+  _globals['_EVENTSERVICESENDREQUEST']._serialized_start=151
+  _globals['_EVENTSERVICESENDREQUEST']._serialized_end=364
+  _globals['_EVENTSERVICESENDREQUEST_EVENTSENTRY']._serialized_start=260
+  _globals['_EVENTSERVICESENDREQUEST_EVENTSENTRY']._serialized_end=364
+  _globals['_EVENTSERVICESENDRESPONSE']._serialized_start=366
+  _globals['_EVENTSERVICESENDRESPONSE']._serialized_end=440
+  _globals['_MACHINEPROVISIONINGEVENT']._serialized_start=443
+  _globals['_MACHINEPROVISIONINGEVENT']._serialized_end=619
+  _globals['_EVENTSERVICE']._serialized_start=1320
+  _globals['_EVENTSERVICE']._serialized_end=1446
+# @@protoc_insertion_point(module_scope)
diff --git a/python/metalstack/infra/v2/event_pb2.pyi b/python/metalstack/infra/v2/event_pb2.pyi
new file mode 100644
index 00000000..4f5ec506
--- /dev/null
+++ b/python/metalstack/infra/v2/event_pb2.pyi
@@ -0,0 +1,71 @@
+import datetime
+
+from buf.validate import validate_pb2 as _validate_pb2
+from google.protobuf import timestamp_pb2 as _timestamp_pb2
+from metalstack.api.v2 import common_pb2 as _common_pb2
+from google.protobuf.internal import containers as _containers
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from collections.abc import Iterable as _Iterable, Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class ProvisioningEventType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    PROVISIONING_EVENT_TYPE_UNSPECIFIED: _ClassVar[ProvisioningEventType]
+    PROVISIONING_EVENT_TYPE_ALIVE: _ClassVar[ProvisioningEventType]
+    PROVISIONING_EVENT_TYPE_CRASHED: _ClassVar[ProvisioningEventType]
+    PROVISIONING_EVENT_TYPE_PXE_BOOTING: _ClassVar[ProvisioningEventType]
+    PROVISIONING_EVENT_TYPE_PLANNED_REBOOT: _ClassVar[ProvisioningEventType]
+    PROVISIONING_EVENT_TYPE_PREPARING: _ClassVar[ProvisioningEventType]
+    PROVISIONING_EVENT_TYPE_REGISTERING: _ClassVar[ProvisioningEventType]
+    PROVISIONING_EVENT_TYPE_WAITING: _ClassVar[ProvisioningEventType]
+    PROVISIONING_EVENT_TYPE_INSTALLING: _ClassVar[ProvisioningEventType]
+    PROVISIONING_EVENT_TYPE_BOOTING_NEW_KERNEL: _ClassVar[ProvisioningEventType]
+    PROVISIONING_EVENT_TYPE_PHONED_HOME: _ClassVar[ProvisioningEventType]
+    PROVISIONING_EVENT_TYPE_MACHINE_RECLAIM: _ClassVar[ProvisioningEventType]
+PROVISIONING_EVENT_TYPE_UNSPECIFIED: ProvisioningEventType
+PROVISIONING_EVENT_TYPE_ALIVE: ProvisioningEventType
+PROVISIONING_EVENT_TYPE_CRASHED: ProvisioningEventType
+PROVISIONING_EVENT_TYPE_PXE_BOOTING: ProvisioningEventType
+PROVISIONING_EVENT_TYPE_PLANNED_REBOOT: ProvisioningEventType
+PROVISIONING_EVENT_TYPE_PREPARING: ProvisioningEventType
+PROVISIONING_EVENT_TYPE_REGISTERING: ProvisioningEventType
+PROVISIONING_EVENT_TYPE_WAITING: ProvisioningEventType
+PROVISIONING_EVENT_TYPE_INSTALLING: ProvisioningEventType
+PROVISIONING_EVENT_TYPE_BOOTING_NEW_KERNEL: ProvisioningEventType
+PROVISIONING_EVENT_TYPE_PHONED_HOME: ProvisioningEventType
+PROVISIONING_EVENT_TYPE_MACHINE_RECLAIM: ProvisioningEventType
+
+class EventServiceSendRequest(_message.Message):
+    __slots__ = ("events",)
+    class EventsEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: MachineProvisioningEvent
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[MachineProvisioningEvent, _Mapping]] = ...) -> None: ...
+    EVENTS_FIELD_NUMBER: _ClassVar[int]
+    events: _containers.MessageMap[str, MachineProvisioningEvent]
+    def __init__(self, events: _Optional[_Mapping[str, MachineProvisioningEvent]] = ...) -> None: ...
+
+class EventServiceSendResponse(_message.Message):
+    __slots__ = ("events", "failed")
+    EVENTS_FIELD_NUMBER: _ClassVar[int]
+    FAILED_FIELD_NUMBER: _ClassVar[int]
+    events: int
+    failed: _containers.RepeatedScalarFieldContainer[str]
+    def __init__(self, events: _Optional[int] = ..., failed: _Optional[_Iterable[str]] = ...) -> None: ...
+
+class MachineProvisioningEvent(_message.Message):
+    __slots__ = ("time", "event", "message")
+    TIME_FIELD_NUMBER: _ClassVar[int]
+    EVENT_FIELD_NUMBER: _ClassVar[int]
+    MESSAGE_FIELD_NUMBER: _ClassVar[int]
+    time: _timestamp_pb2.Timestamp
+    event: ProvisioningEventType
+    message: str
+    def __init__(self, time: _Optional[_Union[datetime.datetime, _timestamp_pb2.Timestamp, _Mapping]] = ..., event: _Optional[_Union[ProvisioningEventType, str]] = ..., message: _Optional[str] = ...) -> None: ...