/// <summary>
/// Configures the diagnostic monitor.
/// </summary>
private void ConfigureDiagnosticMonitor()
{
var diagnosticMonitorConfiguration = DiagnosticMonitor.GetDefaultInitialConfiguration();
diagnosticMonitorConfiguration.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
diagnosticMonitorConfiguration.Directories.BufferQuotaInMB = 100;
diagnosticMonitorConfiguration.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
diagnosticMonitorConfiguration.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
diagnosticMonitorConfiguration.WindowsEventLog.DataSources.Add("Application!*");
diagnosticMonitorConfiguration.WindowsEventLog.DataSources.Add("System!*");
diagnosticMonitorConfiguration.WindowsEventLog.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
var performanceCounterConfiguration = new PerformanceCounterConfiguration
{
CounterSpecifier = @"\Processor(_Total)\% Processor Time",
SampleRate = TimeSpan.FromSeconds(10d)
};
diagnosticMonitorConfiguration.PerformanceCounters.DataSources.Add(performanceCounterConfiguration);
diagnosticMonitorConfiguration.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
// TODO: removed due to reference to the old storage client
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diagnosticMonitorConfiguration);
}
/// <summary>
/// Configures the diagnostic monitor.
/// </summary>
private void ConfigureDiagnosticMonitor()
{
var diagnosticMonitorConfiguration = DiagnosticMonitor.GetDefaultInitialConfiguration();
diagnosticMonitorConfiguration.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
diagnosticMonitorConfiguration.Directories.BufferQuotaInMB = 100;
diagnosticMonitorConfiguration.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
diagnosticMonitorConfiguration.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
diagnosticMonitorConfiguration.WindowsEventLog.DataSources.Add("Application!*");
diagnosticMonitorConfiguration.WindowsEventLog.DataSources.Add("System!*");
diagnosticMonitorConfiguration.WindowsEventLog.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
var performanceCounterConfiguration = new PerformanceCounterConfiguration
{
CounterSpecifier = @"\Processor(_Total)\% Processor Time",
SampleRate = TimeSpan.FromSeconds(10d)
};
diagnosticMonitorConfiguration.PerformanceCounters.DataSources.Add(performanceCounterConfiguration);
diagnosticMonitorConfiguration.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
// TODO: removed due to reference to the old storage client
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diagnosticMonitorConfiguration);
}
public void InitializeConfiguration()
{
String eventLog = "Application!*";
String performanceCounter = @"\Processor(_Total)\% Processor Time";
DiagnosticMonitorConfiguration dmc = DiagnosticMonitor.GetDefaultInitialConfiguration();
dmc.DiagnosticInfrastructureLogs.BufferQuotaInMB = 100;
dmc.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = TimeSpan.FromHours(1);
dmc.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
dmc.WindowsEventLog.BufferQuotaInMB = 100;
dmc.WindowsEventLog.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
dmc.WindowsEventLog.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
dmc.WindowsEventLog.DataSources.Add(eventLog);
dmc.Logs.BufferQuotaInMB = 100;
dmc.Logs.ScheduledTransferPeriod = TimeSpan.FromHours(1);
dmc.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
dmc.Directories.ScheduledTransferPeriod = TimeSpan.FromHours(1);
PerformanceCounterConfiguration perfCounterConfiguration = new PerformanceCounterConfiguration();
perfCounterConfiguration.CounterSpecifier = performanceCounter;
perfCounterConfiguration.SampleRate = System.TimeSpan.FromSeconds(10);
dmc.PerformanceCounters.DataSources.Add(perfCounterConfiguration);
dmc.PerformanceCounters.BufferQuotaInMB = 100;
dmc.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromHours(1);
DiagnosticMonitor.Start(cloudStorageAccount, dmc);
}
public TrackedPerformanceCounter(PerformanceCounterConfiguration configuration)
{
Requires.NotNull(configuration, nameof(configuration));
this.Configuration = configuration;
// Set the lastAccessedOn time way in the past so that the data is sampled at startup
this.lastAccessedOn = DateTimeOffset.UtcNow.Subtract(TimeSpan.FromDays(1));
this.disposed = false;
}
private void AreEqual(PerformanceCounterConfiguration exp, PerformanceCounterConfiguration act)
{
if (exp != null)
{
AreEqual(exp.Annotations, act.Annotations);
Assert.Equal(exp.CounterSpecifier, act.CounterSpecifier);
Assert.Equal(exp.SampleRate, act.SampleRate);
Assert.Equal(exp.Unit, act.Unit);
}
}
/// <summary>
/// Enables performance counters
/// Note: PerformanceCounterConfiguration.CounterSpecifier is language specific and depends on your OS language.
/// Note: For a complete list of possible PerformanceCounterConfiguration.CounterSpecifier values run "typeperf.exe /Q"
/// </summary>
/// <param name="diagnosticMonitorConfiguration"></param>
void AddPerformanceCounterMonitoring(DiagnosticMonitorConfiguration diagnosticMonitorConfiguration)
{
var performanceCounterConfiguration =
new PerformanceCounterConfiguration
{
CounterSpecifier = @"\Processor(*)\% Processor Time",
SampleRate = TimeSpan.FromSeconds(15)
};
diagnosticMonitorConfiguration.PerformanceCounters.DataSources.Add(performanceCounterConfiguration);
}
public string GetCounterInstanceNameForCurrentProcess(PerformanceCounterConfiguration counterConfiguration)
{
Requires.NotNull(counterConfiguration, nameof(counterConfiguration));
var key = new CacheKey(counterConfiguration.ProcessIdCounterCategory, counterConfiguration.ProcessIdCounterName);
string instanceName;
if (this.instanceNames.TryGetValue(key, out instanceName))
{
return(instanceName);
}
Process currentProcess = Process.GetCurrentProcess();
if (counterConfiguration.UseDotNetInstanceNameConvention)
{
instanceName = VersioningHelper.MakeVersionSafeName(currentProcess.ProcessName, ResourceScope.Machine, ResourceScope.AppDomain);
// We actually don't need the AppDomain portion, but there is no way to get the runtime ID without AppDomain id attached.
// So we just filter it out
int adIdIndex = instanceName.LastIndexOf("_ad");
if (adIdIndex > 0)
{
instanceName = instanceName.Substring(0, adIdIndex);
}
this.instanceNames[key] = instanceName;
return(instanceName);
}
else
{
PerformanceCounterCategory category = new PerformanceCounterCategory(counterConfiguration.ProcessIdCounterCategory);
string[] processInstanceNames = category.GetInstanceNames()
.Where(inst => inst.StartsWith(currentProcess.ProcessName))
.ToArray();
foreach (string processInstanceName in processInstanceNames)
{
using (PerformanceCounter cnt = new PerformanceCounter(counterConfiguration.ProcessIdCounterCategory, counterConfiguration.ProcessIdCounterName, processInstanceName, readOnly: true))
{
int val = (int)cnt.RawValue;
if (val == currentProcess.Id)
{
this.instanceNames[key] = processInstanceName;
return(processInstanceName);
}
}
}
}
this.instanceNames[key] = null;
return(null);
}
private void ConfigureDiagnostics()
{
String wadConnectionString = "Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString";
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue(wadConnectionString));
DiagnosticMonitorConfiguration dmc = DiagnosticMonitor.GetDefaultInitialConfiguration();
PerformanceCounterConfiguration pmc = new PerformanceCounterConfiguration()
{
CounterSpecifier = @"\Processor(_Total)\% Processor Time",
SampleRate = System.TimeSpan.FromSeconds(10)
};
dmc.PerformanceCounters.DataSources.Add( pmc);
dmc.PerformanceCounters.BufferQuotaInMB = 100;
dmc.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
DiagnosticMonitor.Start(cloudStorageAccount, dmc);
}
private void ConfigureDiagnosticMonitor()
{
DiagnosticMonitorConfiguration diagnosticMonitorConfiguration = DiagnosticMonitor.GetDefaultInitialConfiguration();
diagnosticMonitorConfiguration.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
diagnosticMonitorConfiguration.Directories.BufferQuotaInMB = 100;
diagnosticMonitorConfiguration.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
diagnosticMonitorConfiguration.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
diagnosticMonitorConfiguration.WindowsEventLog.DataSources.Add("Application!*");
diagnosticMonitorConfiguration.WindowsEventLog.DataSources.Add("System!*");
diagnosticMonitorConfiguration.WindowsEventLog.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
PerformanceCounterConfiguration performanceCounterConfiguration = new PerformanceCounterConfiguration();
performanceCounterConfiguration.CounterSpecifier = @"\Processor(_Total)\% Processor Time";
performanceCounterConfiguration.SampleRate = System.TimeSpan.FromSeconds(10d);
diagnosticMonitorConfiguration.PerformanceCounters.DataSources.Add(performanceCounterConfiguration);
diagnosticMonitorConfiguration.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
DiagnosticMonitor.Start(DignosticsConnectionString, diagnosticMonitorConfiguration);
}
// adjust these settings to your needs
private void ConfigureDiagnosticMonitoring()
{
var standardTransfer = TimeSpan.FromMinutes(60);
var pollInterval = TimeSpan.FromMinutes(10);
// retrieve standard config
var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
// check for config changes
config.ConfigurationChangePollInterval = pollInterval;
// traces transfer
config.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
config.Logs.ScheduledTransferPeriod = standardTransfer;
// infrastructure traces
config.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = LogLevel.Error;
config.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = standardTransfer;
// automatic transfer of application event log
config.WindowsEventLog.DataSources.Add("Application!*");
config.WindowsEventLog.DataSources.Add("System!*");
config.WindowsEventLog.ScheduledTransferLogLevelFilter = LogLevel.Warning;
config.WindowsEventLog.ScheduledTransferPeriod = standardTransfer;
// automatic transfer of CPU load
var procTime = new PerformanceCounterConfiguration
{
CounterSpecifier = @"\Processor(*)\% Processor Time",
SampleRate = TimeSpan.FromMinutes(1)
};
config.PerformanceCounters.DataSources.Add(procTime);
config.PerformanceCounters.ScheduledTransferPeriod = standardTransfer;
// send config to monitor
DiagnosticMonitor.Start(DiagnosticStorage, config);
}
// adjust these settings to your needs
private void ConfigureDiagnosticMonitoring()
{
var standardTransfer = TimeSpan.FromMinutes(60);
var pollInterval = TimeSpan.FromMinutes(10);
// retrieve standard config
var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
// check for config changes
config.ConfigurationChangePollInterval = pollInterval;
// traces transfer
config.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
config.Logs.ScheduledTransferPeriod = standardTransfer;
// infrastructure traces
config.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = LogLevel.Error;
config.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = standardTransfer;
// automatic transfer of application event log
config.WindowsEventLog.DataSources.Add("Application!*");
config.WindowsEventLog.DataSources.Add("System!*");
config.WindowsEventLog.ScheduledTransferLogLevelFilter = LogLevel.Warning;
config.WindowsEventLog.ScheduledTransferPeriod = standardTransfer;
// automatic transfer of CPU load
var procTime = new PerformanceCounterConfiguration
{
CounterSpecifier = @"\Processor(*)\% Processor Time",
SampleRate = TimeSpan.FromMinutes(1)
};
config.PerformanceCounters.DataSources.Add(procTime);
config.PerformanceCounters.ScheduledTransferPeriod = standardTransfer;
// send config to monitor
DiagnosticMonitor.Start(DiagnosticStorage, config);
}
private static void ConfigureDiagnosticMonitor()
{
var storageAccount = CloudStorageAccount.FromConfigurationSetting(wadConnectionString);
var roleInstanceDiagnosticManager = storageAccount.CreateRoleInstanceDiagnosticManager(RoleEnvironment.DeploymentId, RoleEnvironment.CurrentRoleInstance.Role.Name, RoleEnvironment.CurrentRoleInstance.Id);
var diagnosticMonitorConfiguration = roleInstanceDiagnosticManager.GetCurrentConfiguration();
// Performance Counters
ConfiguredCounters.ToList().ForEach(
counter =>
{
var counterConfiguration = new PerformanceCounterConfiguration
{
CounterSpecifier = counter,
SampleRate = TimeSpan.FromSeconds(30)
};
diagnosticMonitorConfiguration.PerformanceCounters.DataSources.Add(counterConfiguration);
});
diagnosticMonitorConfiguration.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
roleInstanceDiagnosticManager.SetCurrentConfiguration(diagnosticMonitorConfiguration);
}
public override bool OnStart()
{
Trace.WriteLine("OrleansAzureWeb-OnStart");
// For information on handling configuration changes see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
#region Setup CloudStorageAccount Configuration Setting Publisher
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
CloudStorageAccount.SetConfigurationSettingPublisher(
(string configName, Func<string, bool> configSetter) =>
{
// Provide the configSetter with the initial value
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (sender, arg) =>
{
if (arg.Changes.OfType<RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
// The corresponding configuration setting has changed, propagate the value
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
// In this case, the change to the storage account credentials in the
// service configuration is significant enough that the role needs to be
// recycled in order to use the latest settings. (for example, the
// endpoint has changed)
RoleEnvironment.RequestRecycle();
}
}
};
});
#endregion
// DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString");
// System.Diagnostics.Trace.Listeners.Add(new Microsoft.WindowsAzure.Diagnostics.DiagnosticMonitorTraceListener());
// System.Diagnostics.Trace.Listeners.Add(new Microsoft.
//WindowsAzure.Diagnostics.DiagnosticMonitorTraceListener());
// System.Diagnostics.Trace.AutoFlush = true;
// System.Diagnostics.Trace.TraceInformation("Information");
DiagnosticMonitorConfiguration diagConfig = DiagnosticMonitor.GetDefaultInitialConfiguration();
var perfCounters = new List<string>
{
@"\Processor(_Total)\% Processor Time",
@"\Memory\Available Mbytes",
@"\TCPv4\Connections Established",
@"\ASP.NET Applications(__Total__)\Requests/Sec",
@"\Network Interface(*)\Bytes Received/sec",
@"\Network Interface(*)\Bytes Sent/sec"
};
// Add perf counters to configuration
foreach (var counter in perfCounters)
{
var counterConfig = new PerformanceCounterConfiguration
{
CounterSpecifier = counter,
SampleRate = TimeSpan.FromSeconds(5)
};
diagConfig.PerformanceCounters.DataSources.Add(counterConfig);
}
diagConfig.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(1.0);
//Windows Event Logs
diagConfig.WindowsEventLog.DataSources.Add("System!*");
diagConfig.WindowsEventLog.DataSources.Add("Application!*");
diagConfig.WindowsEventLog.ScheduledTransferPeriod = TimeSpan.FromMinutes(1.0);
diagConfig.WindowsEventLog.ScheduledTransferLogLevelFilter = LogLevel.Warning;
//Azure Trace Logs
diagConfig.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1.0);
diagConfig.Logs.ScheduledTransferLogLevelFilter = LogLevel.Warning;
//Crash Dumps
CrashDumps.EnableCollection(true);
//IIS Logs
diagConfig.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(1.0);
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diagConfig);
bool ok = base.OnStart();
Trace.WriteLine("OrleansAzureWeb-OnStart completed with OK=" + ok);
return ok;
}
private static void EnableCounters(int sampleRateInSeconds, int transferPeriodInSeconds, string[] counters, RoleInstanceDiagnosticManager ridmN)
{
DiagnosticMonitorConfiguration dmc = ridmN.GetCurrentConfiguration();
foreach (string counter in counters)
{
if (!string.IsNullOrWhiteSpace(counter))
{
PerformanceCounterConfiguration pcc = new PerformanceCounterConfiguration();
pcc.CounterSpecifier = counter.Trim();
pcc.SampleRate = TimeSpan.FromSeconds(sampleRateInSeconds);
dmc.PerformanceCounters.DataSources.Add(pcc);
Trace.WriteLine(string.Format("Counter '{0}' Sample Rate {1} seconds", counter, sampleRateInSeconds));
}
}
dmc.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromSeconds(transferPeriodInSeconds);
ridmN.SetCurrentConfiguration(dmc);
}
public static void SetScheduledCountersStorage(ref DiagnosticMonitorConfiguration diagMonConf, int TransferPeriodmin, string CounterSpec, int sampleratesec)
{
//CounterSpec = @"\Processor(*)\% Processor Time";
PerformanceCounterConfiguration pcc = new PerformanceCounterConfiguration();
pcc.CounterSpecifier = CounterSpec;
pcc.SampleRate = TimeSpan.FromSeconds(sampleratesec);
diagMonConf.PerformanceCounters.DataSources.Add(pcc);
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
diagMonConf.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(TransferPeriodmin);
}
static void Main(string[] args)
{
string configXmlDir = Environment.CurrentDirectory;
if (args.Length == 1)
{
configXmlDir = args[0];
}
string configXmlPath = Path.Combine(configXmlDir, "DiagnosticsConfiguration.xml");
if (!File.Exists(configXmlPath))
{
throw new InvalidOperationException(string.Format("Unable to find diagnostics configuration xml @ {0}", configXmlPath));
}
XmlSerializer serializer = new XmlSerializer(typeof(DiagnosticsConfig));
DiagnosticsConfig diagConfig = null;
using (Stream fs = File.OpenRead(configXmlPath))
{
diagConfig = serializer.Deserialize(fs) as DiagnosticsConfig;
}
DiagnosticMonitorConfiguration config = DiagnosticMonitor.GetDefaultInitialConfiguration();
config.OverallQuotaInMB = diagConfig.OverallQuotaInMB;
if (diagConfig.Directories.Directory != null)
{
foreach (DiagnosticsConfigDirectoriesDirectory dir in diagConfig.Directories.Directory)
{
DirectoryConfiguration directoryConfig = new DirectoryConfiguration();
directoryConfig.Container = dir.ContainerName;
if (dir.IsLocalPathRelative)
{
directoryConfig.Path = Path.Combine(Environment.CurrentDirectory, dir.LocalPath);
}
else
{
directoryConfig.Path = dir.LocalPath;
}
directoryConfig.DirectoryQuotaInMB = dir.DirectoryQuotaInMB;
config.Directories.DataSources.Add(directoryConfig);
}
config.Directories.ScheduledTransferPeriod = TimeSpan.FromSeconds(diagConfig.Directories.ScheduledTransferPeriodInSeconds);
}
if (diagConfig.PerformanceCounters.PerformanceCounter != null)
{
foreach (DiagnosticsConfigPerformanceCountersPerformanceCounter perf in diagConfig.PerformanceCounters.PerformanceCounter)
{
PerformanceCounterConfiguration perfConfig = new PerformanceCounterConfiguration();
perfConfig.CounterSpecifier = perf.CounterName;
perfConfig.SampleRate = TimeSpan.FromSeconds(perf.SamplingRateInSeconds);
config.PerformanceCounters.DataSources.Add(perfConfig);
}
config.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromSeconds(diagConfig.PerformanceCounters.ScheduledTransferPeriodInSeconds);
}
DiagnosticMonitor.Start(CloudStorageAccount.Parse(diagConfig.StorageAccountConnectionString), config);
Trace.WriteLine("ConfigureAzureDiagnostics Started.", "Information");
Console.ReadLine();
}
public void ModifyConfiguration(String deploymentId, String roleName, String instanceId)
{
String eventLog = @"Application!*[System[Provider[@Name='.NET Runtime']]]";
String performanceCounter = @"\ASP.NET\Requests Rejected";
RoleInstanceDiagnosticManager ridm = cloudStorageAccount.CreateRoleInstanceDiagnosticManager(deploymentId, roleName, instanceId);
DiagnosticMonitorConfiguration dmc = ridm.GetCurrentConfiguration();
Int32 countDataSources = dmc.WindowsEventLog.DataSources.Count(item => item == eventLog);
if (countDataSources == 0)
{
dmc.WindowsEventLog.DataSources.Add(eventLog);
dmc.WindowsEventLog.ScheduledTransferPeriod = TimeSpan.FromHours(1);
}
countDataSources = dmc.PerformanceCounters.DataSources.Count(item => item.CounterSpecifier == performanceCounter);
if (countDataSources == 0)
{
PerformanceCounterConfiguration perfCounterConfiguration = new PerformanceCounterConfiguration()
{
CounterSpecifier = performanceCounter,
SampleRate = System.TimeSpan.FromHours(1)
};
dmc.PerformanceCounters.DataSources.Add(perfCounterConfiguration);
}
IDictionary<DataBufferName, OnDemandTransferInfo> activeTransfers = ridm.GetActiveTransfers();
if (activeTransfers.Count == 0)
{
ridm.SetCurrentConfiguration(dmc);
}
}
public override bool OnStart()
{
Trace.WriteLine("OrleansAzureWeb-OnStart");
// For information on handling configuration changes see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
#region Setup CloudStorageAccount Configuration Setting Publisher
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
CloudStorageAccount.SetConfigurationSettingPublisher(
(string configName, Func <string, bool> configSetter) =>
{
// Provide the configSetter with the initial value
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (sender, arg) =>
{
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
// The corresponding configuration setting has changed, propagate the value
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
// In this case, the change to the storage account credentials in the
// service configuration is significant enough that the role needs to be
// recycled in order to use the latest settings. (for example, the
// endpoint has changed)
RoleEnvironment.RequestRecycle();
}
}
};
});
#endregion
// DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString");
// System.Diagnostics.Trace.Listeners.Add(new Microsoft.WindowsAzure.Diagnostics.DiagnosticMonitorTraceListener());
// System.Diagnostics.Trace.Listeners.Add(new Microsoft.
//WindowsAzure.Diagnostics.DiagnosticMonitorTraceListener());
// System.Diagnostics.Trace.AutoFlush = true;
// System.Diagnostics.Trace.TraceInformation("Information");
DiagnosticMonitorConfiguration diagConfig = DiagnosticMonitor.GetDefaultInitialConfiguration();
var perfCounters = new List <string>
{
@"\Processor(_Total)\% Processor Time",
@"\Memory\Available Mbytes",
@"\TCPv4\Connections Established",
@"\ASP.NET Applications(__Total__)\Requests/Sec",
@"\Network Interface(*)\Bytes Received/sec",
@"\Network Interface(*)\Bytes Sent/sec"
};
// Add perf counters to configuration
foreach (var counter in perfCounters)
{
var counterConfig = new PerformanceCounterConfiguration
{
CounterSpecifier = counter,
SampleRate = TimeSpan.FromSeconds(5)
};
diagConfig.PerformanceCounters.DataSources.Add(counterConfig);
}
diagConfig.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(1.0);
//Windows Event Logs
diagConfig.WindowsEventLog.DataSources.Add("System!*");
diagConfig.WindowsEventLog.DataSources.Add("Application!*");
diagConfig.WindowsEventLog.ScheduledTransferPeriod = TimeSpan.FromMinutes(1.0);
diagConfig.WindowsEventLog.ScheduledTransferLogLevelFilter = LogLevel.Warning;
//Azure Trace Logs
diagConfig.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1.0);
diagConfig.Logs.ScheduledTransferLogLevelFilter = LogLevel.Warning;
//Crash Dumps
CrashDumps.EnableCollection(true);
//IIS Logs
diagConfig.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(1.0);
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diagConfig);
bool ok = base.OnStart();
Trace.WriteLine("OrleansAzureWeb-OnStart completed with OK=" + ok);
return(ok);
}
static void Main(string[] args)
{
string configXmlDir = Environment.CurrentDirectory;
if (args.Length == 1)
{
configXmlDir = args[0];
}
string configXmlPath = Path.Combine(configXmlDir, "DiagnosticsConfiguration.xml");
if (!File.Exists(configXmlPath))
{
throw new InvalidOperationException(string.Format("Unable to find diagnostics configuration xml @ {0}", configXmlPath));
}
XmlSerializer serializer = new XmlSerializer(typeof(DiagnosticsConfig));
DiagnosticsConfig diagConfig = null;
using (Stream fs = File.OpenRead(configXmlPath))
{
diagConfig = serializer.Deserialize(fs) as DiagnosticsConfig;
}
DiagnosticMonitorConfiguration config = DiagnosticMonitor.GetDefaultInitialConfiguration();
config.OverallQuotaInMB = diagConfig.OverallQuotaInMB;
if (diagConfig.Directories.Directory != null)
{
foreach (DiagnosticsConfigDirectoriesDirectory dir in diagConfig.Directories.Directory)
{
DirectoryConfiguration directoryConfig = new DirectoryConfiguration();
directoryConfig.Container = dir.ContainerName;
if (dir.IsLocalPathRelative)
{
directoryConfig.Path = Path.Combine(Environment.CurrentDirectory, dir.LocalPath);
}
else
{
directoryConfig.Path = dir.LocalPath;
}
directoryConfig.DirectoryQuotaInMB = dir.DirectoryQuotaInMB;
config.Directories.DataSources.Add(directoryConfig);
}
config.Directories.ScheduledTransferPeriod = TimeSpan.FromSeconds(diagConfig.Directories.ScheduledTransferPeriodInSeconds);
}
if (diagConfig.PerformanceCounters.PerformanceCounter != null)
{
foreach (DiagnosticsConfigPerformanceCountersPerformanceCounter perf in diagConfig.PerformanceCounters.PerformanceCounter)
{
PerformanceCounterConfiguration perfConfig = new PerformanceCounterConfiguration();
perfConfig.CounterSpecifier = perf.CounterName;
perfConfig.SampleRate = TimeSpan.FromSeconds(perf.SamplingRateInSeconds);
config.PerformanceCounters.DataSources.Add(perfConfig);
}
config.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromSeconds(diagConfig.PerformanceCounters.ScheduledTransferPeriodInSeconds);
}
DiagnosticMonitor.Start(CloudStorageAccount.Parse(diagConfig.StorageAccountConnectionString), config);
Trace.WriteLine("ConfigureAzureDiagnostics Started.", "Information");
Console.ReadLine();
}
public override bool OnStart()
{
ServicePointManager.DefaultConnectionLimit = 100;
DiagnosticMonitorConfiguration diagConfig = DiagnosticMonitor.GetDefaultInitialConfiguration();
/* diagConfig.Directories.ScheduledTransferPeriod = TimeSpan.FromSeconds(15);
diagConfig.Logs.ScheduledTransferPeriod = TimeSpan.FromSeconds(15);
*/
PerformanceCounterConfiguration pccCPU = new PerformanceCounterConfiguration();
pccCPU.CounterSpecifier = @"\Processor(_Total)\% Processor Time";
pccCPU.SampleRate = TimeSpan.FromSeconds(5);
diagConfig.PerformanceCounters.DataSources.Add(pccCPU);
PerformanceCounterConfiguration pccMemory = new PerformanceCounterConfiguration();
pccMemory.CounterSpecifier = @"\Memory\Available Mbytes";
pccMemory.SampleRate = TimeSpan.FromSeconds(5);
diagConfig.PerformanceCounters.DataSources.Add(pccMemory);
PerformanceCounterConfiguration pccTcpFail = new PerformanceCounterConfiguration();
pccTcpFail.CounterSpecifier = @"\TCPv4\Connection Failures";
pccTcpFail.SampleRate = TimeSpan.FromSeconds(5);
diagConfig.PerformanceCounters.DataSources.Add(pccTcpFail);
diagConfig.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromSeconds(15);
//diagConfig.WindowsEventLog.DataSources.Add("System!*");
DiagnosticMonitor.Start("DiagnosticsConnectionString", diagConfig);
System.Diagnostics.Trace.TraceInformation("OnStart Complete");
/*
String myRoleInstanceName = RoleEnvironment.CurrentRoleInstance.Id;
System.Diagnostics.Trace.TraceInformation("TraceInformation:" + myRoleInstanceName);
CrashDumps.EnableCollection(true);
CrashDumps.EnableCollection(false);
*/
RoleEnvironment.Changing += RoleEnvironmentChanging;
if (_server == null)
_server = _server = new FtpServer(new AzureFileSystemFactory());
_server.NewConnection += ServerNewConnection;
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (sender, arg) =>
{
if (arg.Changes.OfType<RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
RoleEnvironment.RequestRecycle();
}
}
};
});
return base.OnStart();
}
private static void ConfigureDiagnosticMonitor()
{
var storageAccount = CloudStorageAccount.FromConfigurationSetting(wadConnectionString);
var roleInstanceDiagnosticManager = storageAccount.CreateRoleInstanceDiagnosticManager(RoleEnvironment.DeploymentId, RoleEnvironment.CurrentRoleInstance.Role.Name, RoleEnvironment.CurrentRoleInstance.Id);
var diagnosticMonitorConfiguration = roleInstanceDiagnosticManager.GetCurrentConfiguration();
// Performance Counters
ConfiguredCounters.ToList().ForEach(
counter =>
{
var counterConfiguration = new PerformanceCounterConfiguration
{
CounterSpecifier = counter,
SampleRate = TimeSpan.FromSeconds(30)
};
diagnosticMonitorConfiguration.PerformanceCounters.DataSources.Add(counterConfiguration);
});
diagnosticMonitorConfiguration.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
roleInstanceDiagnosticManager.SetCurrentConfiguration(diagnosticMonitorConfiguration);
}
private static void AddPerfCounter(DiagnosticMonitorConfiguration config, string name, double seconds)
{
var perfmon = new PerformanceCounterConfiguration();
perfmon.CounterSpecifier = name;
perfmon.SampleRate = System.TimeSpan.FromSeconds(seconds);
config.PerformanceCounters.DataSources.Add(perfmon);
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
//Get the default initial configuration for Windows Azure Diagnostics
DiagnosticMonitorConfiguration diagnosticMonitorConfiguration = DiagnosticMonitor.GetDefaultInitialConfiguration();
//Specify the scheduled transfer
diagnosticMonitorConfiguration.WindowsEventLog.ScheduledTransferPeriod = System.TimeSpan.FromMinutes(1.0);
diagnosticMonitorConfiguration.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(5.0);
diagnosticMonitorConfiguration.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1.0);
diagnosticMonitorConfiguration.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
diagnosticMonitorConfiguration.WindowsEventLog.ScheduledTransferPeriod = TimeSpan.FromMinutes(5.0);
diagnosticMonitorConfiguration.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(1.0);
diagnosticMonitorConfiguration.WindowsEventLog.DataSources.Add("Application!*");
diagnosticMonitorConfiguration.WindowsEventLog.DataSources.Add("System!*");
PerformanceCounterConfiguration performanceCounterConfiguration = new PerformanceCounterConfiguration();
performanceCounterConfiguration.CounterSpecifier = @"\Processor(*)\% Processor Time";
performanceCounterConfiguration.SampleRate = System.TimeSpan.FromSeconds(1.0);
diagnosticMonitorConfiguration.PerformanceCounters.DataSources.Add(performanceCounterConfiguration);
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diagnosticMonitorConfiguration);
// Config Change Handling
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (sender, arg) =>
{
if (arg.Changes.OfType<RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
RoleEnvironment.RequestRecycle();
}
}
};
});
// create storage account
storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
applicationName = RoleEnvironment.GetConfigurationSettingValue("ApplicationName");
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
return base.OnStart();
}
public override bool OnStart()
{
DiagnosticMonitorConfiguration diagConfig = DiagnosticMonitor.GetDefaultInitialConfiguration();
var perfCounters = new List <string>
{
@"\Processor(_Total)\% Processor Time",
@"\Memory\Available Mbytes",
@"\TCPv4\Connections Established",
@"\ASP.NET Applications(__Total__)\Requests/Sec",
@"\Network Interface(*)\Bytes Received/sec",
@"\Network Interface(*)\Bytes Sent/sec"
};
// Add perf counters to configuration
foreach (var counter in perfCounters)
{
var counterConfig = new PerformanceCounterConfiguration
{
CounterSpecifier = counter,
SampleRate = TimeSpan.FromSeconds(1.0)
};
diagConfig.PerformanceCounters.DataSources.Add(counterConfig);
}
diagConfig.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromSeconds(20.0);
//Windows Event Logs
diagConfig.WindowsEventLog.DataSources.Add("System!*");
diagConfig.WindowsEventLog.DataSources.Add("Application!*");
diagConfig.WindowsEventLog.ScheduledTransferPeriod = TimeSpan.FromMinutes(1.0);
diagConfig.WindowsEventLog.ScheduledTransferLogLevelFilter = LogLevel.Warning;
//Azure Trace Logs
diagConfig.Logs.ScheduledTransferPeriod = TimeSpan.FromSeconds(20.0);
diagConfig.Logs.ScheduledTransferLogLevelFilter = LogLevel.Warning;
diagConfig.Logs.ScheduledTransferLogLevelFilter = LogLevel.Information;
// diagConfig.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
diagConfig.Logs.ScheduledTransferLogLevelFilter = LogLevel.Error;
//Crash Dumps
CrashDumps.EnableCollection(true);
//IIS Logs
diagConfig.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(1.0);
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diagConfig);
Trace.TraceInformation(RoleEnvironment.Roles.Count.ToString());
Trace.TraceInformation("Instance {0} started.", RoleEnvironment.CurrentRoleInstance.Id);
RoleEnvironment.Changing += new EventHandler <RoleEnvironmentChangingEventArgs>(RoleEnvironment_Changing);
// CloudStorageAccount account = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString"));
// account.
// RoleEnvironment.GetConfigurationSettingValue("CacheServiceRole");
RoleEnvironment.Changed += new EventHandler <RoleEnvironmentChangedEventArgs>(RoleEnvironment_Changed);
//if (RoleEnvironment.IsEmulated)
//{
// var traceSource = CreateTraceSource();
// traceSource.TraceInformation("Instance {0} started.", RoleEnvironment.CurrentRoleInstance.Id);
//}
return(base.OnStart());
//// To enable the AzureLocalStorageTraceListner, uncomment relevent section in the web.config
//DiagnosticMonitorConfiguration diagnosticConfig = DiagnosticMonitor.GetDefaultInitialConfiguration();
//diagnosticConfig.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
//diagnosticConfig.Directories.DataSources.Add(AzureLocalStorageTraceListener.GetLogDirectory());
//// For information on handling configuration changes
//// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
//return base.OnStart();
}
