DataDictionaryExtensions.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Exceptionless.Dependency;
using Exceptionless.Extensions;
using Exceptionless.Models;

namespace Exceptionless {
    public static class DataDictionaryExtensions {
        public static T GetValue<T>(this DataDictionary items, string key, IJsonSerializer serializer = null) {
            if (items == null)
                throw new ArgumentNullException(nameof(items));

            if (String.IsNullOrEmpty(key))
                throw new ArgumentNullException(nameof(key));

            if (!items.TryGetValue(key, out object data))
                throw new KeyNotFoundException($"The key '{key}' was not found.");

            if (data == null || data is T)
                return (T)data;

            var json = data as string ?? data.ToString();
            serializer = serializer ?? DependencyResolver.Default.GetJsonSerializer();
            return serializer.Deserialize<T>(json);
        }

        /// <summary>
        /// Sets a property value on the extended data.
        /// </summary>
        /// <param name="target">The target object.</param>
        /// <param name="name">The name of the property to add.</param>
        /// <param name="value">The property value to add.</param>
        /// <param name="maxDepth">The max depth of the object to include. Used when the property value is an object.</param>
        /// <param name="excludedPropertyNames">Any property names that should be excluded in complex object values.</param>
        /// <param name="ignoreSerializationErrors">Specifies whether complex object properties that throw errors while serializing be ignored</param>
        /// <param name="client">
        /// The ExceptionlessClient instance used for configuration. If a client is not specified, it will use
        /// ExceptionlessClient.Default.
        /// </param>
        public static void SetProperty(this IData target, string name, object value, int? maxDepth = null, IEnumerable<string> excludedPropertyNames = null, bool ignoreSerializationErrors = false, ExceptionlessClient client = null) {
            if (String.IsNullOrEmpty(name))
                throw new ArgumentNullException(nameof(name));
            
            AddObject(target, value, name, maxDepth, excludedPropertyNames, ignoreSerializationErrors, client);
        }

        /// <summary>
        /// Adds the object to extended data.
        /// </summary>
        /// <param name="data">The error.</param>
        /// <param name="value">The data object to add.</param>
        /// <param name="name">The name of the object to add. If not specified, the name will be implied from the object type.</param>
        /// <param name="maxDepth">The max depth of the object to include.</param>
        /// <param name="excludedPropertyNames">Any property names that should be excluded</param>
        /// <param name="ignoreSerializationErrors">Specifies whether properties that throw errors while serializing be ignored</param>
        /// <param name="client">
        /// The ExceptionlessClient instance used for configuration. If a client is not specified, it will use
        /// ExceptionlessClient.Default.
        /// </param>
        public static void AddObject(this IData data, object value, string name = null, int? maxDepth = null, IEnumerable<string> excludedPropertyNames = null, bool ignoreSerializationErrors = false, ExceptionlessClient client = null) {
            if (client == null)
                client = ExceptionlessClient.Default;

            if (value == null)
                return;

            ExtendedDataInfo info;
            if (value is ExtendedDataInfo)
                info = value as ExtendedDataInfo;
            else {
                info = new ExtendedDataInfo {
                    Data = value,
                    Name = name,
                    MaxDepthToSerialize = maxDepth,
                    IgnoreSerializationErrors = ignoreSerializationErrors
                };

                if (excludedPropertyNames != null)
                    info.ExcludedPropertyNames.AddRange(excludedPropertyNames);
            }

            AddObject(data, info, client);
        }

        /// <summary>
        /// Adds the object to extended data.
        /// </summary>
        /// <param name="data">The error to add the object to.</param>
        /// <param name="info">The data object to add.</param>
        /// <param name="client">
        /// The ExceptionlessClient instance used for configuration. If a client is not specified, it will use
        /// ExceptionlessClient.Default.
        /// </param>
        public static void AddObject(this IData data, ExtendedDataInfo info, ExceptionlessClient client = null) {
            if (client == null)
                client = ExceptionlessClient.Default;

            if (info == null || info.Data == null)
                return;
            
            string[] exclusions = info.ExcludedPropertyNames != null
                ? client.Configuration.DataExclusions.Union(info.ExcludedPropertyNames).ToArray()
                : client.Configuration.DataExclusions.ToArray();

            string name = !String.IsNullOrWhiteSpace(info.Name) ? info.Name.Trim() : null;
            var dataType = info.Data.GetType();
            if (String.IsNullOrEmpty(name)) {
                name = dataType.Name;
                int index = 1;
                while (data.Data.ContainsKey(name))
                    name = dataType.Name + index++;
            } else if (exclusions.Length > 0 && name.AnyWildcardMatches(exclusions, true)) {
                return;
            }

            if (dataType == typeof(bool) || dataType == typeof(string) || dataType.IsNumeric()) {
                data.Data[name] = info.Data;

                return;
            }

            string json;
            try {
                if (dataType.IsPrimitiveType()) {
                    json = info.Data.ToString();
                } else {
                    var serializer = client.Configuration.Resolver.GetJsonSerializer();
                    json = serializer.Serialize(info.Data, exclusions, info.MaxDepthToSerialize.GetValueOrDefault(5), info.IgnoreSerializationErrors);
                }
            } catch (Exception ex) {
                json = ex.ToString();
            }

            if (String.IsNullOrEmpty(json))
                return;

            if (dataType.IsPrimitiveType())
                data.Data[name] = json;
            else
                data.Data.SetRawJson(name, json);
        }
    }
}