internal static void AddProperties(ISupportProperties telemetry, object message, ICollection <string> categories,
int eventId, string title, IDictionary <string, object> properties)
{
telemetry.Properties.Add("Message", message?.ToString().MaximizeLength(MaxValueLength));
telemetry.Properties.Add("EventId", eventId.ToString());
if (categories != null && categories.Count > 0)
{
telemetry.Properties.Add("Categories", string.Join(", ", categories));
}
if (!string.IsNullOrEmpty(title))
{
telemetry.Properties.Add("Title", title);
}
if (properties?.Any() ?? false)
{
foreach (var property in properties.Where(p => !string.IsNullOrEmpty(p.Key)))
{
telemetry.Properties.Add(property.Key.MaximizeLength(MaxPropertyNameLength),
property.Value?.ToString().MaximizeLength(MaxValueLength));
}
}
}
private static ITelemetry ConvertLogEventsToCustomTraceTelemetry(LogEvent logEvent, IFormatProvider formatProvider)
{
var telemetry = GetTelemetry(logEvent, formatProvider);
telemetry.Context.Cloud.RoleInstance = _roleInstance;
telemetry.Context.Cloud.RoleName = _roleName;
if (logEvent.Properties.ContainsKey("UserId"))
{
telemetry.Context.User.Id = logEvent.Properties["UserId"].ToString();
}
if (logEvent.Properties.ContainsKey("operation_Id"))
{
telemetry.Context.Operation.Id = logEvent.Properties["operation_Id"].ToString();
}
if (logEvent.Properties.ContainsKey("operation_parentId"))
{
telemetry.Context.Operation.ParentId = logEvent.Properties["operation_parentId"].ToString();
}
ISupportProperties supportProperties = (ISupportProperties)telemetry;
var removeProps = new[] { "UserId", "operation_parentId", "operation_Id" };
removeProps = removeProps.Where(prop => supportProperties.Properties.ContainsKey(prop)).ToArray();
foreach (var prop in removeProps)
{
supportProperties.Properties.Remove(prop);
}
return(telemetry);
}
public void Initialize(ITelemetry telemetry)
{
if (string.IsNullOrEmpty(telemetry.Context.Cloud.RoleName))
{
//set custom role name here
telemetry.Context.Cloud.RoleName = "Sales Api";
//telemetry.Context.Cloud..RoleInstance = "Custom RoleInstance";
}
var messageCorrelation = _messageAccessor.CorrelationId;
if (messageCorrelation != Guid.Empty)
{
ISupportProperties properties = (ISupportProperties)telemetry;
properties.Properties["CorrelationId"] = messageCorrelation.ToString();
}
else
{
var correlationContext = _accessor.CorrelationContext;
if (correlationContext != null)
{
ISupportProperties properties = (ISupportProperties)telemetry;
properties.Properties["CorrelationId"] = correlationContext.CorrelationId;
}
}
}
public void InitializeWillNotOverwriteExistingCustomDimension()
{
var envMock = new Mock <IK8sEnvironment>();
envMock.Setup(env => env.ContainerName).Returns("Hello RoleName");
envMock.Setup(env => env.ContainerID).Returns("Cid");
var envFactoryMock = new Mock <IK8sEnvironmentFactory>();
envFactoryMock.Setup(f => f.CreateAsync(It.IsAny <DateTime>())).ReturnsAsync(() => envMock.Object);
Mock <ITelemetryKeyCache> keyCacheMock = new Mock <ITelemetryKeyCache>();
keyCacheMock.Setup(c => c.GetProcessedKey(It.IsAny <string>())).Returns <string>(input => input);
KubernetesTelemetryInitializer target = new KubernetesTelemetryInitializer(
envFactoryMock.Object,
GetOptions(TimeSpan.FromSeconds(1)),
SDKVersionUtils.Instance,
keyCacheMock.Object);
ITelemetry telemetry = new TraceTelemetry();
ISupportProperties telemetryWithProperties = telemetry as ISupportProperties;
telemetryWithProperties.Properties["K8s.Container.ID"] = "Existing Cid";
target.Initialize(telemetry);
Assert.Equal("Existing Cid", telemetryWithProperties.Properties["K8s.Container.ID"]);
}
private void _propertiesProcessContext(ISupportProperties data, ProcessContext pc)
{
data.Properties.Add("ResourceId", pc.CurrentInfo.ResourceId);
data.Properties.Add("ProcessType", pc.ProcessType.ToString());
data.Properties.Add("ResultType", pc.ResultType.ToString());
data.Properties.Add("Idx/Total", pc.Index.ToString() + "/" + pc.Total.ToString());
if (pc.LastState != default)
{
data.Properties.Add("CheckSum_Old", pc.LastState.CheckSum);
data.Properties.Add("Modified_Old", pc.LastState.Modified.ToString());
}
if (pc.NewState != default)
{
data.Properties.Add("RetryCount", pc.NewState.RetryCount.ToString());
data.Properties.Add("RetrievedAt", pc.NewState.ToString());
data.Properties.Add("CheckSum", pc.NewState.CheckSum);
data.Properties.Add("Modified", pc.NewState.Modified.ToString());
string extensionsString = JsonConvert.SerializeObject(pc.NewState.Extensions, ArkDefaultJsonSerializerSettings.Instance);
data.Properties.Add("Extensions", extensionsString);
}
}
public int GetHashCode(ITelemetry obj)
{
// now construct the basis for our hash
StringBuilder sb = new StringBuilder();
// first append the type
sb.Append(obj.GetType().ToString());
// then the name
sb.Append(obj.GetNameOrMessage());
if (obj.GetType().GetInterfaces().Contains(typeof(ISupportProperties)))
{
ISupportProperties objp = obj as ISupportProperties;
// Properties may have been added out of order, which may result
// in different hash values despite having the same properties.
// Therefore we need to construct the string on which we base our
// hash value in an ordered manner.
SortedSet <string> sortedKeys = new SortedSet <string>();
foreach (string key in objp.Properties.Keys)
{
sortedKeys.Add(key);
}
// then each key/value pair in an ordered manner
foreach (string key in sortedKeys)
{
sb.Append(key).Append(objp.Properties[key]);
}
}
// and finally calculate the hash
return(sb.ToString().GetHashCode());
}
// Inserts properties into the telemetry's properties. Properly formats dates, removes nulls, applies prefix, etc.
private static void ApplyProperties(ISupportProperties telemetry, IEnumerable <KeyValuePair <string, object> > values, string propertyPrefix = null)
{
foreach (var property in values)
{
ApplyProperty(telemetry, property.Key, property.Value, propertyPrefix);
}
}
private bool IsEnabled(ITelemetry item)
{
bool enabled = true;
ISupportProperties telemetry = item as ISupportProperties;
if (telemetry != null && _filter != null)
{
string categoryName = null;
if (!telemetry.Properties.TryGetValue(LogConstants.CategoryNameKey, out categoryName))
{
// If no category is specified, it will be filtered by the default filter
categoryName = string.Empty;
}
// Extract the log level and apply the filter
string logLevelString = null;
LogLevel logLevel;
if (telemetry.Properties.TryGetValue(LogConstants.LogLevelKey, out logLevelString) &&
Enum.TryParse(logLevelString, out logLevel))
{
enabled = _filter(categoryName, logLevel);
}
}
return(enabled);
}
// Applies custom scope properties; does not apply 'system' used properties
private static void ApplyCustomScopeProperties(ISupportProperties telemetry)
{
var scopeProperties = DictionaryLoggerScope.GetMergedStateDictionary()
.Where(p => !SystemScopeKeys.Contains(p.Key, StringComparer.Ordinal));
ApplyProperties(telemetry, scopeProperties, LogConstants.CustomPropertyPrefix);
}
private void PrintProperties(ISupportProperties itemProps)
{
foreach (var prop in itemProps.Properties)
{
this.output.WriteLine(prop.Key + ":" + prop.Value);
}
}
private void AddProperty(ISupportProperties item, string propertyName, string propertyValue)
{
if (propertyName == null)
{
return;
}
var properties = item.Properties;
if (!properties.ContainsKey(propertyName))
{
properties.Add(propertyName, propertyValue);
return;
}
string newPropertyName = propertyName + "_";
//update property key till there is no such key in dict
do
{
newPropertyName += RandomGenerator.Value.Next(0, 10);
}while (properties.ContainsKey(newPropertyName));
properties.Add(newPropertyName, propertyValue);
}
public static ITelemetry UpdateWithContextTelemitryProperties(this ITelemetry telemetry, LogEvent logEvent)
{
// Post-process the telemetry's context to contain the user id as desired
if (logEvent.Properties.ContainsKey("userId"))
{
telemetry.Context.User.Id = logEvent.Properties["userId"].ToString();
}
// Post-process the telemetry's context to contain the operation id
if (logEvent.Properties.ContainsKey("RequestId"))
{
telemetry.Context.Operation.Id = logEvent.Properties["RequestId"].ToString();
}
// Post-process the telemetry's context to contain the operation parent id
if (logEvent.Properties.ContainsKey("parentActivityId"))
{
telemetry.Context.Operation.ParentId = logEvent.Properties["parentActivityId"].ToString();
}
// Typecast to ISupportProperties so you can manipulate the properties as desired
ISupportProperties propTelematry = (ISupportProperties)telemetry;
// Find now redundent properties
var removeProps = new[] { "userId", "RequestId", "parentActivityId" };
removeProps = removeProps.Where(prop => propTelematry.Properties.ContainsKey(prop)).ToArray();
foreach (var prop in removeProps)
{
// Remove those properties
propTelematry.Properties.Remove(prop);
}
return(telemetry);
}
private void ApplyCustomProperties(ISupportProperties telemetry, IEnumerable <KeyValuePair <string, object> > values)
{
telemetry.Properties.Add(LoggingKeys.CategoryName, _categoryName);
foreach (var property in values)
{
string stringValue = null;
// drop null properties
if (property.Value == null)
{
continue;
}
// Format dates
Type propertyType = property.Value.GetType();
if (propertyType == typeof(DateTime))
{
stringValue = ((DateTime)property.Value).ToUniversalTime().ToString(DateTimeFormatString);
}
else if (propertyType == typeof(DateTimeOffset))
{
stringValue = ((DateTimeOffset)property.Value).UtcDateTime.ToString(DateTimeFormatString);
}
else
{
stringValue = property.Value.ToString();
}
// Since there is no nesting of properties, apply a prefix before the property name to lessen
// the chance of collisions.
telemetry.Properties.Add(LoggingKeys.CustomPropertyPrefix + property.Key, stringValue);
}
}
private void AddProperty(ISupportProperties item, string propertyName, string propertyValue)
{
if (propertyValue != null)
{
item.Properties.Add(propertyName, propertyValue);
}
}
private void SetContextProperties(ITelemetry telemetry)
{
telemetry.Context.Cloud.RoleName = FabricEnvironmentVariable.ServicePackageName;
telemetry.Context.Cloud.RoleInstance = FabricEnvironmentVariable.ServicePackageActivationId ?? FabricEnvironmentVariable.ServicePackageInstanceId;
telemetry.Context.Component.Version = _context.CodePackageActivationContext.CodePackageVersion;
ISupportProperties propTelematry = (ISupportProperties)telemetry;
if (!propTelematry.Properties.ContainsKey(ServiceContextProperties.NodeName))
{
if (!string.IsNullOrEmpty(FabricEnvironmentVariable.NodeName))
{
propTelematry.Properties.Add(ServiceContextProperties.NodeName, FabricEnvironmentVariable.NodeName);
}
}
#if Debug
telemetry.Context.Operation.SyntheticSource = "DebugSession";
#else
if (Debugger.IsAttached)
{
telemetry.Context.Operation.SyntheticSource = "DebuggerAttached";
}
#endif
if (_logEvent.Properties.TryGetValue(SharedProperties.TraceId, out LogEventPropertyValue value))
{
var id = ((ScalarValue)value).Value.ToString();
telemetry.Context.Operation.ParentId = id;
telemetry.Context.Operation.Id = id;
}
}
/// <summary>
/// Flattens Extension object on ITelemetry if exists into the properties and measurements.
/// </summary>
internal static void FlattenIExtensionIfExists(this ITelemetry telemetry)
{
if (telemetry.Extension != null)
{
ISupportProperties itemWithProperties = telemetry as ISupportProperties;
ISupportMetrics itemWithMetrics = telemetry as ISupportMetrics;
// Do not serialize if data cannot be stored on the item
if (itemWithProperties != null || itemWithMetrics != null)
{
DictionarySerializationWriter extensionSerializationWriter = new DictionarySerializationWriter();
telemetry.Extension.Serialize(extensionSerializationWriter);
if (itemWithProperties != null)
{
Utils.CopyDictionary(extensionSerializationWriter.AccumulatedDictionary, itemWithProperties.Properties);
}
if (itemWithMetrics != null)
{
Utils.CopyDictionary(extensionSerializationWriter.AccumulatedMeasurements, itemWithMetrics.Metrics);
}
}
}
}
/// <summary>
/// Merges the properties from an <see cref="IDictionary{TKey, TValue}"/> into the <see cref="ISupportProperties" />Telemetry object
/// </summary>
/// <param name="telemetry">The object into which the properties will be merged.</param>
/// <param name="properties">The properties to merge in.</param>
public static void MergeProperties(this ISupportProperties telemetry, IDictionary <string, string> properties)
{
if (telemetry == null)
{
throw new ArgumentNullException(nameof(telemetry));
}
if (properties == null)
{
throw new ArgumentNullException(nameof(properties));
}
foreach (KeyValuePair <string, string> property in properties)
{
string kn;
if (telemetry.Properties.ContainsKey(property.Key))
{
kn = string.Concat("MERGED_", property.Key);
}
else
{
kn = property.Key;
}
telemetry.Properties.Add(kn, property.Value);
}
}
public void TimeoutGettingK8sEnvNoException()
{
var envMock = new Mock <IK8sEnvironment>();
envMock.Setup(env => env.ContainerID).Returns("Cid");
var envFactoryMock = new Mock <IK8sEnvironmentFactory>();
envFactoryMock.Setup(f => f.CreateAsync(It.IsAny <DateTime>())).ReturnsAsync(envMock.Object, TimeSpan.FromMinutes(1));
Mock <ITelemetryKeyCache> keyCacheMock = new Mock <ITelemetryKeyCache>();
keyCacheMock.Setup(c => c.GetProcessedKey(It.IsAny <string>())).Returns <string>(input => input);
KubernetesTelemetryInitializer target = new KubernetesTelemetryInitializer(
envFactoryMock.Object,
GetOptions(TimeSpan.FromSeconds(1)),
SDKVersionUtils.Instance,
keyCacheMock.Object);
ITelemetry telemetry = new TraceTelemetry();
ISupportProperties telemetryWithProperties = telemetry as ISupportProperties;
telemetryWithProperties.Properties["K8s.Container.ID"] = "No Crash";
target.Initialize(telemetry);
Assert.Equal("No Crash", telemetryWithProperties.Properties["K8s.Container.ID"]);
}
private void AddEsquioProperties(ITelemetry telemetryItem)
{
if (_httpContextAccessor.HttpContext != null && telemetryItem != null)
{
var evaluation = _httpContextAccessor.HttpContext?
.Items
.Where(k => k.Key.ToString() == EsquioConstants.ESQUIO)
.Select(i => i.Value)
.SingleOrDefault();
if (evaluation != null)
{
var items = evaluation as Dictionary <string, bool>;
if (items != null)
{
ISupportProperties telemetry = telemetryItem as ISupportProperties;
foreach (var(key, value) in items)
{
if (!telemetry.Properties.ContainsKey(key.ToString()))
{
telemetry.Properties.Add(key.ToString(), value.ToString());
}
}
}
}
}
}
public void ShouldUseTheValueByTheKeyProcessorForTelemetry()
{
var envMock = new Mock <IK8sEnvironment>();
envMock.Setup(env => env.ContainerName).Returns("Hello.RoleName");
envMock.Setup(env => env.ContainerID).Returns("Hello.Cid");
var envFactoryMock = new Mock <IK8sEnvironmentFactory>();
envFactoryMock.Setup(f => f.CreateAsync(It.IsAny <DateTime>())).ReturnsAsync(() => envMock.Object);
Mock <ITelemetryKeyCache> keyCacheMock = new Mock <ITelemetryKeyCache>();
keyCacheMock.Setup(c => c.GetProcessedKey(It.IsAny <string>())).Returns <string>(input => input.Replace('.', '_'));
KubernetesTelemetryInitializer target = new KubernetesTelemetryInitializer(
envFactoryMock.Object,
GetOptions(TimeSpan.FromSeconds(1)),
SDKVersionUtils.Instance,
keyCacheMock.Object);
ITelemetry telemetry = new TraceTelemetry();
target.Initialize(telemetry);
ISupportProperties telemetryWithProperties = telemetry as ISupportProperties;
Assert.False(telemetryWithProperties.Properties.ContainsKey("Kubernetes.Container.ID"));
Assert.True(telemetryWithProperties.Properties.ContainsKey("Kubernetes_Container_ID"));
}
private void AddCommonData(ISupportProperties telemetry)
{
if (_httpContextAccessor != null)
{
telemetry.Properties.Add("User", _httpContextAccessor.HttpContext.User.Identity.Name);
}
}
// Inserts properties into the telemetry's properties. Properly formats dates, removes nulls, applies prefix, etc.
private static void ApplyProperties(ISupportProperties telemetry, IEnumerable <KeyValuePair <string, object> > values, string propertyPrefix = null)
{
foreach (var property in values)
{
string stringValue = null;
// drop null properties
if (property.Value == null)
{
continue;
}
// Format dates
Type propertyType = property.Value.GetType();
if (propertyType == typeof(DateTime))
{
stringValue = ((DateTime)property.Value).ToUniversalTime().ToString(DateTimeFormatString);
}
else if (propertyType == typeof(DateTimeOffset))
{
stringValue = ((DateTimeOffset)property.Value).UtcDateTime.ToString(DateTimeFormatString);
}
else
{
stringValue = property.Value.ToString();
}
telemetry.Properties.Add($"{propertyPrefix}{property.Key}", stringValue);
}
}
private void SetCustomDimensions(ISupportProperties telemetry, Stopwatch cpuWatch, TimeSpan startCPUTime)
{
SetCustomDimensions(telemetry);
// Add CPU/Memory metrics to telemetry.
Process process = Process.GetCurrentProcess();
TimeSpan endCPUTime = process.TotalProcessorTime;
cpuWatch.Stop();
string cpuString = "NaN";
if (cpuWatch.ElapsedMilliseconds > 0)
{
int processorCount = Environment.ProcessorCount;
Debug.Assert(processorCount > 0, $"How could process count be {processorCount}?");
// A very simple but not that accurate evaluation of how much CPU the process is take out of a core.
double CPUPercentage = (endCPUTime - startCPUTime).TotalMilliseconds / (double)(cpuWatch.ElapsedMilliseconds);
cpuString = CPUPercentage.ToString("P2", CultureInfo.InvariantCulture);
}
long memoryInBytes = process.VirtualMemorySize64;
SetCustomDimension(telemetry, Invariant($"{ProcessString}.{CPU}(%)"), cpuString);
SetCustomDimension(telemetry, Invariant($"{ProcessString}.{Memory}"), memoryInBytes.GetReadableSize());
}
private static void ApplyProperty(ISupportProperties telemetry, string key, object value, string propertyPrefix = null)
{
// do not apply null values
if (value == null)
{
return;
}
string stringValue = null;
// Format dates
Type propertyType = value.GetType();
if (propertyType == typeof(DateTime))
{
stringValue = ((DateTime)value).ToUniversalTime().ToString(DateTimeFormatString);
}
else if (propertyType == typeof(DateTimeOffset))
{
stringValue = ((DateTimeOffset)value).UtcDateTime.ToString(DateTimeFormatString);
}
else
{
stringValue = value.ToString();
}
telemetry.Properties[$"{propertyPrefix}{key}"] = stringValue;
}
private void ForwardEventPropertiesToTelemetryProperties(LogEvent logEvent, ISupportProperties telemetryProperties, IFormatProvider formatProvider)
{
ForwardPropertiesToTelemetryProperties(logEvent, telemetryProperties, formatProvider,
includeLogLevel: false,
includeRenderedMessage: false,
includeMessageTemplate: false);
}
private static KeyValuePair <string, string>[] GetProperties(ISupportProperties telemetry, string specialPropertyName = null)
{
Dictionary <string, string> properties = null;
if (telemetry.Properties != null && telemetry.Properties.Count > 0)
{
properties = new Dictionary <string, string>(MaxPropertyCount + 1);
foreach (var prop in
telemetry.Properties.Where(p => !string.Equals(p.Key, specialPropertyName, StringComparison.Ordinal)).Take(MaxPropertyCount))
{
string truncatedKey = TruncateValue(prop.Key);
if (!properties.ContainsKey(truncatedKey))
{
properties.Add(truncatedKey, TruncateValue(prop.Value));
}
}
if (specialPropertyName != null)
{
string specialPropertyValue;
if (telemetry.Properties.TryGetValue(specialPropertyName, out specialPropertyValue))
{
properties.Add(TruncateValue(specialPropertyName), TruncateValue(specialPropertyValue));
}
}
}
return(properties != null?properties.ToArray() : null);
}
public static string GetProperty(this ISupportProperties propertiesTelemetry, string key, string defaultValue = null)
{
if (propertiesTelemetry.Properties.ContainsKey(key))
{
return(propertiesTelemetry.Properties[key]);
}
return(defaultValue);
}
protected void AssignTelemetryContextProperties(LogEvent logEvent, ISupportProperties telemetry)
{
AssignContextPropertiesFromDictionaryProperty(logEvent, telemetry, ContextProperties.TelemetryContext);
#pragma warning disable 618 // Until we remove obsolete 'EventDescription'.
AssignContextPropertiesFromDictionaryProperty(logEvent, telemetry, ContextProperties.EventTracking.EventContext);
#pragma warning restore 618
}
/// <summary>
/// Populates the state, scope and event information for the logging event.
/// </summary>
/// <typeparam name="TState">State information for the current event.</typeparam>
/// <param name="telemetryItem">Telemetry item.</param>
/// <param name="state">Event state information.</param>
/// <param name="eventId">Event Id information.</param>
private void PopulateTelemetry <TState>(ISupportProperties telemetryItem, TState state, EventId eventId)
{
IDictionary <string, string> dict = telemetryItem.Properties;
dict["CategoryName"] = this.categoryName;
if (eventId.Id != 0)
{
dict["EventId"] = eventId.Id.ToString(CultureInfo.InvariantCulture);
}
if (!string.IsNullOrEmpty(eventId.Name))
{
dict["EventName"] = eventId.Name;
}
if (this.applicationInsightsLoggerOptions.IncludeScopes)
{
if (state is IReadOnlyCollection <KeyValuePair <string, object> > stateDictionary)
{
foreach (KeyValuePair <string, object> item in stateDictionary)
{
dict[item.Key] = Convert.ToString(item.Value, CultureInfo.InvariantCulture);
}
}
if (this.ExternalScopeProvider != null)
{
StringBuilder stringBuilder = new StringBuilder();
this.ExternalScopeProvider.ForEachScope(
(activeScope, builder) =>
{
// Ideally we expect that the scope to implement IReadOnlyList<KeyValuePair<string, object>>.
// But this is not guaranteed as user can call BeginScope and pass anything. Hence
// we try to resolve the scope as Dictionary and if we fail, we just serialize the object and add it.
if (activeScope is IReadOnlyCollection <KeyValuePair <string, object> > activeScopeDictionary)
{
foreach (KeyValuePair <string, object> item in activeScopeDictionary)
{
dict[item.Key] = Convert.ToString(item.Value, CultureInfo.InvariantCulture);
}
}
else
{
builder.Append(" => ").Append(activeScope);
}
},
stringBuilder);
if (stringBuilder.Length > 0)
{
dict["Scope"] = stringBuilder.ToString();
}
}
}
}
/// <summary>
/// Add properties if not null or empty to a telemetry object that supports properties
/// </summary>
/// <param name="propertiesObject"></param>
/// <param name="dataName"></param>
/// <param name="dataValue"></param>
private void AddPropertyData(ISupportProperties propertiesObject, string dataName, string dataValue)
{
if (propertiesObject == null || string.IsNullOrEmpty(dataName) || string.IsNullOrEmpty(dataValue))
{
return;
}
propertiesObject.Properties[dataName] = dataValue;
}
/// <summary>
/// Forwards the log event properties to the provided <see cref="ISupportProperties" /> instance.
/// </summary>
/// <param name="telemetry">The telemetry.</param>
/// <param name="logEvent">The log event.</param>
/// <param name="renderedMessage">The rendered message.</param>
/// <returns></returns>
private void ForwardLogEventPropertiesToTelemetryProperties(ISupportProperties telemetry, LogEvent logEvent, string renderedMessage)
{
telemetry.Properties.Add("LogLevel", logEvent.Level.ToString());
telemetry.Properties.Add("RenderedMessage", renderedMessage);
foreach (var property in logEvent.Properties.Where(property => property.Value != null && !telemetry.Properties.ContainsKey(property.Key)))
{
telemetry.Properties.Add(property.Key, property.Value.ToString());
}
}
private static KeyValuePair<string, string>[] GetProperties(ISupportProperties telemetry, string specialPropertyName = null)
{
Dictionary<string, string> properties = null;
if (telemetry.Properties != null && telemetry.Properties.Count > 0)
{
properties = new Dictionary<string, string>(MaxPropertyCount + 1);
foreach (var prop in
telemetry.Properties
.Where(p => !string.Equals(p.Key, specialPropertyName, StringComparison.Ordinal))
.Take(MaxPropertyCount))
{
string truncatedKey = TruncateValue(prop.Key);
if (!properties.ContainsKey(truncatedKey))
{
properties.Add(truncatedKey, TruncateValue(prop.Value));
}
}
if (specialPropertyName != null)
{
string specialPropertyValue;
if (telemetry.Properties.TryGetValue(specialPropertyName, out specialPropertyValue))
{
properties.Add(TruncateValue(specialPropertyName), TruncateValue(specialPropertyValue));
}
}
}
return properties != null ? properties.ToArray() : null;
}
