1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections.Generic;
#if !ES_BUILD_AGAINST_DOTNET_V35
using Contract = System.Diagnostics.Contracts.Contract;
#else
using Contract = Microsoft.Diagnostics.Contracts.Internal.Contract;
#endif
#if ES_BUILD_STANDALONE
namespace Microsoft.Diagnostics.Tracing
#else
namespace System.Diagnostics.Tracing
#endif
{
/// <summary>
/// TraceLogging: used when implementing a custom TraceLoggingTypeInfo.
/// Non-generic base class for TraceLoggingTypeInfo<DataType>. Do not derive
/// from this class. Instead, derive from TraceLoggingTypeInfo<DataType>.
/// </summary>
internal abstract class TraceLoggingTypeInfo
{
private readonly string name;
private readonly EventKeywords keywords;
private readonly EventLevel level = (EventLevel)(-1);
private readonly EventOpcode opcode = (EventOpcode)(-1);
private readonly EventTags tags;
private readonly Type dataType;
private readonly Func<object, PropertyValue> propertyValueFactory;
internal TraceLoggingTypeInfo(Type dataType)
{
if (dataType == null)
{
throw new ArgumentNullException(nameof(dataType));
}
Contract.EndContractBlock();
this.name = dataType.Name;
this.dataType = dataType;
this.propertyValueFactory = PropertyValue.GetFactory(dataType);
}
internal TraceLoggingTypeInfo(
Type dataType,
string name,
EventLevel level,
EventOpcode opcode,
EventKeywords keywords,
EventTags tags)
{
if (dataType == null)
{
throw new ArgumentNullException(nameof(dataType));
}
if (name == null)
{
throw new ArgumentNullException("eventName");
}
Contract.EndContractBlock();
Statics.CheckName(name);
this.name = name;
this.keywords = keywords;
this.level = level;
this.opcode = opcode;
this.tags = tags;
this.dataType = dataType;
this.propertyValueFactory = PropertyValue.GetFactory(dataType);
}
/// <summary>
/// Gets the name to use for the event if this type is the top-level type,
/// or the name to use for an implicitly-named field.
/// Never null.
/// </summary>
public string Name
{
get { return this.name; }
}
/// <summary>
/// Gets the event level associated with this type. Any value in the range 0..255
/// is an associated event level. Any value outside the range 0..255 is invalid and
/// indicates that this type has no associated event level.
/// </summary>
public EventLevel Level
{
get { return this.level; }
}
/// <summary>
/// Gets the event opcode associated with this type. Any value in the range 0..255
/// is an associated event opcode. Any value outside the range 0..255 is invalid and
/// indicates that this type has no associated event opcode.
/// </summary>
public EventOpcode Opcode
{
get { return this.opcode; }
}
/// <summary>
/// Gets the keyword(s) associated with this type.
/// </summary>
public EventKeywords Keywords
{
get { return this.keywords; }
}
/// <summary>
/// Gets the event tags associated with this type.
/// </summary>
public EventTags Tags
{
get { return this.tags; }
}
internal Type DataType
{
get { return this.dataType; }
}
internal Func<object, PropertyValue> PropertyValueFactory
{
get { return this.propertyValueFactory; }
}
/// <summary>
/// When overridden by a derived class, writes the metadata (schema) for
/// this type. Note that the sequence of operations in WriteMetadata should be
/// essentially identical to the sequence of operations in
/// WriteData/WriteObjectData. Otherwise, the metadata and data will not match,
/// which may cause trouble when decoding the event.
/// </summary>
/// <param name="collector">
/// The object that collects metadata for this object's type. Metadata is written
/// by calling methods on the collector object. Note that if the type contains
/// sub-objects, the implementation of this method may need to call the
/// WriteMetadata method for the type of the sub-object, e.g. by calling
/// TraceLoggingTypeInfo<SubType>.Instance.WriteMetadata(...).
/// </param>
/// <param name="name">
/// The name of the property that contains an object of this type, or null if this
/// object is being written as a top-level object of an event. Typical usage
/// is to pass this value to collector.AddGroup.
/// </param>
/// <param name="format">
/// The format attribute for the field that contains an object of this type.
/// </param>
public abstract void WriteMetadata(
TraceLoggingMetadataCollector collector,
string name,
EventFieldFormat format);
/// <summary>
/// Refer to TraceLoggingTypeInfo.WriteObjectData for information about this
/// method.
/// </summary>
/// <param name="collector">
/// Refer to TraceLoggingTypeInfo.WriteObjectData for information about this
/// method.
/// </param>
/// <param name="value">
/// Refer to TraceLoggingTypeInfo.WriteObjectData for information about this
/// method.
/// </param>
public abstract void WriteData(
TraceLoggingDataCollector collector,
PropertyValue value);
/// <summary>
/// Fetches the event parameter data for internal serialization.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public virtual object GetData(object value)
{
return value;
}
[ThreadStatic] // per-thread cache to avoid synchronization
private static Dictionary<Type, TraceLoggingTypeInfo> threadCache;
public static TraceLoggingTypeInfo GetInstance(Type type, List<Type> recursionCheck)
{
var cache = threadCache ?? (threadCache = new Dictionary<Type, TraceLoggingTypeInfo>());
TraceLoggingTypeInfo instance;
if (!cache.TryGetValue(type, out instance))
{
if (recursionCheck == null)
recursionCheck = new List<Type>();
var recursionCheckCount = recursionCheck.Count;
instance = Statics.CreateDefaultTypeInfo(type, recursionCheck);
cache[type] = instance;
recursionCheck.RemoveRange(recursionCheckCount, recursionCheck.Count - recursionCheckCount);
}
return instance;
}
}
}
|
