private static void ProcessCounterEmit(CounterEmit emit)
{
// This is an expensive call, so make sure that we only make it once
string counterName = emit.GetCounterName();
int hashCode = CounterInstance.GetCounterHashCode(emit.Name, emit.Dimensions);
CounterInstance instance;
if (!instanceByNameCache.TryGetValue(counterName, out instance))
{
// The counter is not in the cache, so we need to get/create is in the database
using (var db = new CounterDatabase())
{
if (!TryGetInstanceFromDatabase(emit, hashCode, db, out instance))
{
CounterInstanceData counterInstanceData =
new CounterInstanceData()
{
Name = emit.Name,
InstanceHashCode = hashCode
};
if (counterInstanceData.Dimensions == null)
{
counterInstanceData.Dimensions = new List <CounterDimensionData>();
}
foreach (KeyValuePair <string, string> emitDimension in emit.Dimensions)
{
counterInstanceData.Dimensions.Add(
new CounterDimensionData(emitDimension.Key, emitDimension.Value));
}
db.Instances.Add(counterInstanceData);
db.SaveChanges();
instance = new CounterInstance(counterInstanceData);
}
// Add the newly created/retrieved counter instance to the cache
// TODO: Where does the TTL go???
instanceByNameCache.TryAdd(counterName, instance);
}
}
long ts = Convert.ToInt64(Math.Floor(emit.Timestamp.Subtract(Epoch).TotalSeconds));
CounterValueSet valueSet;
// Check if there is a valueSet for this particular timestamp. If not, add one
if (!instance.Values.TryGetValue(ts, out valueSet))
{
valueSet = new CounterValueSet(emit.Value, 1);
instance.Values.Add(ts, valueSet);
return;
}
valueSet.Sum += emit.Value;
valueSet.Count++;
}
internal Dictionary <long, CounterInstanceData> CreateActorMethodCounterInstanceData(
List <KeyValuePair <long, MethodInfo> > methodInfoList,
PerformanceCounterInstanceNameBuilder percCounterInstanceNameBuilder)
{
var actorMethodCounterInstanceData = new Dictionary <long, CounterInstanceData>();
// Compute the counter instance names for all the actor methods
var counterInstanceNames = percCounterInstanceNameBuilder.GetMethodCounterInstanceNames(methodInfoList);
FabricPerformanceCounterSet actorMethodCounterSet;
if (!AvaiableFabricCounterSet.TryGetValue(ActorPerformanceCounters.ActorMethodCategoryName,
out actorMethodCounterSet))
{
ActorTrace.Source.WriteWarning(
TraceType,
"PerformanceCounterSet not generated yet for category {0}",
ActorPerformanceCounters.ActorMethodCategoryName);
return(null);
}
foreach (var kvp in counterInstanceNames)
{
var data = new CounterInstanceData {
InstanceName = kvp.Value
};
data.CounterWriters = this.CreateCounterWriters(data, actorMethodCounterSet);
actorMethodCounterInstanceData[kvp.Key] = data;
}
return
(actorMethodCounterInstanceData);
}
protected override void ProcessRecord()
{
DateTime epoch = new DateTime(1970, 1, 1);
using (var db = new CounterDatabase())
{
List <CounterInstanceData> ins = db.Instances
.Where(i => i.Id == this.CounterId)
.Include(i => i.Dimensions)
.ToList();
if (!ins.Any())
{
throw new Exception("No counters found with ID " + this.CounterId);
}
CounterInstanceData instance = ins.First();
foreach (var val in db.Values.Where(v => v.CounterInstanceId == instance.Id))
{
SyncProCounterValue temp = new SyncProCounterValue
{
Count = val.Count,
Timestamp = epoch.AddSeconds(val.Timestamp),
Value = val.Value,
};
this.WriteObject(temp);
}
}
}
/// <summary>
/// Obtiene la instancia de contador especificada
/// </summary>
/// <param name="categoryName">Nombre de la categoría</param>
/// <param name="counterName">Nombre del contador</param>
/// <param name="instanceName">Nombre de la instancia</param>
/// <returns>Instancia de contador especificada o nula de lo contrario</returns>
public static CounterInstanceData GetPerformanceCounterInstance(string categoryName,
string counterName, string instanceName)
{
CounterInstanceData instanceData = null;
if (HasCategory(categoryName))
{
instanceData = categoryDataList[categoryName].GetCounterInstance(counterName,
instanceName);
}
return(instanceData);
}
/// <summary>
/// Incrementa en 1 la instancia del contador especificado
/// </summary>
/// <param name="categoryName">Nombre de la categoría del contador</param>
/// <param name="counterName">Nombre del contador</param>
/// <param name="instanceName">Nombre de la instancia del contador</param>
public static void IncreaseCounter(string categoryName, string counterName,
string instanceName)
{
if (isInitialized)
{
CounterInstanceData instanceData =
PerformanceCounterContainer.GetPerformanceCounterInstance(categoryName, counterName, instanceName);
if (instanceData != null)
{
instanceData.IncreaseCounter();
}
}
}
private MethodSpecificCounterWriters CreateCounterWriters(
CounterInstanceData counterInstanceData,
FabricPerformanceCounterSet ActorMethodCounterSet)
{
var logCounterWriterCreation = false;
// We have not yet created the objects that write the counter values. So build
// up the list of counter writers now.
var instanceName = counterInstanceData.InstanceName;
var tempCounterWriters = new MethodSpecificCounterWriters();
try
{
tempCounterWriters.ActorMethodCounterSetInstance =
ActorMethodCounterSet.CreateCounterSetInstance(instanceName);
}
catch (Exception ex)
{
//Instance creation failed, Be done.
ActorTrace.Source.WriteWarning(
TraceType,
"Data for performance counter instance {0} of category {1} will not be provided because an exception occurred during its initialization. Exception info: {2}",
instanceName, ActorPerformanceCounters.ActorMethodCategoryName, ex);
return(null);
}
tempCounterWriters.ActorMethodFrequencyCounterWriter = this.CreateMethodCounterWriter(
instanceName,
typeof(ActorMethodFrequencyCounterWriter),
tempCounterWriters.ActorMethodCounterSetInstance,
inst => new ActorMethodFrequencyCounterWriter(inst));
tempCounterWriters.ActorMethodExceptionFrequencyCounterWriter = this.CreateMethodCounterWriter(
instanceName,
typeof(ActorMethodExceptionFrequencyCounterWriter),
tempCounterWriters.ActorMethodCounterSetInstance,
inst => new ActorMethodExceptionFrequencyCounterWriter(inst));
tempCounterWriters.ActorMethodExecTimeCounterWriter = this.CreateMethodCounterWriter(
instanceName,
typeof(ActorMethodExecTimeCounterWriter),
tempCounterWriters.ActorMethodCounterSetInstance,
inst => new ActorMethodExecTimeCounterWriter(inst));
logCounterWriterCreation = true;
if (logCounterWriterCreation)
{
object[] newlyCreatedCounterWriters =
{
tempCounterWriters.ActorMethodFrequencyCounterWriter,
tempCounterWriters.ActorMethodExceptionFrequencyCounterWriter,
tempCounterWriters.ActorMethodExecTimeCounterWriter
};
foreach (var newlyCreatedCounterWriter in newlyCreatedCounterWriters)
{
if (null != newlyCreatedCounterWriter)
{
this.LogCounterInstanceCreationResult(
newlyCreatedCounterWriter.GetType(),
counterInstanceData.InstanceName,
null);
}
}
}
return(tempCounterWriters);
}