コード例 #1
0
        public async Task Should_not_forward_request_if_disabled()
        {
            A.CallTo(() => requestLogStore.IsEnabled)
            .Returns(false);

            await sut.LogAsync(DomainId.NewGuid(), default);

            A.CallTo(() => requestLogStore.LogAsync(A <Request> ._))
            .MustNotHaveHappened();
        }
コード例 #2
0
        public async Task Should_forward_request_log_to_store()
        {
            Request?recordedRequest = null;

            A.CallTo(() => requestLogStore.LogAsync(A <Request> ._))
            .Invokes((Request request) => recordedRequest = request);

            var request = default(RequestLog);

            request.Bytes         = 1024;
            request.Costs         = 1.5;
            request.ElapsedMs     = 120;
            request.RequestMethod = "GET";
            request.RequestPath   = "/my-path";
            request.Timestamp     = default;
            request.UserClientId  = "frontend";
            request.UserId        = "user1";

            await sut.LogAsync(DomainId.NewGuid(), request);

            Assert.NotNull(recordedRequest);

            Assert.Contains(request.Bytes.ToString(CultureInfo.InvariantCulture), recordedRequest !.Properties.Values);
            Assert.Contains(request.Costs.ToString(CultureInfo.InvariantCulture), recordedRequest !.Properties.Values);
            Assert.Contains(request.ElapsedMs.ToString(), recordedRequest !.Properties.Values);
            Assert.Contains(request.RequestMethod, recordedRequest !.Properties.Values);
            Assert.Contains(request.RequestPath, recordedRequest !.Properties.Values);
            Assert.Contains(request.UserClientId, recordedRequest !.Properties.Values);
            Assert.Contains(request.UserId, recordedRequest !.Properties.Values);
        }
コード例 #3
0
        public Task LogAsync(DomainId appId, RequestLog request,
                             CancellationToken ct = default)
        {
            if (!requestLogStore.IsEnabled)
            {
                return(Task.CompletedTask);
            }

            var storedRequest = new Request
            {
                Key       = appId.ToString(),
                Timestamp = request.Timestamp
            };

            Append(storedRequest, FieldAuthClientId, request.UserClientId);
            Append(storedRequest, FieldAuthUserId, request.UserId);
            Append(storedRequest, FieldBytes, request.Bytes);
            Append(storedRequest, FieldCacheHits, request.CacheHits);
            Append(storedRequest, FieldCacheServer, request.CacheServer);
            Append(storedRequest, FieldCacheStatus, request.CacheStatus);
            Append(storedRequest, FieldCacheTTL, request.CacheTTL);
            Append(storedRequest, FieldCosts, request.Costs);
            Append(storedRequest, FieldRequestElapsedMs, request.ElapsedMs);
            Append(storedRequest, FieldRequestMethod, request.RequestMethod);
            Append(storedRequest, FieldRequestPath, request.RequestPath);
            Append(storedRequest, FieldStatusCode, request.StatusCode);

            return(requestLogStore.LogAsync(storedRequest, ct));
        }
コード例 #4
0
        public Task LogAsync(DomainId appId, RequestLog request)
        {
            if (!requestLogStore.IsEnabled)
            {
                return(Task.CompletedTask);
            }

            var storedRequest = new Request
            {
                Key        = appId.ToString(),
                Properties = new Dictionary <string, string>
                {
                    [FieldCosts] = request.Costs.ToString(CultureInfo.InvariantCulture)
                },
                Timestamp = request.Timestamp
            };

            Append(storedRequest, FieldAuthClientId, request.UserClientId);
            Append(storedRequest, FieldAuthUserId, request.UserId);
            Append(storedRequest, FieldBytes, request.Bytes);
            Append(storedRequest, FieldCosts, request.Costs);
            Append(storedRequest, FieldRequestElapsedMs, request.ElapsedMs);
            Append(storedRequest, FieldRequestMethod, request.RequestMethod);
            Append(storedRequest, FieldRequestPath, request.RequestPath);

            return(requestLogStore.LogAsync(storedRequest));
        }
コード例 #5
0
        public async Task Should_forward_request_log_to_store()
        {
            Request?recordedRequest = null;

            A.CallTo(() => requestLogStore.LogAsync(A <Request> ._))
            .Invokes((Request request) => recordedRequest = request);

            var clientId      = "frontend";
            var costs         = 2;
            var elapsedMs     = 120;
            var requestMethod = "GET";
            var requestPath   = "/my-path";
            var userId        = "user1";

            await sut.LogAsync(Guid.NewGuid(), default, requestMethod, requestPath, userId, clientId, elapsedMs, costs);
コード例 #6
0
        public Task LogAsync(Guid appId, Instant timestamp, string?requestMethod, string?requestPath, string?userId, string?clientId, long elapsedMs, double costs)
        {
            var request = new Request
            {
                Key        = appId.ToString(),
                Properties = new Dictionary <string, string>
                {
                    [FieldCosts] = costs.ToString(CultureInfo.InvariantCulture)
                },
                Timestamp = timestamp
            };

            Append(request, FieldAuthClientId, clientId);
            Append(request, FieldAuthUserId, userId);
            Append(request, FieldCosts, costs.ToString(CultureInfo.InvariantCulture));
            Append(request, FieldRequestElapsedMs, elapsedMs.ToString(CultureInfo.InvariantCulture));
            Append(request, FieldRequestMethod, requestMethod);
            Append(request, FieldRequestPath, requestPath);

            return(requestLogStore.LogAsync(request));
        }