Add LogContext to IntegrationEventHandlers

src/Services/Basket/Basket.API/Controllers/BasketController.cs

@@ -78,8 +78,6 @@ namespace Microsoft.eShopOnContainers.Services.Basket.API.Controllers
             // Once basket is checkout, sends an integration event to
             // ordering.api to convert basket to order and proceeds with
             // order creation process
-            using (LogContext.PushProperty("IntegrationEventId", eventMessage.Id))
-            {
             try
             {
                 _logger.LogInformation("----- Publishing integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", eventMessage.Id, Program.AppShortName, eventMessage);
@@ -92,7 +90,6 @@ namespace Microsoft.eShopOnContainers.Services.Basket.API.Controllers
 
                 throw;
             }
-            }
 
             return Accepted();
         }

src/Services/Basket/Basket.API/IntegrationEvents/EventHandling/OrderStartedIntegrationEventHandler.cs

@@ -1,6 +1,9 @@
 using Basket.API.IntegrationEvents.Events;
 using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions;
+using Microsoft.eShopOnContainers.Services.Basket.API;
 using Microsoft.eShopOnContainers.Services.Basket.API.Model;
+using Microsoft.Extensions.Logging;
+using Serilog.Context;
 using System;
 using System.Threading.Tasks;
 
@@ -9,18 +12,27 @@ namespace Basket.API.IntegrationEvents.EventHandling
     public class OrderStartedIntegrationEventHandler : IIntegrationEventHandler<OrderStartedIntegrationEvent>
     {
         private readonly IBasketRepository _repository;
+        private readonly ILogger<OrderStartedIntegrationEventHandler> _logger;
 
-        public OrderStartedIntegrationEventHandler(IBasketRepository repository)
+        public OrderStartedIntegrationEventHandler(
+            IBasketRepository repository,
+            ILogger<OrderStartedIntegrationEventHandler> logger)
         {
             _repository = repository ?? throw new ArgumentNullException(nameof(repository));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
 
         public async Task Handle(OrderStartedIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 await _repository.DeleteBasketAsync(@event.UserId.ToString());
             }
         }
     }
+}
 
 
 

src/Services/Basket/Basket.API/IntegrationEvents/EventHandling/ProductPriceChangedIntegrationEventHandler.cs

@@ -24,7 +24,7 @@ namespace Microsoft.eShopOnContainers.Services.Basket.API.IntegrationEvents.Even
 
         public async Task Handle(ProductPriceChangedIntegrationEvent @event)
         {
-            using (LogContext.PushProperty("IntegrationEventId", @event.Id))
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
             {
                 _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
 

src/Services/Catalog/Catalog.API/IntegrationEvents/CatalogIntegrationEventService.cs

@@ -36,12 +36,10 @@ namespace Catalog.API.IntegrationEvents
         }
 
         public async Task PublishThroughEventBusAsync(IntegrationEvent evt)
-        {
-            using (LogContext.PushProperty("IntegrationEventId", evt.Id))
         {
             try
             {
-                    _logger.LogInformation("----- Publishing integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", evt.Id, Program.AppShortName, evt);
+                _logger.LogInformation("----- Publishing integration event: {IntegrationEventId_published} at {AppShortName} - ({@IntegrationEvent})", evt.Id, Program.AppShortName, evt);
 
                 await _eventLogService.MarkEventAsInProgressAsync(evt.Id);
                 _eventBus.Publish(evt);
@@ -53,11 +51,8 @@ namespace Catalog.API.IntegrationEvents
                 await _eventLogService.MarkEventAsFailedAsync(evt.Id);
             }
         }
-        }
 
         public async Task SaveEventAndCatalogContextChangesAsync(IntegrationEvent evt)
-        {
-            using (LogContext.PushProperty("IntegrationEventId", evt.Id))
         {
             _logger.LogInformation("----- CatalogIntegrationEventService - Saving changes and integrationEvent: {IntegrationEventId}", evt.Id);
 
@@ -72,4 +67,3 @@ namespace Catalog.API.IntegrationEvents
         }
     }
 }
-}

src/Services/Catalog/Catalog.API/IntegrationEvents/EventHandling/OrderStatusChangedToAwaitingValidationIntegrationEventHandler.cs

@@ -8,25 +8,35 @@
     using System.Linq;
     using global::Catalog.API.IntegrationEvents;
     using IntegrationEvents.Events;
+    using Serilog.Context;
+    using Microsoft.Extensions.Logging;
 
     public class OrderStatusChangedToAwaitingValidationIntegrationEventHandler : 
         IIntegrationEventHandler<OrderStatusChangedToAwaitingValidationIntegrationEvent>
     {
         private readonly CatalogContext _catalogContext;
         private readonly ICatalogIntegrationEventService _catalogIntegrationEventService;
+        private readonly ILogger<OrderStatusChangedToAwaitingValidationIntegrationEventHandler> _logger;
 
-        public OrderStatusChangedToAwaitingValidationIntegrationEventHandler(CatalogContext catalogContext,
+        public OrderStatusChangedToAwaitingValidationIntegrationEventHandler(
-            ICatalogIntegrationEventService catalogIntegrationEventService)
+            CatalogContext catalogContext,
+            ICatalogIntegrationEventService catalogIntegrationEventService,
+            ILogger<OrderStatusChangedToAwaitingValidationIntegrationEventHandler> logger)
         {
             _catalogContext = catalogContext;
             _catalogIntegrationEventService = catalogIntegrationEventService;
+            _logger = logger ?? throw new System.ArgumentNullException(nameof(logger));
         }
 
-        public async Task Handle(OrderStatusChangedToAwaitingValidationIntegrationEvent command)
+        public async Task Handle(OrderStatusChangedToAwaitingValidationIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 var confirmedOrderStockItems = new List<ConfirmedOrderStockItem>();
 
-            foreach (var orderStockItem in command.OrderStockItems)
+                foreach (var orderStockItem in @event.OrderStockItems)
                 {
                     var catalogItem = _catalogContext.CatalogItems.Find(orderStockItem.ProductId);
                     var hasStock = catalogItem.AvailableStock >= orderStockItem.Units;
@@ -36,11 +46,13 @@
                 }
 
                 var confirmedIntegrationEvent = confirmedOrderStockItems.Any(c => !c.HasStock)
-                ? (IntegrationEvent) new OrderStockRejectedIntegrationEvent(command.OrderId, confirmedOrderStockItems)
+                    ? (IntegrationEvent)new OrderStockRejectedIntegrationEvent(@event.OrderId, confirmedOrderStockItems)
-                : new OrderStockConfirmedIntegrationEvent(command.OrderId);
+                    : new OrderStockConfirmedIntegrationEvent(@event.OrderId);
 
                 await _catalogIntegrationEventService.SaveEventAndCatalogContextChangesAsync(confirmedIntegrationEvent);
                 await _catalogIntegrationEventService.PublishThroughEventBusAsync(confirmedIntegrationEvent);
+
+            }
         }
     }
 }

src/Services/Catalog/Catalog.API/IntegrationEvents/EventHandling/OrderStatusChangedToPaidIntegrationEventHandler.cs

@@ -4,21 +4,31 @@
     using System.Threading.Tasks;
     using Infrastructure;
     using Microsoft.eShopOnContainers.Services.Catalog.API.IntegrationEvents.Events;
+    using Microsoft.Extensions.Logging;
+    using Serilog.Context;
 
     public class OrderStatusChangedToPaidIntegrationEventHandler : 
         IIntegrationEventHandler<OrderStatusChangedToPaidIntegrationEvent>
     {
         private readonly CatalogContext _catalogContext;
+        private readonly ILogger<OrderStatusChangedToPaidIntegrationEventHandler> _logger;
 
-        public OrderStatusChangedToPaidIntegrationEventHandler(CatalogContext catalogContext)
+        public OrderStatusChangedToPaidIntegrationEventHandler(
+            CatalogContext catalogContext,
+            ILogger<OrderStatusChangedToPaidIntegrationEventHandler> logger)
         {
             _catalogContext = catalogContext;
+            _logger = logger ?? throw new System.ArgumentNullException(nameof(logger));
         }
 
-        public async Task Handle(OrderStatusChangedToPaidIntegrationEvent command)
+        public async Task Handle(OrderStatusChangedToPaidIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 //we're not blocking stock/inventory
-            foreach (var orderStockItem in command.OrderStockItems)
+                foreach (var orderStockItem in @event.OrderStockItems)
                 {
                     var catalogItem = _catalogContext.CatalogItems.Find(orderStockItem.ProductId);
 
@@ -26,6 +36,8 @@
                 }
 
                 await _catalogContext.SaveChangesAsync();
+
+            }
         }
     }
 }

src/Services/Marketing/Marketing.API/IntegrationEvents/Handlers/UserLocationUpdatedIntegrationEventHandler.cs

@@ -4,6 +4,8 @@
     using Marketing.API.Model;
     using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions;
     using Microsoft.eShopOnContainers.Services.Marketing.API.Infrastructure.Repositories;
+    using Microsoft.Extensions.Logging;
+    using Serilog.Context;
     using System;
     using System.Collections.Generic;
     using System.Threading.Tasks;
@@ -12,14 +14,22 @@
         : IIntegrationEventHandler<UserLocationUpdatedIntegrationEvent>
     {
         private readonly IMarketingDataRepository _marketingDataRepository;
+        private readonly ILogger<UserLocationUpdatedIntegrationEventHandler> _logger;
 
-        public UserLocationUpdatedIntegrationEventHandler(IMarketingDataRepository repository)
+        public UserLocationUpdatedIntegrationEventHandler(
+            IMarketingDataRepository repository,
+            ILogger<UserLocationUpdatedIntegrationEventHandler> logger)
         {
             _marketingDataRepository = repository ?? throw new ArgumentNullException(nameof(repository));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
 
         public async Task Handle(UserLocationUpdatedIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 var userMarketingData = await _marketingDataRepository.GetAsync(@event.UserId);
                 userMarketingData = userMarketingData ??
                     new MarketingData() { UserId = @event.UserId };
@@ -27,6 +37,7 @@
                 userMarketingData.Locations = MapUpdatedUserLocations(@event.LocationList);
                 await _marketingDataRepository.UpdateLocationAsync(userMarketingData);
             }
+        }
 
         private List<Location> MapUpdatedUserLocations(List<UserLocationDetails> newUserLocations)
         {

src/Services/Marketing/Marketing.API/Program.cs

@@ -13,7 +13,7 @@
     public class Program
     {
         public static readonly string AppName = typeof(Program).Namespace;
-        public static readonly string ShortAppName = AppName.Substring(AppName.LastIndexOf('.', AppName.LastIndexOf('.') - 1) + 1);
+        public static readonly string AppShortName = AppName.Substring(AppName.LastIndexOf('.', AppName.LastIndexOf('.') - 1) + 1);
 
         public static int Main(string[] args)
         {

src/Services/Ordering/Ordering.API/Application/Behaviors/BehaviorsHelperExtensions.cs

@@ -7,7 +7,7 @@ namespace Ordering.API.Application.Behaviors
 {
     internal static class BehaviorsHelperExtensions
     {
-        internal static string GetTypeName(this object @object)
+        internal static string GetGenericTypeName(this object @object)
         {
             var typeName = string.Empty;
             var type = @object.GetType();

src/Services/Ordering/Ordering.API/Application/Behaviors/LoggingBehavior.cs

@@ -13,9 +13,9 @@ namespace Ordering.API.Application.Behaviors
 
         public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
         {
-            _logger.LogInformation("----- Handling command {CommandName} ({@Command})", request.GetTypeName(), request);
+            _logger.LogInformation("----- Handling command {CommandName} ({@Command})", request.GetGenericTypeName(), request);
             var response = await next();
-            _logger.LogInformation("----- Command {CommandName} handled - response: {@Response}", request.GetTypeName(), response);
+            _logger.LogInformation("----- Command {CommandName} handled - response: {@Response}", request.GetGenericTypeName(), response);
 
             return response;
         }

src/Services/Ordering/Ordering.API/Application/Behaviors/TransactionBehaviour.cs

@@ -27,7 +27,7 @@ namespace Ordering.API.Application.Behaviors
         public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
         {
             TResponse response = default(TResponse);
-            var typeName = request.GetTypeName();
+            var typeName = request.GetGenericTypeName();
 
             try
             {

src/Services/Ordering/Ordering.API/Application/Behaviors/ValidatorBehavior.cs

@@ -21,7 +21,7 @@ namespace Ordering.API.Application.Behaviors
 
         public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
         {
-            var typeName = request.GetTypeName();
+            var typeName = request.GetGenericTypeName();
 
             _logger.LogInformation("----- Validating command {CommandType}", typeName);
 

src/Services/Ordering/Ordering.API/Application/IntegrationEvents/EventHandling/GracePeriodConfirmedIntegrationEventHandler.cs

@@ -1,8 +1,11 @@
 using MediatR;
 using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions;
+using Microsoft.eShopOnContainers.Services.Ordering.API;
 using Microsoft.eShopOnContainers.Services.Ordering.Domain.AggregatesModel.OrderAggregate;
+using Microsoft.Extensions.Logging;
 using Ordering.API.Application.Commands;
 using Ordering.API.Application.IntegrationEvents.Events;
+using Serilog.Context;
 using System.Threading.Tasks;
 
 namespace Ordering.API.Application.IntegrationEvents.EventHandling
@@ -10,10 +13,14 @@ namespace Ordering.API.Application.IntegrationEvents.EventHandling
     public class GracePeriodConfirmedIntegrationEventHandler : IIntegrationEventHandler<GracePeriodConfirmedIntegrationEvent>
     {
         private readonly IMediator _mediator;
+        private readonly ILogger<GracePeriodConfirmedIntegrationEventHandler> _logger;
 
-        public GracePeriodConfirmedIntegrationEventHandler(IMediator mediator)
+        public GracePeriodConfirmedIntegrationEventHandler(
+            IMediator mediator,
+            ILogger<GracePeriodConfirmedIntegrationEventHandler> logger)
         {
             _mediator = mediator;
+            _logger = logger ?? throw new System.ArgumentNullException(nameof(logger));
         }
 
         /// <summary>
@@ -26,8 +33,13 @@ namespace Ordering.API.Application.IntegrationEvents.EventHandling
         /// <returns></returns>
         public async Task Handle(GracePeriodConfirmedIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 var command = new SetAwaitingValidationOrderStatusCommand(@event.OrderId);
                 await _mediator.Send(command);
             }
         }
     }
+}

src/Services/Ordering/Ordering.API/Application/IntegrationEvents/EventHandling/OrderPaymentFailedIntegrationEventHandler.cs

@@ -2,9 +2,12 @@
 {
     using MediatR;
     using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions;
+    using Microsoft.eShopOnContainers.Services.Ordering.API;
     using Microsoft.eShopOnContainers.Services.Ordering.Domain.AggregatesModel.OrderAggregate;
+    using Microsoft.Extensions.Logging;
     using Ordering.API.Application.Commands;
     using Ordering.API.Application.IntegrationEvents.Events;
+    using Serilog.Context;
     using System;
     using System.Threading.Tasks;
 
@@ -12,16 +15,25 @@
         IIntegrationEventHandler<OrderPaymentFailedIntegrationEvent>
     {
         private readonly IMediator _mediator;
+        private readonly ILogger<OrderPaymentFailedIntegrationEventHandler> _logger;
 
-        public OrderPaymentFailedIntegrationEventHandler(IMediator mediator)
+        public OrderPaymentFailedIntegrationEventHandler(
+            IMediator mediator,
+            ILogger<OrderPaymentFailedIntegrationEventHandler> logger)
         {
             _mediator = mediator ?? throw new ArgumentNullException(nameof(mediator));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
 
         public async Task Handle(OrderPaymentFailedIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 var command = new CancelOrderCommand(@event.OrderId);
                 await _mediator.Send(command);
             }
         }
     }
+}

src/Services/Ordering/Ordering.API/Application/IntegrationEvents/EventHandling/OrderPaymentSuccededIntegrationEventHandler.cs

@@ -2,9 +2,12 @@
 {
     using MediatR;
     using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions;
+    using Microsoft.eShopOnContainers.Services.Ordering.API;
     using Microsoft.eShopOnContainers.Services.Ordering.Domain.AggregatesModel.OrderAggregate;
+    using Microsoft.Extensions.Logging;
     using Ordering.API.Application.Commands;
     using Ordering.API.Application.IntegrationEvents.Events;
+    using Serilog.Context;
     using System;
     using System.Threading.Tasks;
 
@@ -12,16 +15,25 @@
         IIntegrationEventHandler<OrderPaymentSuccededIntegrationEvent>
     {
         private readonly IMediator _mediator;
+        private readonly ILogger<OrderPaymentSuccededIntegrationEventHandler> _logger;
 
-        public OrderPaymentSuccededIntegrationEventHandler(IMediator mediator)
+        public OrderPaymentSuccededIntegrationEventHandler(
+            IMediator mediator,
+            ILogger<OrderPaymentSuccededIntegrationEventHandler> logger)
         {
             _mediator = mediator ?? throw new ArgumentNullException(nameof(mediator));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
 
         public async Task Handle(OrderPaymentSuccededIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 var command = new SetPaidOrderStatusCommand(@event.OrderId);
                 await _mediator.Send(command);
             }
         }
     }
+}

src/Services/Ordering/Ordering.API/Application/IntegrationEvents/EventHandling/OrderStockConfirmedIntegrationEventHandler.cs

@@ -7,21 +7,33 @@
     using MediatR;
     using System;
     using Ordering.API.Application.Commands;
+    using Microsoft.Extensions.Logging;
+    using Serilog.Context;
+    using Microsoft.eShopOnContainers.Services.Ordering.API;
 
     public class OrderStockConfirmedIntegrationEventHandler :
         IIntegrationEventHandler<OrderStockConfirmedIntegrationEvent>
     {
         private readonly IMediator _mediator;
+        private readonly ILogger<OrderStockConfirmedIntegrationEventHandler> _logger;
 
-        public OrderStockConfirmedIntegrationEventHandler(IMediator mediator)
+        public OrderStockConfirmedIntegrationEventHandler(
+            IMediator mediator,
+            ILogger<OrderStockConfirmedIntegrationEventHandler> logger)
         {
             _mediator = mediator ?? throw new ArgumentNullException(nameof(mediator));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
 
         public async Task Handle(OrderStockConfirmedIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 var command = new SetStockConfirmedOrderStatusCommand(@event.OrderId);
                 await _mediator.Send(command);
             }
         }
     }
+}

src/Services/Ordering/Ordering.API/Application/IntegrationEvents/EventHandling/OrderStockRejectedIntegrationEventHandler.cs

@@ -7,18 +7,29 @@
     using Microsoft.eShopOnContainers.Services.Ordering.Domain.AggregatesModel.OrderAggregate;
     using MediatR;
     using Ordering.API.Application.Commands;
+    using Microsoft.Extensions.Logging;
+    using Serilog.Context;
+    using Microsoft.eShopOnContainers.Services.Ordering.API;
 
     public class OrderStockRejectedIntegrationEventHandler : IIntegrationEventHandler<OrderStockRejectedIntegrationEvent>
     {
         private readonly IMediator _mediator;
+        private readonly ILogger<OrderStockRejectedIntegrationEventHandler> _logger;
 
-        public OrderStockRejectedIntegrationEventHandler(IMediator mediator)
+        public OrderStockRejectedIntegrationEventHandler(
+            IMediator mediator,
+            ILogger<OrderStockRejectedIntegrationEventHandler> logger)
         {
             _mediator = mediator;
+            _logger = logger ?? throw new System.ArgumentNullException(nameof(logger));
         }
 
         public async Task Handle(OrderStockRejectedIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 var orderStockRejectedItems = @event.OrderStockItems
                     .FindAll(c => !c.HasStock)
                     .Select(c => c.ProductId)
@@ -29,3 +40,4 @@
             }
         }
     }
+}

src/Services/Ordering/Ordering.API/Application/IntegrationEvents/EventHandling/UserCheckoutAcceptedIntegrationEventHandler.cs

@@ -26,30 +26,30 @@ namespace Ordering.API.Application.IntegrationEvents.EventHandling
         /// <summary>
         /// Integration event handler which starts the create order process
         /// </summary>
-        /// <param name="eventMsg">
+        /// <param name="@event">
         /// Integration event message which is sent by the
         /// basket.api once it has successfully process the 
         /// order items.
         /// </param>
         /// <returns></returns>
-        public async Task Handle(UserCheckoutAcceptedIntegrationEvent eventMsg)
+        public async Task Handle(UserCheckoutAcceptedIntegrationEvent @event)
         {
-            using (LogContext.PushProperty("IntegrationEventId", eventMsg.Id))
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
             {
-                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", eventMsg.Id, Program.AppShortName, eventMsg);
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
 
                 var result = false;
 
-                if (eventMsg.RequestId != Guid.Empty)
+                if (@event.RequestId != Guid.Empty)
                 {
-                    using (LogContext.PushProperty("IdentifiedCommandId", eventMsg.RequestId))
+                    using (LogContext.PushProperty("IdentifiedCommandId", @event.RequestId))
                     {
-                        var createOrderCommand = new CreateOrderCommand(eventMsg.Basket.Items, eventMsg.UserId, eventMsg.UserName, eventMsg.City, eventMsg.Street,
+                        var createOrderCommand = new CreateOrderCommand(@event.Basket.Items, @event.UserId, @event.UserName, @event.City, @event.Street,
-                            eventMsg.State, eventMsg.Country, eventMsg.ZipCode,
+                            @event.State, @event.Country, @event.ZipCode,
-                            eventMsg.CardNumber, eventMsg.CardHolderName, eventMsg.CardExpiration,
+                            @event.CardNumber, @event.CardHolderName, @event.CardExpiration,
-                            eventMsg.CardSecurityNumber, eventMsg.CardTypeId);
+                            @event.CardSecurityNumber, @event.CardTypeId);
 
-                        var requestCreateOrder = new IdentifiedCommand<CreateOrderCommand, bool>(createOrderCommand, eventMsg.RequestId);
+                        var requestCreateOrder = new IdentifiedCommand<CreateOrderCommand, bool>(createOrderCommand, @event.RequestId);
 
                         _logger.LogInformation("----- IdentifiedCreateOrderCommand: {@IdentifiedCreateOrderCommand}", requestCreateOrder);
 
@@ -57,17 +57,17 @@ namespace Ordering.API.Application.IntegrationEvents.EventHandling
 
                         if (result)
                         {
-                            _logger.LogInformation("----- CreateOrderCommand suceeded - RequestId: {RequestId}", eventMsg.RequestId);
+                            _logger.LogInformation("----- CreateOrderCommand suceeded - RequestId: {RequestId}", @event.RequestId);
                         }
                         else
                         {
-                            _logger.LogWarning("----- CreateOrderCommand failed - RequestId: {RequestId}", eventMsg.RequestId);
+                            _logger.LogWarning("----- CreateOrderCommand failed - RequestId: {RequestId}", @event.RequestId);
                         }
                     }
                 }
                 else
                 {
-                    _logger.LogWarning("----- Invalid IntegrationEvent - RequestId is missing - {@IntegrationEvent}", eventMsg);
+                    _logger.LogWarning("----- Invalid IntegrationEvent - RequestId is missing - {@IntegrationEvent}", @event);
                 }
             }
         }

src/Services/Ordering/Ordering.API/Application/IntegrationEvents/OrderingIntegrationEventService.cs

@@ -5,6 +5,7 @@ using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events;
 using Microsoft.eShopOnContainers.BuildingBlocks.IntegrationEventLogEF;
 using Microsoft.eShopOnContainers.BuildingBlocks.IntegrationEventLogEF.Services;
 using Microsoft.eShopOnContainers.BuildingBlocks.IntegrationEventLogEF.Utilities;
+using Microsoft.eShopOnContainers.Services.Ordering.API;
 using Microsoft.eShopOnContainers.Services.Ordering.Infrastructure;
 using Microsoft.Extensions.Logging;
 using System;
@@ -44,7 +45,7 @@ namespace Ordering.API.Application.IntegrationEvents
 
             foreach (var logEvt in pendindLogEvents)
             {
-                _logger.LogInformation("----- Publishing integration event {IntegrationEventId} ({@IntegrationEvent})", logEvt.EventId, logEvt);
+                _logger.LogInformation("----- Publishing integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", logEvt.EventId, Program.AppShortName, logEvt);
 
                 try
                 {

src/Services/Ordering/Ordering.SignalrHub/IntegrationEvents/EventHandling/OrderStatusChangedToCancelledIntegrationEventHandler.cs

@@ -1,6 +1,8 @@
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions;
+using Microsoft.Extensions.Logging;
 using Ordering.SignalrHub.IntegrationEvents.Events;
+using Serilog.Context;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -11,18 +13,27 @@ namespace Ordering.SignalrHub.IntegrationEvents.EventHandling
     public class OrderStatusChangedToCancelledIntegrationEventHandler : IIntegrationEventHandler<OrderStatusChangedToCancelledIntegrationEvent>
     {
         private readonly IHubContext<NotificationsHub> _hubContext;
+        private readonly ILogger<OrderStatusChangedToCancelledIntegrationEventHandler> _logger;
 
-        public OrderStatusChangedToCancelledIntegrationEventHandler(IHubContext<NotificationsHub> hubContext)
+        public OrderStatusChangedToCancelledIntegrationEventHandler(
+            IHubContext<NotificationsHub> hubContext,
+            ILogger<OrderStatusChangedToCancelledIntegrationEventHandler> logger)
         {
             _hubContext = hubContext ?? throw new ArgumentNullException(nameof(hubContext));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
 
 
         public async Task Handle(OrderStatusChangedToCancelledIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 await _hubContext.Clients
                     .Group(@event.BuyerName)
                     .SendAsync("UpdatedOrderState", new { OrderId = @event.OrderId, Status = @event.OrderStatus });
             }
         }
     }
+}

src/Services/Ordering/Ordering.SignalrHub/IntegrationEvents/EventHandling/OrderStatusChangedToPaidIntegrationEventHandler.cs

@@ -1,6 +1,8 @@
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions;
+using Microsoft.Extensions.Logging;
 using Ordering.SignalrHub.IntegrationEvents.Events;
+using Serilog.Context;
 using System;
 using System.Threading.Tasks;
 
@@ -9,18 +11,27 @@ namespace Ordering.SignalrHub.IntegrationEvents.EventHandling
     public class OrderStatusChangedToPaidIntegrationEventHandler : IIntegrationEventHandler<OrderStatusChangedToPaidIntegrationEvent>
     {
         private readonly IHubContext<NotificationsHub> _hubContext;
+        private readonly ILogger<OrderStatusChangedToPaidIntegrationEventHandler> _logger;
 
-        public OrderStatusChangedToPaidIntegrationEventHandler(IHubContext<NotificationsHub> hubContext)
+        public OrderStatusChangedToPaidIntegrationEventHandler(
+            IHubContext<NotificationsHub> hubContext,
+            ILogger<OrderStatusChangedToPaidIntegrationEventHandler> logger)
         {
             _hubContext = hubContext ?? throw new ArgumentNullException(nameof(hubContext));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
 
 
         public async Task Handle(OrderStatusChangedToPaidIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 await _hubContext.Clients
                     .Group(@event.BuyerName)
                     .SendAsync("UpdatedOrderState", new { OrderId = @event.OrderId, Status = @event.OrderStatus });
             }
         }
     }
+}

src/Services/Ordering/Ordering.SignalrHub/IntegrationEvents/EventHandling/OrderStatusChangedToShippedIntegrationEventHandler.cs

@@ -1,6 +1,8 @@
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions;
+using Microsoft.Extensions.Logging;
 using Ordering.SignalrHub.IntegrationEvents.Events;
+using Serilog.Context;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -11,18 +13,27 @@ namespace Ordering.SignalrHub.IntegrationEvents.EventHandling
     public class OrderStatusChangedToShippedIntegrationEventHandler : IIntegrationEventHandler<OrderStatusChangedToShippedIntegrationEvent>
     {
         private readonly IHubContext<NotificationsHub> _hubContext;
+        private readonly ILogger<OrderStatusChangedToShippedIntegrationEventHandler> _logger;
 
-        public OrderStatusChangedToShippedIntegrationEventHandler(IHubContext<NotificationsHub> hubContext)
+        public OrderStatusChangedToShippedIntegrationEventHandler(
+            IHubContext<NotificationsHub> hubContext,
+            ILogger<OrderStatusChangedToShippedIntegrationEventHandler> logger)
         {
             _hubContext = hubContext ?? throw new ArgumentNullException(nameof(hubContext));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
 
 
         public async Task Handle(OrderStatusChangedToShippedIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 await _hubContext.Clients
                     .Group(@event.BuyerName)
                     .SendAsync("UpdatedOrderState", new { OrderId = @event.OrderId, Status = @event.OrderStatus });
             }
         }
     }
+}

src/Services/Ordering/Ordering.SignalrHub/IntegrationEvents/EventHandling/OrderStatusChangedToStockConfirmedIntegrationEventHandler.cs

@@ -1,6 +1,8 @@
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions;
+using Microsoft.Extensions.Logging;
 using Ordering.SignalrHub.IntegrationEvents.Events;
+using Serilog.Context;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -12,18 +14,27 @@ namespace Ordering.SignalrHub.IntegrationEvents.EventHandling
         IIntegrationEventHandler<OrderStatusChangedToStockConfirmedIntegrationEvent>
     {
         private readonly IHubContext<NotificationsHub> _hubContext;
+        private readonly ILogger<OrderStatusChangedToStockConfirmedIntegrationEventHandler> _logger;
 
-        public OrderStatusChangedToStockConfirmedIntegrationEventHandler(IHubContext<NotificationsHub> hubContext)
+        public OrderStatusChangedToStockConfirmedIntegrationEventHandler(
+            IHubContext<NotificationsHub> hubContext,
+            ILogger<OrderStatusChangedToStockConfirmedIntegrationEventHandler> logger)
         {
             _hubContext = hubContext ?? throw new ArgumentNullException(nameof(hubContext));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
 
 
         public async Task Handle(OrderStatusChangedToStockConfirmedIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 await _hubContext.Clients
                     .Group(@event.BuyerName)
                     .SendAsync("UpdatedOrderState", new { OrderId = @event.OrderId, Status = @event.OrderStatus });
             }
         }
     }
+}

src/Services/Ordering/Ordering.SignalrHub/IntegrationEvents/EventHandling/OrderStatusChangedToSubmittedIntegrationEventHandler.cs

@@ -1,6 +1,8 @@
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions;
+using Microsoft.Extensions.Logging;
 using Ordering.SignalrHub.IntegrationEvents.Events;
+using Serilog.Context;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -12,18 +14,27 @@ namespace Ordering.SignalrHub.IntegrationEvents.EventHandling
         IIntegrationEventHandler<OrderStatusChangedToSubmittedIntegrationEvent>
     {
         private readonly IHubContext<NotificationsHub> _hubContext;
+        private readonly ILogger<OrderStatusChangedToSubmittedIntegrationEventHandler> _logger;
 
-        public OrderStatusChangedToSubmittedIntegrationEventHandler(IHubContext<NotificationsHub> hubContext)
+        public OrderStatusChangedToSubmittedIntegrationEventHandler(
+            IHubContext<NotificationsHub> hubContext,
+            ILogger<OrderStatusChangedToSubmittedIntegrationEventHandler> logger)
         {
             _hubContext = hubContext ?? throw new ArgumentNullException(nameof(hubContext));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
 
 
         public async Task Handle(OrderStatusChangedToSubmittedIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 await _hubContext.Clients
                     .Group(@event.BuyerName)
                     .SendAsync("UpdatedOrderState", new { OrderId = @event.OrderId, Status = @event.OrderStatus });
             }
         }
     }
+}

src/Services/Ordering/Ordering.SignalrHub/IntegrationEvents/EventHandling/orderStatusChangedToAwaitingValidationIntegrationEventHandler.cs

@@ -1,5 +1,7 @@
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions;
+using Microsoft.Extensions.Logging;
+using Serilog.Context;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -10,18 +12,27 @@ namespace Ordering.SignalrHub.IntegrationEvents
     public class OrderStatusChangedToAwaitingValidationIntegrationEventHandler : IIntegrationEventHandler<OrderStatusChangedToAwaitingValidationIntegrationEvent>
     {
         private readonly IHubContext<NotificationsHub> _hubContext;
+        private readonly ILogger<OrderStatusChangedToAwaitingValidationIntegrationEventHandler> _logger;
 
-        public OrderStatusChangedToAwaitingValidationIntegrationEventHandler(IHubContext<NotificationsHub> hubContext)
+        public OrderStatusChangedToAwaitingValidationIntegrationEventHandler(
+            IHubContext<NotificationsHub> hubContext,
+            ILogger<OrderStatusChangedToAwaitingValidationIntegrationEventHandler> logger)
         {
             _hubContext = hubContext ?? throw new ArgumentNullException(nameof(hubContext));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
 
 
         public async Task Handle(OrderStatusChangedToAwaitingValidationIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 await _hubContext.Clients
                     .Group(@event.BuyerName)
                     .SendAsync("UpdatedOrderState", new { OrderId = @event.OrderId, Status = @event.OrderStatus });
             }
         }
     }
+}

src/Services/Payment/Payment.API/IntegrationEvents/EventHandling/OrderStatusChangedToStockConfirmedIntegrationEventHandler.cs

@@ -2,8 +2,10 @@
 {
     using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions;
     using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events;
+    using Microsoft.Extensions.Logging;
     using Microsoft.Extensions.Options;
     using Payment.API.IntegrationEvents.Events;
+    using Serilog.Context;
     using System.Threading.Tasks;
 
     public class OrderStatusChangedToStockConfirmedIntegrationEventHandler :
@@ -11,16 +13,24 @@
     {
         private readonly IEventBus _eventBus;
         private readonly PaymentSettings _settings;
+        private readonly ILogger<OrderStatusChangedToStockConfirmedIntegrationEventHandler> _logger;
 
-        public OrderStatusChangedToStockConfirmedIntegrationEventHandler(IEventBus eventBus, 
+        public OrderStatusChangedToStockConfirmedIntegrationEventHandler(
-            IOptionsSnapshot<PaymentSettings> settings)
+            IEventBus eventBus,
+            IOptionsSnapshot<PaymentSettings> settings,
+            ILogger<OrderStatusChangedToStockConfirmedIntegrationEventHandler> logger)
         {
             _eventBus = eventBus;
             _settings = settings.Value;
+            _logger = logger ?? throw new System.ArgumentNullException(nameof(logger));
         }
 
         public async Task Handle(OrderStatusChangedToStockConfirmedIntegrationEvent @event)
         {
+            using (LogContext.PushProperty("IntegrationEventId_Context", @event.Id))
+            {
+                _logger.LogInformation("----- Handling integration event: {IntegrationEventId} at {AppShortName} - ({@IntegrationEvent})", @event.Id, Program.AppShortName, @event);
+
                 IntegrationEvent orderPaymentIntegrationEvent;
 
                 //Business feature comment:
@@ -44,3 +54,4 @@
             }
         }
     }
+}

src/Services/Payment/Payment.API/Program.cs

@@ -12,7 +12,7 @@ namespace Payment.API
     public class Program
     {
         public static readonly string AppName = typeof(Program).Namespace;
-        public static readonly string ShortAppName = AppName.Substring(AppName.LastIndexOf('.', AppName.LastIndexOf('.') - 1) + 1);
+        public static readonly string AppShortName = AppName.Substring(AppName.LastIndexOf('.', AppName.LastIndexOf('.') - 1) + 1);
 
         public static int Main(string[] args)
         {