public void It_should_create_definitions()
        {
            var provider = new SlaProvider();

            SlaDefinitionBuilder.For<IRequest>(x => x.RequestId)
                .AddSla<IResponse>(TimeSpan.FromSeconds(1), x => x.ResponseId)
                .AddSla<IErrorResponse>(TimeSpan.FromSeconds(2), x => x.ResponseId)
                .Configure(provider);

            Assert.That(provider.GetRequestDefinitions(new Mock<IRequest>().Object).Count(), Is.EqualTo(1), "request mapping");

            Assert.That(provider.GetSlaDefinitionsFor(new Mock<IResponse>().Object).Single().Sla, Is.EqualTo(TimeSpan.FromSeconds(1)));
            Assert.That(provider.GetSlaDefinitionsFor(new Mock<IErrorResponse>().Object).Single().Sla, Is.EqualTo(TimeSpan.FromSeconds(2)));
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Captures incoming (response) message time and generates SLA violation logs if message has SLA defined and is has been violated.
        /// </summary>
        public void ProcessIncomingMessage(object message)
        {
            foreach (var definition in _provider.GetSlaDefinitionsFor(message))
            {
                RequestTracerCollection tracingsForType;
                if (!_tracers.TryGetValue(definition.Request.Type, out tracingsForType))
                {
                    continue;
                }
                Stopwatch watch;
                var       correlationId = definition.Response.GetCorrelationId(message);
                if (!tracingsForType.TryRemove(correlationId, out watch))
                {
                    continue;
                }

                watch.Stop();

                ProcessSla(definition, watch.Elapsed, correlationId);
            }
        }
Ejemplo n.º 3
0
        public void Provider_should_return_all_matching_sla_definitions_for_given_response()
        {
            var provider = new SlaProvider();

            var def1 = new SlaDefinition(
                MessageDefinition.Create<IRequestOne>(r => r.OneId),
                MessageDefinition.Create<IResponseOne>(r => r.Id),
                TimeSpan.FromSeconds(1));

            var def2 = new SlaDefinition(
                MessageDefinition.Create<IRequestTwo>(r => r.TwoId),
                MessageDefinition.Create<IResponseTwo>(r => r.Id),
                TimeSpan.FromSeconds(2));

            var def3 = new SlaDefinition(
                MessageDefinition.Create<IExtendedRequestOne>(r => r.OneId),
                MessageDefinition.Create<IResponseOne>(r => r.Id),
                TimeSpan.FromSeconds(3));

            var def4 = new SlaDefinition(
                MessageDefinition.Create<IRequestOne>(r => r.OneId),
                MessageDefinition.Create<IExtendedResponseOne>(r => r.Id),
                TimeSpan.FromSeconds(3));

            provider.Add(def1);
            provider.Add(def2);
            provider.Add(def3);
            provider.Add(def4);

            var definitions = provider.GetSlaDefinitionsFor(new Mock<IExtendedResponseOne>().Object);

            Assert.That(definitions.ToArray(), Is.EquivalentTo(new[] { def1, def3, def4 }));
        }