public RxLogEntry(RxLogEntryMeta meta, object specifics)
        {
            Guard.NotNull(specifics);

            Meta      = meta;
            Specifics = specifics;
        }
Beispiel #2
0
        public static IObservable <TSource> Log <TSource, T>(this IObservable <TSource> source, object host,
                                                             Func <TSource, T> loggedInstance,
                                                             [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int lineNo = 0)
        {
            Guard.NotNull(source);

            return(Observable.Create <TSource>(observer =>
            {
                var meta = new RxLogEntryMeta(host.GetType(), callerMemberName, lineNo);

                var subscription = source.Subscribe(v =>
                {
                    var i = loggedInstance(v);

                    try
                    {
                        RxLog.Log(meta, i);
                    }
                    catch (Exception)
                    {
                        throw;
                    }


                    observer.OnNext(v);
                },
                                                    observer.OnError,
                                                    observer.OnCompleted);


                return new CompositeDisposable(subscription);
            }));
        }
Beispiel #3
0
        /// <summary>
        /// Publish a lost entry using the specified meta and instance data.
        /// </summary>
        /// <param name="meta"></param>
        /// <param name="instance"></param>
        /// <returns></returns>
        public static RxLogEntry Log(RxLogEntryMeta meta, object instance)
        {
            Guard.NotNull(instance);

            var entry = new RxLogEntry(meta, instance);

            Log(entry);

            return(entry);
        }
Beispiel #4
0
        /// <summary>
        /// Create and publish a log entry with specified <see cref="RxLogEntryMeta"/> and instance data.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="meta"></param>
        /// <param name="instance"></param>
        /// <returns></returns>
        public static RxLogEntry <T> Log <T>(RxLogEntryMeta meta, T instance)
        {
            Guard.NotNull(instance);

            var entry = new RxLogEntry <T>(meta, instance);

            Log(entry);

            return(entry);
        }
Beispiel #5
0
        public static IObservable <TSource> Trace <TSource>(this IObservable <TSource> source,
                                                            string name = default(string), [CallerMemberName] string callerMemberName = "",
                                                            [CallerLineNumber] int lineNo = 0)
        {
            Guard.NotNull(source);
            // counter used for our 'tick' occurance
            var id = 0;

            return(Observable.Create <TSource>(observer =>
            {
                var id1 = ++id;

                var meta = new RxLogEntryMeta(typeof(ObservableExtensions), callerMemberName, lineNo);

                Action <string, object> trace = (m, v) =>
                {
                    try
                    {
                        RxLog.Log(meta, Classified.Information($"{name} {id1}: {m}({v})"));
                    }
                    catch (Exception)
                    {
                        // do nothing
                    }
                };

                trace("Subscribe", string.Empty);

                var subscription = source.Subscribe(v =>
                {
                    trace("OnNext", v);
                    observer.OnNext(v);
                },
                                                    e =>
                {
                    trace("OnError", e.Message);
                    observer.OnError(e);
                },
                                                    () =>
                {
                    trace("OnCompleted", "");
                    observer.OnCompleted();
                });


                return new CompositeDisposable(subscription, Disposable.Create(() => trace("Dispose", string.Empty)));
            }));
        }