Exemplo n.º 1
0
        public void Provider_should_return_all_matching_request_definitions()
        {
            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));

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

            var definitions = provider.GetRequestDefinitions(new Mock<IExtendedRequestOne>().Object);

            Assert.That(definitions.ToArray(), Is.EquivalentTo(new[] { def1.Request, def3.Request }));
        }
Exemplo n.º 2
0
 /// <summary>
 /// Configures SlaProvider instance with SLA definitions.
 /// </summary>
 public void Configure(SlaProvider provider)
 {
     foreach (var definition in _definitions)
     {
         provider.Add(definition);
     }
 }
        public void SlaDefinition_ToString_should_return_meaningful_information()
        {
            var provider = new SlaProvider();
            SlaDefinitionBuilder.AddSla<IRequest, IResponse>(TimeSpan.FromSeconds(1), r => r.RequestId, r => r.ResponseId, provider);

            Assert.That(provider.Definitions.First().ToString(), Is.EqualTo("Wonga.SLAMonitor.Tests.Asynchronous.SlaDefinitionBuilderTests+IRequest -> Wonga.SLAMonitor.Tests.Asynchronous.SlaDefinitionBuilderTests+IResponse: 00:00:01"));
        }
Exemplo n.º 4
0
 /// <summary>
 /// Defines SLA in-line.
 /// </summary>
 /// <typeparam name="TRequest">Request type</typeparam>
 /// <typeparam name="TResponse">Response type</typeparam>
 /// <param name="sla">SLA</param>
 /// <param name="requestCorrelator">Method to retrieve request-response correlation ID for TRequest</param>
 /// <param name="responseCorrelator">Method to retrieve request-response correlation ID for TResponse</param>
 /// <param name="provider">SLA provider to configure</param>
 public static void AddSla <TRequest, TResponse>(
     TimeSpan sla,
     Func <TRequest, Guid> requestCorrelator,
     Func <TResponse, Guid> responseCorrelator,
     SlaProvider provider)
 {
     For(requestCorrelator).AddSla(sla, responseCorrelator).Configure(provider);
 }
Exemplo n.º 5
0
        /// <summary>
        /// Creates a SlaProvessor that uses given <c>provider</c> SlaProvider to determine which messages should be monitored.
        /// The <c>quotaPerMessageType</c> determines how many request messages of given type would be tracked at the same time (<see cref="QuotaPerMessageType"/> for details).
        /// </summary>
        /// <param name="provider">SlaProvider instance</param>
        /// <param name="quotaPerMessageType">The maximum number of request messages of given type that can be tracked at the same time.</param>
        /// <param name="loggingConfiguration">Specifies the log level for when SLA is met/breached</param>
        /// <param name="timeoutValidationSchedulerFactory">Timeout scheduler factory</param>
        internal protected SlaProcessor(SlaProvider provider, int quotaPerMessageType, LoggingConfiguration loggingConfiguration, Func <ISlaProcessor, IDisposable> timeoutValidationSchedulerFactory)
        {
            _provider           = provider;
            QuotaPerMessageType = quotaPerMessageType;

            _logSlaBreach = loggingConfiguration.ConfigureLoggingAction(_logger, loggingConfiguration.LoggingLevelWhenSLAIsBreached);
            _logSlaMet    = loggingConfiguration.ConfigureLoggingAction(_logger, loggingConfiguration.LoggingLevelWhenSLAIsMet);
            _timeoutValidationScheduler = timeoutValidationSchedulerFactory.Invoke(this);
        }
Exemplo n.º 6
0
        /// <summary>
        /// Creates a SlaProvessor that uses given <c>provider</c> SlaProvider to determine which messages should be monitored.
        /// The <c>quotaPerMessageType</c> determines how many request messages of given type would be tracked at the same time (<see cref="QuotaPerMessageType"/> for details).
        /// </summary>
        /// <param name="provider">SlaProvider instance</param>
        /// <param name="quotaPerMessageType">The maximum number of request messages of given type that can be tracked at the same time.</param>
        /// <param name="loggingConfiguration">Specifies the log level for when SLA is met/breached</param>
        /// <param name="timeoutValidationSchedulerFactory">Timeout scheduler factory</param>
        protected internal SlaProcessor(SlaProvider provider, int quotaPerMessageType, LoggingConfiguration loggingConfiguration, Func<ISlaProcessor, IDisposable> timeoutValidationSchedulerFactory)
        {
            _provider = provider;
            QuotaPerMessageType = quotaPerMessageType;

            _logSlaBreach = loggingConfiguration.ConfigureLoggingAction(_logger, loggingConfiguration.LoggingLevelWhenSLAIsBreached);
            _logSlaMet = loggingConfiguration.ConfigureLoggingAction(_logger, loggingConfiguration.LoggingLevelWhenSLAIsMet);
            _timeoutValidationScheduler = timeoutValidationSchedulerFactory.Invoke(this);
        }
        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)));
        }
Exemplo n.º 8
0
 /// <summary>
 /// Starts building SlaProcessor, that would be using given SlaProvider.
 /// </summary>
 public static SlaProcessorBuilder For(SlaProvider provider)
 {
     return new SlaProcessorBuilder(provider);
 }
Exemplo n.º 9
0
 private SlaProcessorBuilder(SlaProvider provider)
 {
     _provider = provider;
 }
Exemplo n.º 10
0
        public void Provider_should_return_one_request_definition_if_multiple_slas_are_referring_to_the_same_request()
        {
            var provider = new SlaProvider();

            var requestDefinition = MessageDefinition.Create<IRequestOne>(r => r.OneId);

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

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

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

            Assert.That(provider.GetRequestDefinitions(new Mock<IRequestOne>().Object).ToArray(), Is.EqualTo(new[] { requestDefinition }));
        }
        public void SetUp()
        {
            _provider = new SlaProvider();

            SlaDefinitionBuilder.For<Request>(r => r.Id)
                .AddSla<Response>(_sla, r => r.Id)
                .Configure(_provider);

            _appender = InjectInMemoryAppender();
        }