Merge branch 'develop' into release-1.0.0

andreasohlund · andreasohlund · commit e18b9cf78341 · 2014-03-22T14:24:11.000+01:00
diff --git a/src/ServiceControl.AcceptanceTests/HeartbeatMonitoring/When_an_endpoint_starts_up.cs b/src/ServiceControl.AcceptanceTests/HeartbeatMonitoring/When_an_endpoint_starts_up.cs
@@ -7,7 +7,7 @@
     using NServiceBus.Config;
     using NServiceBus.Unicast;
     using NUnit.Framework;
-    using ServiceControl.Contracts.HeartbeatMonitoring;
+    using ServiceControl.Contracts.EndpointControl;
     using ServiceControl.EventLog;
 
     public class When_an_endpoint_starts_up : AcceptanceTest
diff --git a/src/ServiceControl/CompositeViews/Endpoints/EndpointsView.cs b/src/ServiceControl/CompositeViews/Endpoints/EndpointsView.cs
@@ -7,8 +7,12 @@ public class EndpointsView
         public Guid Id { get; set; }
         public string Name { get; set; }
         public string HostDisplayName { get; set; }
+
+        public bool Monitored { get; set; }
+
         public bool MonitorHeartbeat { get; set; }
         public string LicenseStatus { get; set; }
         public HeartbeatInformation HeartbeatInformation { get; set; }
+        public bool IsSendingHeartbeats { get; set; }
     }
 }
diff --git a/src/ServiceControl/CompositeViews/Endpoints/GetEndpoints.cs b/src/ServiceControl/CompositeViews/Endpoints/GetEndpoints.cs
@@ -39,7 +39,7 @@ public GetEndpoints()
                         return HttpStatusCode.NotFound;
                     }
 
-                    if (data.MonitorHeartbeat == endpoint.MonitorHeartbeat)
+                    if (data.MonitorHeartbeat == endpoint.Monitored)
                     {
                         return HttpStatusCode.NotModified;
                     }
@@ -79,7 +79,8 @@ public GetEndpoints()
                                 Id = knownEndpoint.Id,
                                 Name = knownEndpoint.EndpointDetails.Name,
                                 HostDisplayName = knownEndpoint.HostDisplayName,
-                                MonitorHeartbeat = knownEndpoint.MonitorHeartbeat,
+                                Monitored = knownEndpoint.Monitored,
+                                MonitorHeartbeat = true,
                                 LicenseStatus = LicenseStatusKeeper.Get(knownEndpoint.EndpointDetails.Name + knownEndpoint.HostDisplayName)
                             };
 
@@ -91,6 +92,10 @@ public GetEndpoints()
                                         return;
                                     }
 
+                                    view.IsSendingHeartbeats = true;
+
+                                    view.MonitorHeartbeat = !heartbeat.Disabled;
+
                                     view.HeartbeatInformation =
                                         new HeartbeatInformation
                                         {
diff --git a/src/ServiceControl/CompositeViews/Endpoints/KnownEndpointIndex.cs b/src/ServiceControl/CompositeViews/Endpoints/KnownEndpointIndex.cs
@@ -13,7 +13,7 @@ public KnownEndpointIndex()
                               {
                                   EndpointDetails = message.EndpointDetails,
                                   HostDisplayName = message.HostDisplayName,
-                                  MonitorHeartbeat = message.MonitorHeartbeat,
+                                  Monitored = message.Monitored,
                               };
 
             DisableInMemoryIndexing = true;
diff --git a/src/ServiceControl/CompositeViews/Endpoints/KnownEndpointUpdateHandler.cs b/src/ServiceControl/CompositeViews/Endpoints/KnownEndpointUpdateHandler.cs
@@ -21,13 +21,13 @@ public void Handle(EnableEndpointMonitoring message)
                 throw new Exception("No endpoint with found with id: " + message.EndpointId);
             }
 
-            knownEndpoint.MonitorHeartbeat = true;
+            knownEndpoint.Monitored = true;
 
             Session.Store(knownEndpoint);
 
             Bus.Publish(new MonitoringEnabledForEndpoint
             {
-                EndpointId = message.EndpointId,
+                EndpointInstanceId = message.EndpointId,
                 Endpoint = knownEndpoint.EndpointDetails
             });
         }
@@ -41,13 +41,13 @@ public void Handle(DisableEndpointMonitoring message)
                 throw new Exception("No endpoint with found with id: " + message.EndpointId);
             }
 
-            knownEndpoint.MonitorHeartbeat = false;
+            knownEndpoint.Monitored = false;
 
             Session.Store(knownEndpoint);
 
             Bus.Publish(new MonitoringDisabledForEndpoint
             {
-                EndpointId = message.EndpointId,
+                EndpointInstanceId = message.EndpointId,
                 Endpoint = knownEndpoint.EndpointDetails
             });
         }
diff --git a/src/ServiceControl/Contracts/EndpointControl/EndpointStarted.cs b/src/ServiceControl/Contracts/EndpointControl/EndpointStarted.cs
@@ -1,12 +1,12 @@
-namespace ServiceControl.Contracts.HeartbeatMonitoring
+namespace ServiceControl.Contracts.EndpointControl
 {
     using System;
     using NServiceBus;
+    using Operations;
 
     public class EndpointStarted : IEvent
     {
-        public Guid HostId { get; set; }
-        public string Endpoint { get; set; }
+        public EndpointDetails EndpointDetails { get; set; }
         public DateTime StartedAt { get; set; }
     }
 }
diff --git a/src/ServiceControl/Contracts/EndpointControl/MonitoringDisabledForEndpoint.cs b/src/ServiceControl/Contracts/EndpointControl/MonitoringDisabledForEndpoint.cs
@@ -6,7 +6,7 @@ namespace ServiceControl.EndpointControl.Contracts
 
     public class MonitoringDisabledForEndpoint : IEvent
     {
-        public Guid EndpointId { get; set; }
+        public Guid EndpointInstanceId { get; set; }
 
         public EndpointDetails Endpoint { get; set; }
     }
diff --git a/src/ServiceControl/Contracts/EndpointControl/MonitoringEnabledForEndpoint.cs b/src/ServiceControl/Contracts/EndpointControl/MonitoringEnabledForEndpoint.cs
@@ -6,7 +6,7 @@ namespace ServiceControl.EndpointControl.Contracts
 
     public class MonitoringEnabledForEndpoint : IEvent
     {
-        public Guid EndpointId { get; set; }
+        public Guid EndpointInstanceId { get; set; }
 
         public EndpointDetails Endpoint { get; set; }
     }
diff --git a/src/ServiceControl/Contracts/HeartbeatMonitoring/EndpointFailedToHeartbeat.cs b/src/ServiceControl/Contracts/HeartbeatMonitoring/EndpointFailedToHeartbeat.cs
@@ -1,10 +1,9 @@
 namespace ServiceControl.Contracts.HeartbeatMonitoring
 {
     using System;
-    using NServiceBus;
     using Operations;
 
-    public class EndpointFailedToHeartbeat : IEvent
+    public class EndpointFailedToHeartbeat : HeartbeatStatusChanged
     {
         public EndpointDetails Endpoint { get; set; }
         public DateTime LastReceivedAt { get; set; }
diff --git a/src/ServiceControl/Contracts/HeartbeatMonitoring/EndpointHeartbeatRestored.cs b/src/ServiceControl/Contracts/HeartbeatMonitoring/EndpointHeartbeatRestored.cs
@@ -1,10 +1,9 @@
 namespace ServiceControl.Contracts.HeartbeatMonitoring
 {
     using System;
-    using NServiceBus;
     using Operations;
 
-    public class EndpointHeartbeatRestored : IEvent
+    public class EndpointHeartbeatRestored : HeartbeatStatusChanged
     {
         public EndpointDetails Endpoint { get; set; }
         public DateTime RestoredAt { get; set; }
diff --git a/src/ServiceControl/Contracts/HeartbeatMonitoring/HeartbeatMonitoringDisabled.cs b/src/ServiceControl/Contracts/HeartbeatMonitoring/HeartbeatMonitoringDisabled.cs
@@ -0,0 +1,9 @@
+namespace ServiceControl.Contracts.HeartbeatMonitoring
+{
+    using System;
+
+    public class HeartbeatMonitoringDisabled : HeartbeatStatusChanged
+    {
+        public Guid EndpointInstanceId { get; set; }
+    }
+}
diff --git a/src/ServiceControl/Contracts/HeartbeatMonitoring/HeartbeatMonitoringEnabled.cs b/src/ServiceControl/Contracts/HeartbeatMonitoring/HeartbeatMonitoringEnabled.cs
@@ -0,0 +1,9 @@
+namespace ServiceControl.Contracts.HeartbeatMonitoring
+{
+    using System;
+
+    public class HeartbeatMonitoringEnabled : HeartbeatStatusChanged
+    {
+        public Guid EndpointInstanceId { get; set; } 
+    }
+}
diff --git a/src/ServiceControl/Contracts/HeartbeatMonitoring/HeartbeatStatusChanged.cs b/src/ServiceControl/Contracts/HeartbeatMonitoring/HeartbeatStatusChanged.cs
@@ -0,0 +1,9 @@
+﻿namespace ServiceControl.Contracts.HeartbeatMonitoring
+{
+    using NServiceBus;
+
+    public class HeartbeatStatusChanged : IEvent
+    {
+        
+    }
+}
diff --git a/src/ServiceControl/Contracts/HeartbeatMonitoring/HeartbeatingEndpointDetected.cs b/src/ServiceControl/Contracts/HeartbeatMonitoring/HeartbeatingEndpointDetected.cs
@@ -1,10 +1,9 @@
 ﻿namespace ServiceControl.Contracts.HeartbeatMonitoring
 {
     using System;
-    using NServiceBus;
     using Operations;
 
-    public class HeartbeatingEndpointDetected : IEvent
+    public class HeartbeatingEndpointDetected : HeartbeatStatusChanged
     {
         public EndpointDetails Endpoint { get; set; }
         public DateTime DetectedAt { get; set; }
diff --git a/src/ServiceControl/EndpointControl/DetectNewEndpointsFromImportsEnricher.cs b/src/ServiceControl/EndpointControl/DetectNewEndpointsFromImportsEnricher.cs
@@ -28,6 +28,12 @@ public override void Enrich(ImportMessage message)
 
         void TryAddEndpoint(EndpointDetails endpointDetails)
         {
+            // SendingEndpoint will be null for messages that are from v3.3.x endpoints because we don't
+            // have the relevant information via the headers, which were added in v4.
+            // The ReceivingEndpoint will be null for messages from v3.3.x endpoints that were successfully
+            // processed because we dont have the information from the relevant headers.
+            if (endpointDetails == null) return; 
+
             Guid id;
 
             if (endpointDetails.HostId == Guid.Empty)
diff --git a/src/ServiceControl/EndpointControl/EnrichWithEndpointDetails.cs b/src/ServiceControl/EndpointControl/EnrichWithEndpointDetails.cs
@@ -8,12 +8,20 @@ public class EnrichWithEndpointDetails : ImportEnricher
         public override void Enrich(ImportMessage message)
         {
             var sendingEndpoint = EndpointDetailsParser.SendingEndpoint(message.PhysicalMessage.Headers);
-
-            message.Metadata.Add("SendingEndpoint", sendingEndpoint);
+            // SendingEndpoint will be null for messages that are from v3.3.x endpoints because we don't
+            // have the relevant information via the headers, which were added in v4.
+            if (sendingEndpoint != null)
+            {
+                message.Metadata.Add("SendingEndpoint", sendingEndpoint);
+            }
 
             var receivingEndpoint = EndpointDetailsParser.ReceivingEndpoint(message.PhysicalMessage.Headers);
-
-            message.Metadata.Add("ReceivingEndpoint", receivingEndpoint);
+            // The ReceivingEndpoint will be null for messages from v3.3.x endpoints that were successfully
+            // processed because we dont have the information from the relevant headers.
+            if (receivingEndpoint != null)
+            {
+                message.Metadata.Add("ReceivingEndpoint", receivingEndpoint);
+            }
         }
     }
 }
diff --git a/src/ServiceControl/EndpointControl/KnownEndpoint.cs b/src/ServiceControl/EndpointControl/KnownEndpoint.cs
@@ -7,12 +7,12 @@ public class KnownEndpoint
     {
         public KnownEndpoint()
         {
-            MonitorHeartbeat = true;
+            Monitored = true;
         }
 
         public Guid Id { get; set; }
         public string HostDisplayName { get; set; }
-        public bool MonitorHeartbeat { get; set; }
+        public bool Monitored { get; set; }
         public EndpointDetails EndpointDetails { get; set; }
         public bool HasTemporaryId{ get; set; }
     }
diff --git a/src/ServiceControl/EventLog/Definitions/EndpointStartedDefinition.cs b/src/ServiceControl/EventLog/Definitions/EndpointStartedDefinition.cs
@@ -1,15 +1,15 @@
 ﻿namespace ServiceControl.EventLog.Definitions
 {
-    using Contracts.HeartbeatMonitoring;
+    using Contracts.EndpointControl;
 
     public class EndpointStartedDefinition : EventLogMappingDefinition<EndpointStarted>
     {
         public EndpointStartedDefinition()
         {
-            Description(m => string.Format("Endpoint '{0}' started at {1} on host {2}", m.Endpoint, m.StartedAt, m.HostId));
+            Description(m => string.Format("Endpoint '{0}' started at {1} on host {2}", m.EndpointDetails.Name, m.StartedAt, m.EndpointDetails.Host));
 
-            RelatesToEndpoint(m => m.Endpoint);
-            RelatesToHost(m => m.HostId);
+            RelatesToEndpoint(m => m.EndpointDetails.Name);
+            RelatesToHost(m => m.EndpointDetails.HostId);
 
             RaisedAt(m => m.StartedAt);
         }
diff --git a/src/ServiceControl/HeartbeatMonitoring/Heartbeat.cs b/src/ServiceControl/HeartbeatMonitoring/Heartbeat.cs
@@ -9,6 +9,7 @@ public class Heartbeat
         public DateTime LastReportAt { get; set; }
         public EndpointDetails EndpointDetails { get; set; }
         public Status ReportedStatus { get; set; }
+        public bool Disabled { get; set; }
     }
 
     public enum Status
diff --git a/src/ServiceControl/HeartbeatMonitoring/HeartbeatStatusInitializer.cs b/src/ServiceControl/HeartbeatMonitoring/HeartbeatStatusInitializer.cs
@@ -51,19 +51,11 @@ void Initialise()
 
                 session.Query<KnownEndpoint, KnownEndpointIndex>()
                     .Customize(customization)
-                    .Lazily(heartbeats =>
+                    .Lazily(endpoints =>
                     {
-                        foreach (var knownEndpoint in heartbeats)
+                        foreach (var knownEndpoint in endpoints)
                         {
-                            if (knownEndpoint.MonitorHeartbeat)
-                            {
-                                statusProvider.EnableMonitoring(knownEndpoint.EndpointDetails);
-                            }
-                            else
-                            {
-                                statusProvider.DisableMonitoring(knownEndpoint.EndpointDetails);
-                            }
-
+                            statusProvider.RegisterNewEndpoint(knownEndpoint.EndpointDetails);
                         }
                     });
 
@@ -73,6 +65,14 @@ void Initialise()
                     {
                         foreach (var heartbeat in heartbeats)
                         {
+                            if (heartbeat.Disabled)
+                            {
+                                statusProvider.DisableMonitoring(heartbeat.EndpointDetails);
+                                continue;
+                            }
+
+                            statusProvider.EnableMonitoring(heartbeat.EndpointDetails);
+
                             if (heartbeat.ReportedStatus == Status.Beating)
                             {
                                 statusProvider.RegisterHeartbeatingEndpoint(heartbeat.EndpointDetails, heartbeat.LastReportAt);
diff --git a/src/ServiceControl/HeartbeatMonitoring/MonitoringDisabledForEndpointHandler.cs b/src/ServiceControl/HeartbeatMonitoring/MonitoringDisabledForEndpointHandler.cs
@@ -0,0 +1,47 @@
+﻿namespace ServiceControl.HeartbeatMonitoring
+{
+    using System;
+    using Contracts.HeartbeatMonitoring;
+    using EndpointControl.Contracts;
+    using NServiceBus;
+    using NServiceBus.Logging;
+    using Raven.Client;
+
+    class MonitoringDisabledForEndpointHandler : IHandleMessages<MonitoringDisabledForEndpoint>
+    {
+        public HeartbeatStatusProvider StatusProvider { get; set; }
+
+        public IDocumentSession Session { get; set; }
+
+        public IBus Bus { get; set; }
+
+        public void Handle(MonitoringDisabledForEndpoint message)
+        {
+            var heartbeat = Session.Load<Heartbeat>(message.EndpointInstanceId);
+
+            if (heartbeat == null)
+            {
+                throw new Exception("No heartbeat with found with id: " + message.EndpointInstanceId);
+            }
+
+            if (heartbeat.Disabled)
+            {
+                Logger.InfoFormat("Heartbeat monitoring for endpoint {0} is already disabled", message.EndpointInstanceId);
+                return;
+            }
+
+            heartbeat.Disabled = true;
+
+            StatusProvider.DisableMonitoring(message.Endpoint);
+
+            Session.Store(heartbeat);
+
+            Bus.Publish(new HeartbeatMonitoringDisabled
+            {
+                EndpointInstanceId = message.EndpointInstanceId
+            });
+        }
+
+        static readonly ILog Logger = LogManager.GetLogger(typeof(MonitoringEnabledForEndpointHandler));
+    }
+}
diff --git a/src/ServiceControl/HeartbeatMonitoring/MonitoringEnabledForEndpointHandler.cs b/src/ServiceControl/HeartbeatMonitoring/MonitoringEnabledForEndpointHandler.cs
diff --git a/src/ServiceControl/HeartbeatMonitoring/RaiseHeartbeatChanges.cs b/src/ServiceControl/HeartbeatMonitoring/RaiseHeartbeatChanges.cs
diff --git a/src/ServiceControl/HeartbeatMonitoring/RegisterEndpointStartupHandler.cs b/src/ServiceControl/HeartbeatMonitoring/RegisterEndpointStartupHandler.cs
diff --git a/src/ServiceControl/HeartbeatMonitoring/RegisterPotentiallyMissingHeartbeatsHandler.cs b/src/ServiceControl/HeartbeatMonitoring/RegisterPotentiallyMissingHeartbeatsHandler.cs
diff --git a/src/ServiceControl/HeartbeatMonitoring/SaveHeartbeatHandler.cs b/src/ServiceControl/HeartbeatMonitoring/SaveHeartbeatHandler.cs
diff --git a/src/ServiceControl/Operations/EndpointDetailsParser.cs b/src/ServiceControl/Operations/EndpointDetailsParser.cs
diff --git a/src/ServiceControl/Operations/UpdateLicenseEnricher.cs b/src/ServiceControl/Operations/UpdateLicenseEnricher.cs
diff --git a/src/ServiceControl/ServiceControl.csproj b/src/ServiceControl/ServiceControl.csproj

Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,12 @@ public class EndpointsView`
`7`	`7`	`public Guid Id { get; set; }`
`8`	`8`	`public string Name { get; set; }`
`9`	`9`	`public string HostDisplayName { get; set; }`
	`10`	`+`
	`11`	`+ public bool Monitored { get; set; }`
	`12`	`+`
`10`	`13`	`public bool MonitorHeartbeat { get; set; }`
`11`	`14`	`public string LicenseStatus { get; set; }`
`12`	`15`	`public HeartbeatInformation HeartbeatInformation { get; set; }`
	`16`	`+ public bool IsSendingHeartbeats { get; set; }`
`13`	`17`	`}`
`14`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ public GetEndpoints()`
`39`	`39`	`return HttpStatusCode.NotFound;`
`40`	`40`	`}`
`41`	`41`
`42`		`- if (data.MonitorHeartbeat == endpoint.MonitorHeartbeat)`
	`42`	`+ if (data.MonitorHeartbeat == endpoint.Monitored)`
`43`	`43`	`{`
`44`	`44`	`return HttpStatusCode.NotModified;`
`45`	`45`	`}`
`@@ -79,7 +79,8 @@ public GetEndpoints()`
`79`	`79`	`Id = knownEndpoint.Id,`
`80`	`80`	`Name = knownEndpoint.EndpointDetails.Name,`
`81`	`81`	`HostDisplayName = knownEndpoint.HostDisplayName,`
`82`		`- MonitorHeartbeat = knownEndpoint.MonitorHeartbeat,`
	`82`	`+ Monitored = knownEndpoint.Monitored,`
	`83`	`+ MonitorHeartbeat = true,`
`83`	`84`	`LicenseStatus = LicenseStatusKeeper.Get(knownEndpoint.EndpointDetails.Name + knownEndpoint.HostDisplayName)`
`84`	`85`	`};`
`85`	`86`
`@@ -91,6 +92,10 @@ public GetEndpoints()`
`91`	`92`	`return;`
`92`	`93`	`}`
`93`	`94`
	`95`	`+ view.IsSendingHeartbeats = true;`
	`96`	`+`
	`97`	`+ view.MonitorHeartbeat = !heartbeat.Disabled;`
	`98`	`+`
`94`	`99`	`view.HeartbeatInformation =`
`95`	`100`	`new HeartbeatInformation`
`96`	`101`	`{`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public KnownEndpointIndex()`
`13`	`13`	`{`
`14`	`14`	`EndpointDetails = message.EndpointDetails,`
`15`	`15`	`HostDisplayName = message.HostDisplayName,`
`16`		`- MonitorHeartbeat = message.MonitorHeartbeat,`
	`16`	`+ Monitored = message.Monitored,`
`17`	`17`	`};`
`18`	`18`
`19`	`19`	`DisableInMemoryIndexing = true;`
Original file line number	Diff line number	Diff line change
`@@ -21,13 +21,13 @@ public void Handle(EnableEndpointMonitoring message)`
`21`	`21`	`throw new Exception("No endpoint with found with id: " + message.EndpointId);`
`22`	`22`	`}`
`23`	`23`
`24`		`- knownEndpoint.MonitorHeartbeat = true;`
	`24`	`+ knownEndpoint.Monitored = true;`
`25`	`25`
`26`	`26`	`Session.Store(knownEndpoint);`
`27`	`27`
`28`	`28`	`Bus.Publish(new MonitoringEnabledForEndpoint`
`29`	`29`	`{`
`30`		`- EndpointId = message.EndpointId,`
	`30`	`+ EndpointInstanceId = message.EndpointId,`
`31`	`31`	`Endpoint = knownEndpoint.EndpointDetails`
`32`	`32`	`});`
`33`	`33`	`}`
`@@ -41,13 +41,13 @@ public void Handle(DisableEndpointMonitoring message)`
`41`	`41`	`throw new Exception("No endpoint with found with id: " + message.EndpointId);`
`42`	`42`	`}`
`43`	`43`
`44`		`- knownEndpoint.MonitorHeartbeat = false;`
	`44`	`+ knownEndpoint.Monitored = false;`
`45`	`45`
`46`	`46`	`Session.Store(knownEndpoint);`
`47`	`47`
`48`	`48`	`Bus.Publish(new MonitoringDisabledForEndpoint`
`49`	`49`	`{`
`50`		`- EndpointId = message.EndpointId,`
	`50`	`+ EndpointInstanceId = message.EndpointId,`
`51`	`51`	`Endpoint = knownEndpoint.EndpointDetails`
`52`	`52`	`});`
`53`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,12 @@`
`1`		`-namespace ServiceControl.Contracts.HeartbeatMonitoring`
	`1`	`+namespace ServiceControl.Contracts.EndpointControl`
`2`	`2`	`{`
`3`	`3`	`using System;`
`4`	`4`	`using NServiceBus;`
	`5`	`+ using Operations;`
`5`	`6`
`6`	`7`	`public class EndpointStarted : IEvent`
`7`	`8`	`{`
`8`		`- public Guid HostId { get; set; }`
`9`		`- public string Endpoint { get; set; }`
	`9`	`+ public EndpointDetails EndpointDetails { get; set; }`
`10`	`10`	`public DateTime StartedAt { get; set; }`
`11`	`11`	`}`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ namespace ServiceControl.EndpointControl.Contracts`
`6`	`6`
`7`	`7`	`public class MonitoringDisabledForEndpoint : IEvent`
`8`	`8`	`{`
`9`		`- public Guid EndpointId { get; set; }`
	`9`	`+ public Guid EndpointInstanceId { get; set; }`
`10`	`10`
`11`	`11`	`public EndpointDetails Endpoint { get; set; }`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ namespace ServiceControl.EndpointControl.Contracts`
`6`	`6`
`7`	`7`	`public class MonitoringEnabledForEndpoint : IEvent`
`8`	`8`	`{`
`9`		`- public Guid EndpointId { get; set; }`
	`9`	`+ public Guid EndpointInstanceId { get; set; }`
`10`	`10`
`11`	`11`	`public EndpointDetails Endpoint { get; set; }`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,9 @@`
`1`	`1`	`namespace ServiceControl.Contracts.HeartbeatMonitoring`
`2`	`2`	`{`
`3`	`3`	`using System;`
`4`		`- using NServiceBus;`
`5`	`4`	`using Operations;`
`6`	`5`
`7`		`- public class EndpointFailedToHeartbeat : IEvent`
	`6`	`+ public class EndpointFailedToHeartbeat : HeartbeatStatusChanged`
`8`	`7`	`{`
`9`	`8`	`public EndpointDetails Endpoint { get; set; }`
`10`	`9`	`public DateTime LastReceivedAt { get; set; }`