/// <summary>
/// Converts from model to recipe.
/// </summary>
/// <param name="sample">Model sample.</param>
/// <returns>Recipe description.</returns>
public static RecipePerformanceCounterSample FromModel(this PerformanceCounterSample sample)
{
if (sample == null)
{
throw new ArgumentNullException(nameof(sample));
}
return(sample.ToRecipe());
}
/// <summary>
/// Converts from recipe to model.
/// </summary>
/// <param name="sample">Recipe sample.</param>
/// <returns>Model description.</returns>
public static PerformanceCounterSample ToModel(this RecipePerformanceCounterSample sample)
{
if (sample == null)
{
throw new ArgumentNullException(nameof(sample));
}
var result = new PerformanceCounterSample(sample.Description.ToModel(), sample.Value);
return(result);
}
public PerformanceCounterSampleSet ReadNextSet()
{
this._firstRead.Wait();
long fileTimeStamp = 0;
uint returnCode = this._isPreVista ? Apis.PdhCollectQueryData(this._safeQueryHandle)
: Apis.PdhCollectQueryDataWithTime(this._safeQueryHandle, ref fileTimeStamp);
if (this._isLastSampleBad)
{
return(null);
}
if (returnCode != PdhResults.PDH_CSTATUS_VALID_DATA)
{
//this makes sure next call to ReadNextSet doesn't examine the data, and just returns null
this._isLastSampleBad = true;
return(null);
}
DateTime now = (_isPreVista || returnCode == PdhResults.PDH_NO_DATA) ? DateTime.Now :
new DateTime(DateTime.FromFileTimeUtc(fileTimeStamp).Ticks, DateTimeKind.Local);
PerformanceCounterSample[] counterSamples = new PerformanceCounterSample[this._consumerPathToHandleAndInstanceMap.Count];
int samplesRead = 0;
foreach (string key in this._consumerPathToHandleAndInstanceMap.Keys)
{
IntPtr counterHandle = this._consumerPathToHandleAndInstanceMap[key].CounterHandle;
CounterInfo info = PdhHelper.GetCounterInfo(counterHandle);
var sample = GetRawCounterSample(counterHandle, key, info, now);
var performanceSample = sample.PerformanceCounterSample ?? GetFormattedCounterSample(counterHandle, key, info, sample.RawCounter);
if (!this._ignoreBadStatusCodes && (performanceSample.Status != 0))
{
throw BuildException(performanceSample.Status);
}
if (performanceSample.Status != 0)
{
_log.Info(() => string.Format("Status {0:x} ignored for counter {1}", performanceSample.Status, key));
continue;
}
counterSamples[samplesRead++] = performanceSample;
}
this._isLastSampleBad = false;
//in the event we skipped bad data
if (samplesRead < counterSamples.Length)
{
Array.Resize(ref counterSamples, samplesRead);
}
return(new PerformanceCounterSampleSet(this._isPreVista ? counterSamples[samplesRead].Timestamp : now, counterSamples));
}
public static void IsInRange___When_range_not_provided___Gets_null_serialized_to_json()
{
// Arrange
var description = new PerformanceCounterDescription(A.Dummy <string>(), A.Dummy <string>(), A.Dummy <string>());
var sample = new PerformanceCounterSample(description, 10);
// Act
var json = Serializer.SerializeToString(sample);
// Assert
json.Should().Contain("\"inRange\": null");
}
public static void Model_Recipe_conversions___Roundtrip()
{
// Arrange
var inputDescription = new PerformanceCounterDescription(A.Dummy <string>(), A.Dummy <string>(), A.Dummy <string>(), A.Dummy <float>(), A.Dummy <float>());
var inputSample = new PerformanceCounterSample(inputDescription, A.Dummy <float>());
// Act
var actualDescription = inputDescription.ToRecipe().ToModel().FromModel().FromRecipe();
var actualSample = inputSample.ToRecipe().ToModel().FromModel().FromRecipe();
// Assert
actualDescription.Should().BeOfType(inputDescription.GetType());
actualSample.Should().BeOfType(inputSample.GetType());
var inputDescriptionJson = Serializer.SerializeToString(inputDescription);
var actualDescriptionJson = Serializer.SerializeToString(actualDescription);
actualDescriptionJson.Should().Be(inputDescriptionJson);
var inputSampleJson = Serializer.SerializeToString(inputSample);
var actualSampleJson = Serializer.SerializeToString(actualSample);
actualSampleJson.Should().Be(inputSampleJson);
}
public long SetCounterValue(PerformanceCounterSample sample, out bool bUnknownPath)
{
bUnknownPath = false;
string key = sample.Path.ToLower(CultureInfo.InvariantCulture);
if (!this.m_ReloggerPathToHandleAndInstanceMap.ContainsKey(key))
{
bUnknownPath = true;
return(0);
}
PDH_RAW_COUNTER pdh_raw_counter = new PDH_RAW_COUNTER {
FirstValue = (long)sample.RawValue,
SecondValue = (long)sample.SecondValue,
MultiCount = sample.MultipleCount
};
DateTime time2 = new DateTime(sample.Timestamp.Ticks, DateTimeKind.Utc);
pdh_raw_counter.TimeStamp.dwHighDateTime = (int)(((ulong)(time2.ToFileTimeUtc() >> 0x20)) & 0xffffffffL);
DateTime time4 = new DateTime(sample.Timestamp.Ticks, DateTimeKind.Utc);
pdh_raw_counter.TimeStamp.dwLowDateTime = (int)(((ulong)time4.ToFileTimeUtc()) & 0xffffffffL);
pdh_raw_counter.CStatus = sample.Status;
return(PdhSetCounterValue(this.m_ReloggerPathToHandleAndInstanceMap[key].hCounter, ref pdh_raw_counter, this.m_ReloggerPathToHandleAndInstanceMap[key].InstanceName));
}
public void ToGraphiteString_GeneratesExpectedMetrics(string key, PerformanceCounterSample sample, string expected)
{
string converted = new [] { sample }.ToGraphiteString(key).First();
Assert.Equal(expected, converted);
}
public DiagnosticsDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new AssemblyDetails(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new OperatingSystemDetails(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new MachineDetails(
A.Dummy <Dictionary <string, string> >(),
A.Dummy <int>(),
A.Dummy <Dictionary <string, decimal> >(),
A.Dummy <bool>(),
A.Dummy <OperatingSystemDetails>(),
A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new ProcessDetails(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <bool>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new PerformanceCounterDescription(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <float>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new PerformanceCounterSample(
A.Dummy <PerformanceCounterDescription>(),
A.Dummy <float>());
return(result);
});
}
public long ReadNextSetPreVista(out PerformanceCounterSampleSet nextSet, bool bSkipReading)
{
long num = 0;
nextSet = null;
num = PdhCollectQueryData(this.m_hQuery);
if (bSkipReading)
{
return(num);
}
if ((num != 0) && (num != 0x800007d5L))
{
return(num);
}
PerformanceCounterSample[] counterSamples = new PerformanceCounterSample[this.m_ConsumerPathToHandleAndInstanceMap.Count];
long num2 = 0;
long num3 = 0;
long num4 = 0;
DateTime now = DateTime.Now;
foreach (string str in this.m_ConsumerPathToHandleAndInstanceMap.Keys)
{
PDH_RAW_COUNTER pdh_raw_counter;
IntPtr lpdwType = new IntPtr(0);
long counterType = 0x40030403;
long defaultScale = 0;
ulong timeBase = 0L;
IntPtr hCounter = this.m_ConsumerPathToHandleAndInstanceMap[str].hCounter;
this.GetCounterInfoPlus(hCounter, out counterType, out defaultScale, out timeBase);
num = PdhGetRawCounterValue(hCounter, out lpdwType, out pdh_raw_counter);
switch (num)
{
case 0xc0000bc6L:
case 0x800007d5L:
counterSamples[num2++] = new PerformanceCounterSample(str, this.m_ConsumerPathToHandleAndInstanceMap[str].InstanceName, 0.0, 0L, 0L, 0, PerformanceCounterType.RawBase, defaultScale, timeBase, DateTime.Now, (ulong)DateTime.Now.ToFileTime(), pdh_raw_counter.CStatus);
num3++;
num4 = num;
break;
default:
{
PDH_FMT_COUNTERVALUE_DOUBLE pdh_fmt_countervalue_double;
if (num != 0)
{
return(num);
}
long fileTime = (pdh_raw_counter.TimeStamp.dwHighDateTime << 0x20) + ((long)((ulong)pdh_raw_counter.TimeStamp.dwLowDateTime));
now = new DateTime(DateTime.FromFileTimeUtc(fileTime).Ticks, DateTimeKind.Local);
num = PdhGetFormattedCounterValue(hCounter, 0x8200, out lpdwType, out pdh_fmt_countervalue_double);
switch (num)
{
case 0xc0000bc6L:
case 0x800007d5L:
{
counterSamples[num2++] = new PerformanceCounterSample(str, this.m_ConsumerPathToHandleAndInstanceMap[str].InstanceName, 0.0, (ulong)pdh_raw_counter.FirstValue, (ulong)pdh_raw_counter.SecondValue, pdh_raw_counter.MultiCount, (PerformanceCounterType)counterType, defaultScale, timeBase, now, (ulong)fileTime, pdh_fmt_countervalue_double.CStatus);
num3++;
num4 = num;
continue;
}
}
if (num != 0)
{
return(num);
}
counterSamples[num2++] = new PerformanceCounterSample(str, this.m_ConsumerPathToHandleAndInstanceMap[str].InstanceName, pdh_fmt_countervalue_double.doubleValue, (ulong)pdh_raw_counter.FirstValue, (ulong)pdh_raw_counter.SecondValue, pdh_raw_counter.MultiCount, (PerformanceCounterType)lpdwType.ToInt32(), defaultScale, timeBase, now, (ulong)fileTime, pdh_fmt_countervalue_double.CStatus);
break;
}
}
}
nextSet = new PerformanceCounterSampleSet(now, counterSamples, this.m_firstReading);
this.m_firstReading = false;
if (num3 == counterSamples.Length)
{
return(num4);
}
return(0);
}
public void ToGraphiteString_GeneratesExpectedMetrics(string key, PerformanceCounterSample sample, string expected)
{
string converted = new [] { sample }.ToGraphiteString(key).First();
Assert.Equal(expected, converted);
}
public static void SetNetwork(this HealthReport report, PerformanceCounterSample receivedCounterSample, PerformanceCounterSample sentCounterSample, PerformanceCounterSample totalCounterSample)
{
report.NetworkBytesInPerSec = receivedCounterSample.CookedValue;
report.NetworkBytesOutPerSec = sentCounterSample.CookedValue;
report.NetworkBytesTotalPerSec = totalCounterSample.CookedValue;
}
