public override string Format(RxLoggerConfiguration configuration, RxLogEntryMeta meta, TLog instance, FormatFlags format) { Guard.NotNull(configuration); Guard.NotNull(instance); // right then, this is what we do // we format out the meta data that we want, and then just use a simple method to get the // rest of the formatted text var sb = new StringBuilder(); if (format == FormatFlags.IncludeMeta) { var formattedMeta = configuration.Formatting.FormatMeta(meta); if (_multiLine) { sb.AppendLine(formattedMeta); } else { sb.Append(formattedMeta + " "); } } BuildText(sb, configuration, instance); return(sb.ToString()); }
/// <summary> /// Create an instance using the specified configuration /// </summary> /// <param name="configuration"></param> public RxObservableLogHost(RxLoggerConfiguration configuration) { Configuration = configuration; _disposables = new CompositeDisposable(); var pump = new Subject <RxLogEntry>(); _pumpSubject = Subject.Synchronize(pump, Configuration.Host.PublishScheduler); // starts the process... var log = new ReplaySubject <RxLogEntry>(Configuration.Host.ReplaySize); _syncsubject = log; // setup the subscription var prePumpSubscription = Configuration.Host.PrePumpObservable(_pumpSubject). Do(Enqueue). Select(_ => Unit.Default). Catch((Exception e) => this.OnError(e)). Retry(). Subscribe(); _disposables.Add(prePumpSubscription); // Create a single one var messageObservable = log.Publish().RefCount(); // and now build all of the subscribers BuildSubscribers(messageObservable); }
public void CrashingSubscriberHandledCorrectlyTest() { var hostConfiguration = new HostConfiguration(publishScheduler: Scheduler.Immediate); var configuration = RxLoggerConfiguration.Create(hostConfiguration); RxLogEntry lastValueSub1 = null; RxLogEntry lastValueSub2 = null; configuration.AddSubscriber((c, en) => TestSubscriber(c, en, (r) => lastValueSub1 = r, raiseException: true)); configuration.AddSubscriber((c, en) => TestSubscriber(c, en, (r) => lastValueSub2 = r)); // one subscription we will let it raise exceptions, other won't. var entry1 = RxLogEntry.WithNoMeta(new object()); var entry2 = RxLogEntry.WithNoMeta(new object()); var host = new RxObservableLogHost(configuration); host.Publish(entry1); Assert.Null(lastValueSub1); Assert.Same(entry1, lastValueSub2); host.Publish(entry2); Assert.Null(lastValueSub1); Assert.Same(entry2, lastValueSub2); }
public ObservableMixinsTests() { _testSubject = new Subject <string>(); _mockLogHost = new Mock <IRxLogHost>(); _mockLogHost.Setup(p => p.Configuration).Returns(RxLoggerConfiguration.Create()); RxLog.SetDefault(new RxLog(_mockLogHost.Object)); }
/// <summary> /// Set the default <see cref="RxLog"/> based upon a specified configuration. /// </summary> /// <param name="configuration"></param> public static void SetDefault(RxLoggerConfiguration configuration) { Guard.NotNull(configuration); var host = configuration.CreateHost(); RxLog.SetDefault(new RxLog(host)); }
/// <summary> /// Create the default log host using the specified <see cref="RxLoggerConfiguration"/> /// </summary> /// <param name="configuration"></param> /// <returns></returns> public static void SetDefault(this RxLoggerConfiguration configuration) { var host = configuration.CreateHost(); var log = new RxLog(host); RxLog.SetDefault(log); }
public void CreateSuccessfullyTest() { var configuration = RxLoggerConfiguration.Create(); var host = new RxObservableLogHost(configuration); Assert.Equal(host.Configuration, configuration); }
public void CreateValidConfigurationTest() { var config = RxLoggerConfiguration.Create(); var meta = config.CreateMeta(this.GetType(), _testMemberName, _testLineNo); Assert.NotNull(config.Host); Assert.NotNull(config.Formatting); }
public void MetaCreationValidTest() { var config = RxLoggerConfiguration.Create(); var meta = config.CreateMeta(this.GetType(), _testMemberName, _testLineNo); Assert.Same(meta.CallingClass, this.GetType()); Assert.Equal(_testMemberName, meta.MemberName); Assert.Equal(_testLineNo, meta.LineNo); }
public void CustomCreateWIthNoSubscriberTest() { var hc = HostConfiguration.Default; var lc = LogFormattingConfiguration.Default; var subs = new List <Func <RxLoggerConfiguration, IObservable <RxLogEntry>, IObservable <Unit> > >(); var config = new RxLoggerConfiguration(hc, lc, subs); Assert.Same(config.Host, hc); Assert.Same(config.Formatting, lc); Assert.Equal(0, config.Subscribers.Count); }
public override void BuildText(StringBuilder sb, RxLoggerConfiguration configuration, Timer timer) { sb.AppendLine($"{timer.Name} Timer"); var totalAmount = timer.Entries.Count; sb.AppendLine($"Total {totalAmount}"); foreach (var instance in timer.Entries) { _blockFormatter.BuildText(sb, configuration, instance.Value); } }
public void PublishedItemsChanneledThroughConfigTest() { var hostConfiguration = new HostConfiguration(prePumpObservable: (e) => PumpTest(e), publishScheduler: Scheduler.Immediate); var configuration = RxLoggerConfiguration.Create(hostConfiguration: hostConfiguration); var host = new RxObservableLogHost(configuration); var entry = RxLogEntry.WithNoMeta(new object()); host.Publish(entry); Assert.Same(entry, _lastValue); }
public string Formatted(RxLoggerConfiguration configuration, RxLogEntry entry, FormatFlags flags) { Guard.NotNull(configuration); Guard.NotNull(entry); var sb = new StringBuilder(); // right then, we need to format the core and then the rest of the properties for the actual log item... // this is a straight wander of the properties of the item... if (flags == FormatFlags.IncludeMeta && entry.Meta != null) { sb.Append(_metaFormatter.Formatted(entry.Meta)); } if (_onePropertyPerLine) { sb.AppendLine(); sb.AppendLine(entry.Specifics.GetType().Name); } else { sb.Append(" "); sb.Append(entry.Specifics.GetType().Name); sb.Append(" "); } var attributes = entry.Specifics.Properties(); foreach (var attribute in attributes) { if (_onePropertyPerLine) { sb.Append(attribute.Key); sb.Append("="); sb.Append(attribute.Value); sb.AppendLine(); } else { sb.Append(" "); sb.Append(attribute.Key); sb.Append("="); sb.Append(attribute.Value); } } return(sb.ToString()); }
public override void BuildText(StringBuilder sb, RxLoggerConfiguration configuration, Discrete discrete) { sb.AppendLine($"{discrete.Name} {discrete.GetType()} Discrete {discrete.Unit.Name}"); if (discrete.Count > 0) { sb.AppendLine($"Assigned = {discrete.Count} time(s)"); sb.AppendLine($"Last Value = {discrete.LastValue} {discrete.Unit.Name}"); sb.AppendLine($"At = {discrete.LastDateTimeOffset}"); } else { sb.AppendLine("Never assigned"); } }
public void CustomCreateWithSubscriberTest() { var hc = HostConfiguration.Default; var lc = LogFormattingConfiguration.Default; Func <RxLoggerConfiguration, IObservable <RxLogEntry>, IObservable <Unit> > sub = (r, o) => Observable.Return(Unit.Default); var subs = new List <Func <RxLoggerConfiguration, IObservable <RxLogEntry>, IObservable <Unit> > > { sub }; var config = new RxLoggerConfiguration(hc, lc, subs); Assert.Equal(1, config.Subscribers.Count); Assert.Same(sub, config.Subscribers[0]); }
public void SubscribersCorrectlySubscribedTest() { var hostConfiguration = new HostConfiguration(prePumpObservable: (e) => PumpTest(e, false), publishScheduler: Scheduler.Immediate); var configuration = RxLoggerConfiguration.Create(hostConfiguration: hostConfiguration); RxLogEntry lastValue = default(RxLogEntry); configuration.AddSubscriber((c, en) => TestSubscriber(c, en, (v) => lastValue = v)); var host = new RxObservableLogHost(configuration); var entry = RxLogEntry.WithNoMeta(new object()); host.Publish(entry); Assert.Same(entry, lastValue); }
public override void BuildText(StringBuilder sb, RxLoggerConfiguration configuration, TimingBlock instance) { if (string.IsNullOrEmpty(instance.Name)) { sb.AppendLine($"unnamed Timer"); } else { sb.AppendLine($"{instance.Name} Timer"); } sb.AppendLine($"Total = {instance.Count}"); if (instance.Count > 1) { sb.AppendLine($"Minimum = {instance.Min} ms"); sb.AppendLine($"Maximum = {instance.Max} ms"); sb.AppendLine($"Mean = {instance.Mean} ms"); } sb.AppendLine($"Last = {instance.LastMilliseconds} ms"); var entryCounter = 1; long last = -1; foreach (var entry in instance.Entries) { if (last < 0) { last = entry.Milliseconds; } else { last = entry.Milliseconds - last; } sb.AppendLine($"#{entryCounter,3} {entry.Label} = {entry.Milliseconds} ms (+{last}) ms"); last = entry.Milliseconds; ++entryCounter; } }
private IObservable <Unit> TestSubscriber(RxLoggerConfiguration rxLoggerConfiguration, IObservable <RxLogEntry> source, Action <RxLogEntry> reportLastValue, bool raiseException = false) { return(Observable.Create <Unit>((o) => { var sub = source.Subscribe(v => { if (raiseException) { o.OnError(new Exception()); } else { reportLastValue(v); o.OnNext(Unit.Default); } }); return sub; })); }
public void ErrorsDuringProcessingPassedToErrorHandlerTest() { Exception lastException = null; var hostConfiguration = new HostConfiguration(prePumpObservable: (e) => PumpTest(e, true), publishScheduler: Scheduler.Immediate, errored: (e) => { lastException = e; return(Observable.Return(Unit.Default)); }); var configuration = RxLoggerConfiguration.Create(hostConfiguration: hostConfiguration); var host = new RxObservableLogHost(configuration); var entry = RxLogEntry.WithNoMeta(new object()); host.Publish(entry); Assert.NotNull(lastException); }
public void PublishedItemsCanBeFilteredTest() { // indicate that pump shouldn't pass through messages var hostConfiguration = new HostConfiguration(prePumpObservable: (e) => PumpTest(e, ignoreAll: true), publishScheduler: Scheduler.Immediate); var configuration = RxLoggerConfiguration.Create(hostConfiguration: hostConfiguration); RxLogEntry lastSubValue = default(RxLogEntry); configuration.AddSubscriber((c, en) => TestSubscriber(c, en, (r) => lastSubValue = r, raiseException: true)); var host = new RxObservableLogHost(configuration); var entry = RxLogEntry.WithNoMeta(new object()); host.Publish(entry); // verify not received anything. Assert.Null(lastSubValue); }
public override void BuildText(StringBuilder sb, RxLoggerConfiguration configuration, Counter counter) { sb.AppendLine($"{counter.Name} Counter"); var totalAmount = counter.Instances.Values.Sum(); sb.AppendLine($"Total {totalAmount}"); if (counter.Instances.ContainsKey(string.Empty)) { var noNameMatch = counter.Instances[string.Empty]; sb.AppendLine($"Item (unnamed) = {noNameMatch} {counter.Unit.Name}"); } foreach (var instance in counter.Instances) { if (!string.IsNullOrEmpty(instance.Key)) { sb.AppendLine($"Item {instance.Key} = {instance.Value} {counter.Unit.Name}"); } } }
public override void BuildText(StringBuilder sb, RxLoggerConfiguration configuration, Classified instance) { sb.Append(instance.Message); }
public abstract void BuildText(StringBuilder sb, RxLoggerConfiguration configuration, TLog instance);
public abstract string Format(RxLoggerConfiguration configuration, RxLogEntryMeta meta, TLog instance, FormatFlags format);
protected override string Format(RxLoggerConfiguration configuration, RxLogEntry entry, FormatFlags format) { return(this.Format(configuration, entry.Meta, (TLog)entry.Specifics, format)); }