Move logs to its own controller

Author: Espen Gulbrandsen

src/Events.Functions/Models/LogEntryDto.cs

@@ -6,7 +6,7 @@ namespace Altinn.Platform.Events.Functions.Models
     /// <summary>
     /// Data transfer object for posting a log event after receiving a webhook response.
     /// </summary>
-    public class LogEntryDto
+    public record LogEntryDto
     {
         /// <summary>
         /// The cloud event id associated with the logged event

src/Events/Controllers/LogsController.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Threading.Tasks;
+
+using Altinn.Platform.Events.Models;
+using Altinn.Platform.Events.Services.Interfaces;
+
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Swashbuckle.AspNetCore.Annotations;
+
+namespace Altinn.Platform.Events.Controllers
+{
+    /// <summary>
+    /// Controller for logging event operations to persistence
+    /// </summary>
+    /// <param name="traceLogService">Service for logging event operations to persistence</param>
+    [Route("events/api/v1/storage/events/logs")]
+    [ApiController]
+    [SwaggerTag("Private API")]
+    public class LogsController(ITraceLogService traceLogService) : ControllerBase
+    {
+        private readonly ITraceLogService _traceLogService = traceLogService;
+
+        /// <summary>
+        /// Create a new trace log for cloud event with a status code.
+        /// </summary>
+        /// <param name="logEntry">The event wrapper associated with the event for logging <see cref="CloudEventEnvelope"/></param>
+        /// <returns></returns>
+        [Authorize(Policy = "PlatformAccess")]
+        [HttpPost]
+        [Consumes("application/json")]
+        [SwaggerResponse(201, Type = typeof(Guid))]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> Logs([FromBody] LogEntryDto logEntry)
+        {
+            var result = await _traceLogService.CreateWebhookResponseEntry(logEntry);
+
+            if (string.IsNullOrEmpty(result))
+            {
+                return BadRequest();
+            }
+
+            return Created();
+        }
+    }
+}

src/Events/Controllers/StorageController.cs

@@ -2,17 +2,14 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Threading.Tasks;
 
-using Altinn.Platform.Events.Models;
 using Altinn.Platform.Events.Services.Interfaces;
 
 using CloudNative.CloudEvents;
-
 using Microsoft.ApplicationInsights.DataContracts;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
-
 using Swashbuckle.AspNetCore.Annotations;
 
 namespace Altinn.Platform.Events.Controllers
@@ -26,20 +23,17 @@ namespace Altinn.Platform.Events.Controllers
     public class StorageController : ControllerBase
     {
         private readonly IEventsService _eventsService;
-        private readonly ITraceLogService _traceLogService;
         private readonly ILogger _logger;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="StorageController"/> class
         /// </summary>
         public StorageController(
             IEventsService eventsService,
-            ITraceLogService traceLogService,
             ILogger<StorageController> logger)
         {
             _logger = logger;
             _eventsService = eventsService;
-            _traceLogService = traceLogService;
         }
 
         /// <summary>
@@ -69,29 +63,6 @@ public async Task<ActionResult<string>> Post([FromBody] CloudEvent cloudEvent)
             }
         }
 
-        /// <summary>
-        /// Create a new trace log for cloud event with a status code.
-        /// </summary>
-        /// <param name="logEntry">The event wrapper associated with the event for logging <see cref="CloudEventEnvelope"/></param>
-        /// <returns></returns>
-        [Authorize(Policy = "PlatformAccess")]
-        [HttpPost("logs")]
-        [Consumes("application/json")]
-        [SwaggerResponse(201, Type = typeof(Guid))]
-        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
-        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        public async Task<IActionResult> Logs([FromBody] LogEntryDto logEntry)
-        {
-            var result = await _traceLogService.CreateWebhookResponseEntry(logEntry);
-
-            if (string.IsNullOrEmpty(result))
-            {
-                return BadRequest();
-            }
-
-            return Created();
-        }
-
         [ExcludeFromCodeCoverage]
         private void AddIdTelemetry(string id)
         {

src/Events/Models/LogEntryDto.cs

@@ -9,7 +9,7 @@ namespace Altinn.Platform.Events.Models
     /// <summary>
     /// Data transfer object for posting a log event after receiving a webhook response.
     /// </summary>
-    public class LogEntryDto
+    public record LogEntryDto
     {
         /// <summary>
         /// The cloud event id associated with the logged event <see cref="CloudEvent"/>"/>

src/Events/Services/TraceLogService.cs

@@ -46,7 +46,7 @@ public async Task<string> CreateRegisteredEntry(CloudEvent cloudEvent)
             }
             catch (Exception exception)
             {
-                _logger.LogError(exception, "Error creating trace log entry for registered event: {Message}", exception.Message);
+                _logger.LogError(exception, "Error creating trace log entry for registered event: {Message} {CloudEventId}", exception.Message, cloudEvent.Id);
 
                 // don't throw exception, we don't want to stop the event processing
                 return string.Empty;
@@ -77,7 +77,7 @@ public async Task<string> CreateLogEntryWithSubscriptionDetails(CloudEvent cloud
             }
             catch (Exception exception)
             {
-                _logger.LogError(exception, "Error creating trace log entry with subscription details: {Message}", exception.Message);
+                _logger.LogError(exception, "Error creating trace log entry with subscription details: {Message} {CloudEventId} {SubscriptionId} {Consumer}", exception.Message, cloudEvent.Id, subscription.Id, subscription.Consumer);
 
                 // don't throw exception, we don't want to stop the event processing
                 return string.Empty;

test/Altinn.Platform.Events.Tests/Models/LogEntryData.cs

@@ -0,0 +1,188 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+using Altinn.Common.AccessToken.Services;
+using Altinn.Common.PEP.Interfaces;
+using Altinn.Platform.Events.Controllers;
+using Altinn.Platform.Events.Models;
+using Altinn.Platform.Events.Services.Interfaces;
+using Altinn.Platform.Events.Tests.Mocks;
+using Altinn.Platform.Events.Tests.Mocks.Authentication;
+using Altinn.Platform.Events.Tests.Utils;
+using Altinn.Platform.Events.UnitTest.Mocks;
+using AltinnCore.Authentication.JwtCookie;
+
+using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using Moq;
+using Xunit;
+
+namespace Altinn.Platform.Events.Tests.TestingControllers;
+
+/// <summary>
+/// Reperesents a collection of integration tests.
+/// </summary>
+public partial class IntegrationTests
+{
+    /// <summary>
+    /// Test class for LogsController
+    /// </summary>
+    public class LogsControllerTests : IClassFixture<WebApplicationFactory<LogsController>>
+    {
+        private const string _basePath = "/events/api/v1";
+
+        private readonly WebApplicationFactory<LogsController> _factory;
+
+        private readonly Mock<ITraceLogService> _traceLogServiceMock = new();
+
+        public LogsControllerTests(WebApplicationFactory<LogsController> factory)
+        {
+            _factory = factory;
+        }
+
+        /// <summary>
+        /// Scenario:
+        ///   Post a request that results in an exception being thrown by the trace log service instance.
+        /// Expected result:
+        ///   Returns internal server error 500.
+        /// Success criteria:
+        ///   The response has correct status code.
+        /// </summary>
+        [Fact]
+        public async Task Logs_WhenExceptionIsThrownByTheService_IsCaughtAnd500IsReturned()
+        {
+            // Arrange
+            string requestUri = $"{_basePath}/storage/events/logs";
+            string responseId = Guid.NewGuid().ToString();
+
+            Mock<IEventsService> eventsService = new();
+            Mock<ITraceLogService> traceLogService = new();
+
+            traceLogService.Setup(x => x.CreateWebhookResponseEntry(It.IsAny<LogEntryDto>())).Throws(new Exception());
+
+            HttpClient client = GetTestClient(eventsService.Object, traceLogService.Object);
+            HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, requestUri)
+            {
+                Content = new StringContent(JsonSerializer.Serialize(new LogEntryDto()), Encoding.UTF8, "application/cloudevents+json")
+            };
+
+            httpRequestMessage.Headers.Add("PlatformAccessToken", PrincipalUtil.GetAccessToken("ttd", "endring-av-navn-v2"));
+
+            // Act
+            HttpResponseMessage response = await client.SendAsync(httpRequestMessage);
+
+            // Assert
+            Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
+        }
+
+        /// <summary>
+        /// Scenario: 
+        ///   A possibly invalid log entry is posted to the logs endpoint.
+        /// Expected result:
+        ///   400 Bad request is returned
+        /// Success criteria:
+        ///   Empty string returned from the service results in a bad request response
+        /// </summary>
+        /// <returns></returns>
+        [Fact]
+        public async Task Logs_WhenEmptyStringIsReturnedFromTheService_ReturnBadRequest()
+        {
+            // Arrange
+            string requestUri = $"{_basePath}/storage/events/logs";
+            string responseId = string.Empty;
+            Mock<IEventsService> eventsService = new();
+            Mock<ITraceLogService> traceLogService = new();
+            traceLogService.Setup(x => x.CreateWebhookResponseEntry(It.IsAny<LogEntryDto>())).ReturnsAsync(string.Empty);
+            HttpClient client = GetTestClient(eventsService.Object, traceLogService.Object);
+            HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, requestUri)
+            {
+                Content = new StringContent(JsonSerializer.Serialize(new LogEntryDto()), Encoding.UTF8, "application/cloudevents+json")
+            };
+            httpRequestMessage.Headers.Add("PlatformAccessToken", PrincipalUtil.GetAccessToken("ttd", "endring-av-navn-v2"));
+
+            // Act
+            HttpResponseMessage response = await client.SendAsync(httpRequestMessage);
+
+            // Assert
+            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        }
+
+        /// <summary>
+        /// Scenario:
+        ///   Post a valid logs request with a logEntryDto.
+        /// Expected result:
+        ///   Returns HttpStatus Ok.
+        /// Success criteria:
+        ///   The response has correct status code.
+        /// </summary>
+        [Fact]
+        public async Task Logs_ValidLogEntryDto_ReturnsStatusCreated()
+        {
+            // Arrange
+            string requestUri = $"{_basePath}/storage/events/logs";
+            string responseId = Guid.NewGuid().ToString();
+
+            Mock<IEventsService> eventsService = new Mock<IEventsService>();
+            Mock<ITraceLogService> traceLogService = new Mock<ITraceLogService>();
+
+            traceLogService.Setup(x => x.CreateWebhookResponseEntry(It.IsAny<LogEntryDto>())).ReturnsAsync(responseId);
+
+            var client = GetTestClient(eventsService.Object, traceLogService.Object);
+
+            string logEntryDto = JsonSerializer.Serialize(new LogEntryDto());
+
+            var httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, requestUri)
+            {
+                Content = new StringContent(logEntryDto, Encoding.UTF8, "application/cloudevents+json")
+            };
+
+            httpRequestMessage.Headers.Add("PlatformAccessToken", PrincipalUtil.GetAccessToken("ttd", "endring-av-navn-v2"));
+
+            // Act
+            var response = await client.SendAsync(httpRequestMessage);
+
+            // Assert
+            Assert.True(response.IsSuccessStatusCode);
+            Assert.Equal(HttpStatusCode.Created, response.StatusCode);
+        }
+
+        private HttpClient GetTestClient(IEventsService eventsService, ITraceLogService traceLogService = null)
+        {
+            HttpClient client = _factory.WithWebHostBuilder(builder =>
+            {
+                builder.ConfigureAppConfiguration((hostingContext, config) =>
+                {
+                    config.AddConfiguration(new ConfigurationBuilder().AddJsonFile("appsettings.unittest.json").Build());
+                });
+
+                builder.ConfigureTestServices(services =>
+                {
+                    services.AddSingleton(eventsService);
+
+                    if (traceLogService != null)
+                    {
+                        services.AddSingleton(traceLogService);
+                    }
+                    else
+                    {
+                        services.AddSingleton(_traceLogServiceMock.Object);
+                    }
+
+                    // Set up mock authentication so that not well known endpoint is used
+                    services.AddSingleton<IPostConfigureOptions<JwtCookieOptions>, JwtCookiePostConfigureOptionsStub>();
+                    services.AddSingleton<IPublicSigningKeyProvider, PublicSigningKeyProviderMock>();
+                    services.AddSingleton<IPDP, PepWithPDPAuthorizationMockSI>();
+                });
+            }).CreateClient();
+
+            return client;
+        }
+    }
+}