コード例 #1
0
        private void TrackMetric(LogLevel logLevel, EventId eventId, string message, MetricLog metric)
        {
            var telemetry = new MetricTelemetry(metric.Name, metric.Value);

            telemetry.Count             = metric.Count;
            telemetry.Min               = metric.Min;
            telemetry.Max               = metric.Max;
            telemetry.StandardDeviation = metric.StandardDeviation;
            if (metric.Properties != null)
            {
                foreach (var item in metric.Properties)
                {
                    telemetry.Properties[item.Key] = item.Value?.ToString();
                }
            }
            telemetry.Properties["logger"]    = categoryName;
            telemetry.Properties["eventName"] = eventId.Name;
            telemetry.Properties["eventId"]   = eventId.Id.ToString();
            telemetry.Properties["remark"]    = metric.Remark;
            telemetryClient.TrackMetric(telemetry);
        }
コード例 #2
0
        public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter)
        {
            if (!IsEnabled(logLevel))
            {
                return;
            }

            if (formatter == null)
            {
                formatter = (TState s, Exception e) =>
                            e == null
                    ? $"{s}"
                    : $"{s}\n{e}";
            }

            var message = formatter(state, exception) ?? "";

            if (exception == null)
            {
                if (state is IEnumerable <KeyValuePair <string, object> > )
                {
                    var properties = state as IEnumerable <KeyValuePair <string, object> >;
                    var logType    = properties
                                     .Where(item => item.Key.Equals("LogType", StringComparison.OrdinalIgnoreCase))
                                     .Select(item => item.Value?.ToString() ?? "")
                                     .FirstOrDefault() ?? "";
                    if (logType.Equals(nameof(MetricLog), StringComparison.OrdinalIgnoreCase))
                    {
                        var metric = MetricLog.Create(properties);
                        if (metric == null)
                        {
                            TrackTrace(logLevel, eventId, message, properties);
                        }
                        else
                        {
                            TrackMetric(logLevel, eventId, message, metric);
                        }
                    }
                    else if (logType.Equals(nameof(EventLog), StringComparison.OrdinalIgnoreCase))
                    {
                        var @event = EventLog.Create(properties);
                        if (@event == null)
                        {
                            TrackTrace(logLevel, eventId, message, properties);
                        }
                        else
                        {
                            TrackEvent(logLevel, eventId, message, @event);
                        }
                    }
                    else
                    {
                        TrackTrace(logLevel, eventId, message, properties);
                    }
                }
                else if (state is EventLog)
                {
                    TrackEvent(logLevel, eventId, message, state as EventLog);
                }
                else if (state is MetricLog)
                {
                    TrackMetric(logLevel, eventId, message, state as MetricLog);
                }
                else
                {
                    TrackTrace(logLevel, eventId, message, Enumerable.Empty <KeyValuePair <string, object> >());
                }
            }
            else
            {
                TrackException(eventId, message, exception, Enumerable.Empty <KeyValuePair <string, object> >());
            }
        }
コード例 #3
0
        /// <summary>
        /// Create a new MetricLog from given properties.
        /// </summary>
        /// <param name="properties">Key-value properties.</param>
        /// <remarks>
        /// Name and Value are mandatory properties.
        /// </remarks>
        /// <returns>Returns a new MetricLog if given properties have the Name and Value properties, or null otherwise.</returns>
        public static MetricLog Create(IEnumerable <KeyValuePair <string, object> > properties)
        {
            if (properties == null)
            {
                return(null);
            }
            if (false == properties.Any(item =>
                                        item.Key.Equals("LogType", StringComparison.OrdinalIgnoreCase) &&
                                        (item.Value?.ToString() ?? "").Equals(nameof(MetricLog), StringComparison.OrdinalIgnoreCase)))
            {
                return(null);
            }
            var metric = new MetricLog("No name", 0);
            var dic    = properties.ToDictionary(item => item.Key, item => item.Value, StringComparer.OrdinalIgnoreCase);

            foreach (var item in dic.Where(item =>
                                           false == new string[]
            {
                nameof(Name),
                nameof(StandardDeviation),
                nameof(Count),
                nameof(Value),
                nameof(Min),
                nameof(Max),
                nameof(Remark),
            }.Contains(item.Key, StringComparer.OrdinalIgnoreCase)))
            {
                metric.Properties[item.Key] = item.Value;
            }
            if (dic.ContainsKey(nameof(Name)))
            {
                metric.Name = dic[nameof(Name)]?.ToString();
            }
            else
            {
                return(null);
            }
            if (dic.ContainsKey(nameof(Value)))
            {
                metric.Value = double.Parse(dic[nameof(Value)]?.ToString() ?? "0");
            }
            else
            {
                return(null);
            }
            if (dic.ContainsKey(nameof(StandardDeviation)))
            {
                var standardDeviation = dic[nameof(StandardDeviation)];
                if (standardDeviation != null)
                {
                    double value = 0.0;
                    if (double.TryParse(standardDeviation.ToString(), out value))
                    {
                        metric.StandardDeviation = value;
                    }
                }
            }
            if (dic.ContainsKey(nameof(Count)))
            {
                var count = dic[nameof(Count)];
                if (count != null)
                {
                    int value = 0;
                    if (int.TryParse(count.ToString(), out value))
                    {
                        metric.Count = value;
                    }
                }
            }
            if (dic.ContainsKey(nameof(Min)))
            {
                var min = dic[nameof(Min)];
                if (min != null)
                {
                    double value = 0;
                    if (double.TryParse(min.ToString(), out value))
                    {
                        metric.Min = value;
                    }
                }
            }
            if (dic.ContainsKey(nameof(Max)))
            {
                var max = dic[nameof(Max)];
                if (max != null)
                {
                    double value = 0;
                    if (double.TryParse(max.ToString(), out value))
                    {
                        metric.Max = value;
                    }
                }
            }
            if (dic.ContainsKey(nameof(Remark)))
            {
                metric.Remark = dic[nameof(Remark)]?.ToString();
            }
            return(metric);
        }