/// <summary>
/// Performs initial configurarion for Windows Azure Diagnostics for the instance.
/// </summary>
private void ConfigureDiagnosticMonitor()
{
DiagnosticMonitorConfiguration diagnosticMonitorConfiguration = DiagnosticMonitor.GetDefaultInitialConfiguration();
diagnosticMonitorConfiguration.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
diagnosticMonitorConfiguration.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1d);
diagnosticMonitorConfiguration.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(1d);
diagnosticMonitorConfiguration.Directories.BufferQuotaInMB = 100;
diagnosticMonitorConfiguration.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1d);
diagnosticMonitorConfiguration.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
diagnosticMonitorConfiguration.WindowsEventLog.DataSources.Add("Application!*");
diagnosticMonitorConfiguration.WindowsEventLog.DataSources.Add("System!*");
diagnosticMonitorConfiguration.WindowsEventLog.ScheduledTransferPeriod = TimeSpan.FromMinutes(1d);
//PerformanceCounterConfiguration performanceCounterConfiguration = new PerformanceCounterConfiguration();
//performanceCounterConfiguration.CounterSpecifier = @"\Processor(_Total)\% Processor Time";
//performanceCounterConfiguration.SampleRate = System.TimeSpan.FromSeconds(10d);
//diagnosticMonitorConfiguration.PerformanceCounters.DataSources.Add(performanceCounterConfiguration);
//PerformanceCounterConfiguration performanceCounterConfigurationMem = new PerformanceCounterConfiguration();
//performanceCounterConfigurationMem.CounterSpecifier = @"\Memory\% Committed Bytes In Use";
//performanceCounterConfigurationMem.SampleRate = System.TimeSpan.FromSeconds(60d);
//diagnosticMonitorConfiguration.PerformanceCounters.DataSources.Add(performanceCounterConfigurationMem);
//diagnosticMonitorConfiguration.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(1d);
DiagnosticMonitor.Start(WadConnectionString, diagnosticMonitorConfiguration);
}
private static IAzureStorageConfig CreateCloudStorageConfig()
{
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString");
CloudStorageAccount.SetConfigurationSettingPublisher(
(configName, configSetter) => configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)));
return(AzureStorage.CreateConfig(CloudStorageAccount.FromConfigurationSetting("StorageConnectionString")));
}
public override bool OnStart()
{
DiagnosticMonitorConfiguration dmc = DiagnosticMonitor.GetDefaultInitialConfiguration();
dmc.Logs.ScheduledTransferPeriod = TimeSpan.FromSeconds(1);
dmc.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", dmc);
return(base.OnStart());
//// For information on handling configuration changes
//// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
//System.Diagnostics.Trace.WriteLine("Entering OnStart in WebRole...");
//var traceResource = RoleEnvironment.GetLocalResource("TraceFiles");
//var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
//config.Directories.DataSources.Add(
// new DirectoryConfiguration
// {
// Path = traceResource.RootPath,
// Container = "traces",
// DirectoryQuotaInMB = 100
// });
//config.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
//DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", config);
//return true;
//return base.OnStart();
}
public override bool OnStart()
{
RoleEnvironment.Changing += RoleEnvironmentChanging;
DiagnosticMonitorConfiguration dmc = DiagnosticMonitor.GetDefaultInitialConfiguration();
dmc.Logs.ScheduledTransferPeriod = TimeSpan.FromSeconds(10);
dmc.Logs.ScheduledTransferLogLevelFilter = LogLevel.Undefined;
DiagnosticMonitor.Start("DiagnosticsConnectionString", dmc);
Log.Info("Worker Role OnStart Entered");
try
{
_endPoint = RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["Raven"].IPEndpoint;
MountCloudDrive();
StartTheServer();
Log.Info("Worker Role OnStart Exited");
}
catch (Exception ex)
{
Log.Error("Worker Role OnStart error: " + ex.Message);
}
return(base.OnStart());
}
public override bool OnStart()
{
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString");
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += this.RoleEnvironmentChanging;
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
CloudStorageAccount.SetConfigurationSettingPublisher((configName, 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();
}
}
};
});
return(base.OnStart());
}
public override bool OnStart()
{
DiagnosticMonitor.Start("DiagnosticsConnectionString");
#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((configName, 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
return(base.OnStart());
}
/// <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);
}
private void ConfigureAzureDiagnostics()
{
if (!RoleEnvironment.IsAvailable)
{
return;
}
Trace.Listeners.Add(new DiagnosticMonitorTraceListener());
if (!InitializeDiagnostics)
{
return;
}
var cloudStorageAccount = CloudStorageAccount.Parse(GetConnectionString());
var roleInstanceDiagnosticManager = cloudStorageAccount.CreateRoleInstanceDiagnosticManager(
RoleEnvironment.DeploymentId,
RoleEnvironment.CurrentRoleInstance.Role.Name,
RoleEnvironment.CurrentRoleInstance.Id);
var configuration = roleInstanceDiagnosticManager.GetCurrentConfiguration();
if (configuration == null) // to remain backward compatible with sdk 1.2
{
configuration = DiagnosticMonitor.GetDefaultInitialConfiguration();
ConfigureDiagnostics(configuration);
DiagnosticMonitor.Start(cloudStorageAccount, configuration);
}
}
public override bool OnStart()
{
DiagnosticMonitor.Start("DiagnosticsConnectionString");
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
Microsoft.WindowsAzure.CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
string configuration = RoleEnvironment.IsAvailable ?
RoleEnvironment.GetConfigurationSettingValue(configName) :
ConfigurationManager.AppSettings[configName];
configSetter(configuration);
});
StorageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
CloudTableClient.CreateTablesFromModel(
typeof(DataContext),
StorageAccount.TableEndpoint.AbsoluteUri,
StorageAccount.Credentials);
return(base.OnStart());
}
/// <summary>
/// Setup counters for diagnostic monitor
/// </summary>
private void SetupCounters()
{
DiagnosticMonitorConfiguration diagnosticMonitorConfiguration = DiagnosticMonitor.GetDefaultInitialConfiguration();
TraceConfig(diagnosticMonitorConfiguration);
diagnosticMonitorConfiguration.PerformanceCounters.BufferQuotaInMB = 5;
diagnosticMonitorConfiguration.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
// Use 30 seconds for the perf counter sample rate.
TimeSpan perfSampleRate = TimeSpan.FromSeconds(30D);
diagnosticMonitorConfiguration.PerformanceCounters.DataSources.Add(new PerformanceCounterConfiguration()
{
CounterSpecifier = @"\Memory\Available Bytes",
SampleRate = perfSampleRate
});
diagnosticMonitorConfiguration.PerformanceCounters.DataSources.Add(new PerformanceCounterConfiguration()
{
CounterSpecifier = @"\Processor(_Total)\% Processor Time",
SampleRate = perfSampleRate
});
// Apply the updated configuration to the diagnostic monitor.
// The first parameter is for the connection string configuration setting.
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diagnosticMonitorConfiguration);
}
public override bool OnStart()
{
DiagnosticMonitorConfiguration config = DiagnosticMonitor.GetDefaultInitialConfiguration();
config.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
config.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
config.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = LogLevel.Error;
DiagnosticMonitor.Start("DiagnosticsConnectionString", config);
RoleEnvironment.Changing += RoleEnvironmentChanging;
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (anotherSender, arg) =>
{
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
RoleEnvironment.RequestRecycle();
}
}
};
});
ChirpManager.Initialize();
AvatarManager.Initialize();
ResizeRequestManager.Initialize();
return(base.OnStart());
}
public override bool 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.
var startInfo = new ProcessStartInfo()
{
FileName = "powershell.exe",
Arguments = @"..\Startup\RoleStart.ps1",
RedirectStandardOutput = true,
UseShellExecute = false
};
var writer = new StreamWriter("out.txt");
var process = Process.Start(startInfo);
process.WaitForExit();
writer.Write(process.StandardOutput.ReadToEnd());
writer.Close();
return(base.OnStart());
}
/// <summary>
/// Override the OnStart handler to add our event handlers for RoleEnvironment changes and
/// to initialize the PerformanceCounters as part of the Diagnostic Monitor configuration.
/// </summary>
/// <returns>Returns true if initialization succeeds, otherwise false.</returns>
public override bool OnStart()
{
// Setup to handle service configuration changes at runtime.
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += this.RoleEnvironmentChanging;
RoleEnvironment.Changed += this.RoleEnvironmentChanged;
var diagnosticMonitorConfiguration = DiagnosticMonitor.GetDefaultInitialConfiguration();
// Transfer diagnostic information once every minute.
TimeSpan transferPeriod = TimeSpan.FromMinutes(1d);
diagnosticMonitorConfiguration.PerformanceCounters.ScheduledTransferPeriod = transferPeriod;
// Set the diagnostic monitor configuration.
DiagnosticMonitor.Start(WADConnectionString, diagnosticMonitorConfiguration);
// Initialize the custom performance counters.
InitializeCustomPerformanceCounters();
// Add the performance counter settings from the ServiceConfiguration.cscfg file.
ConfigureDiagnostics();
return(base.OnStart());
}
public override bool OnStart()
{
// Configure diagnostics
// From: http://www.packtpub.com/article/digging-into-windows-azure-diagnostics-tutotial (sic),
// need to add a diagnostics trace listener; (web.config is just for website tracing)
Trace.Listeners.Add(new DiagnosticMonitorTraceListener());
Trace.AutoFlush = true;
Trace.TraceInformation("Error");
// Set up to transfer to blob storage
DiagnosticMonitorConfiguration diagnosticConfiguration = DiagnosticMonitor.GetDefaultInitialConfiguration();
diagnosticConfiguration.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(10);
// don't need; if not specificed, will use overall quota (which is 4 GB) diagnosticConfiguration.Logs.BufferQuotaInMB = 10;
// Add the startup task logs directory, so the startup logs will get transferred to storage
var dirConfig = new DirectoryConfiguration();
dirConfig.Container = "wad-startuplogs-container";
dirConfig.Path = Path.Combine((new DirectoryInfo(".")).FullName, "startuplogs");
Trace.TraceInformation("not sure why files not getting picked up: dirConfig = " + dirConfig.Path);
diagnosticConfiguration.Directories.DataSources.Add(dirConfig);
diagnosticConfiguration.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(10);
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diagnosticConfiguration);
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
return(base.OnStart());
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
TimeSpan tsMin = TimeSpan.FromMinutes(1);
DiagnosticMonitorConfiguration dmc = DiagnosticMonitor.GetDefaultInitialConfiguration();
// Transfer logs to storage every minute
dmc.Logs.ScheduledTransferPeriod = tsMin;
// Transfer verbose, critical, etc. logs
dmc.Logs.ScheduledTransferLogLevelFilter = LogLevel.Undefined;
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", dmc);
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
CloudStorageAccount.SetConfigurationSettingPublisher(
(a, b) => b(RoleEnvironment.GetConfigurationSettingValue(a)));
return(base.OnStart());
}
public override bool OnStart()
{
DiagnosticMonitor.Start("DiagnosticsConnectionString");
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
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());
}
public override bool OnStart()
{
Trace.WriteLine("OrleansAzureSilos-OnStart called", "Information");
Trace.WriteLine("OrleansAzureSilos-OnStart Initializing config", "Information");
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
// For information on handling configuration changes see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
Trace.WriteLine("OrleansAzureSilos-OnStart Initializing diagnostics", "Information");
DiagnosticMonitorConfiguration diagConfig = ConfigureDiagnostics();
// Start the diagnostic monitor.
// The parameter references a connection string specified in the service configuration file
// that indicates the storage account where diagnostic information will be transferred.
// If the value of this setting is "UseDevelopmentStorage=true" then logs are written to development storage.
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diagConfig);
Trace.WriteLine("OrleansAzureSilos-OnStart Starting Orleans silo", "Information");
orleansAzureSilo = new OrleansAzureSilo();
bool ok = base.OnStart();
if (ok)
{
ok = orleansAzureSilo.Start(RoleEnvironment.DeploymentId, RoleEnvironment.CurrentRoleInstance);
}
Trace.WriteLine("OrleansAzureSilos-OnStart Orleans silo started ok=" + ok, "Information");
return(ok);
}
public override bool OnStart()
{
ServicePointManager.DefaultConnectionLimit = 12;
TimeSpan timeToTransfer;
//// IIS Log.
timeToTransfer = TimeSpan.FromMinutes(5);
//// LocalResource localResource = RoleEnvironment.GetLocalResource("IISLogs");
//// DirectoryConfiguration dirConfig = new DirectoryConfiguration();
//// dirConfig.Container = "wad-iis-logcontainer";
//// dirConfig.DirectoryQuotaInMB = localResource.MaximumSizeInMegabytes;
//// dirConfig.Path = localResource.RootPath;
DiagnosticMonitorConfiguration diagMonitorConfig = DiagnosticMonitor.GetDefaultInitialConfiguration();
//// diagMonitorConfig.Directories.ScheduledTransferPeriod = timeToTransfer;
//// diagMonitorConfig.OverallQuotaInMB = 4080;
//// diagMonitorConfig.Directories.DataSources.Add(dirConfig);
//// Logging diagnostic information to WADLog storage table.
timeToTransfer = TimeSpan.FromMinutes(5);
diagMonitorConfig.Logs.ScheduledTransferPeriod = timeToTransfer;
diagMonitorConfig.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
//// Start diagnostic monitor.
DiagnosticMonitor diagMonitor = DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diagMonitorConfig);
return(base.OnStart());
}
public override bool OnStart()
{
DiagnosticMonitor.Start("DiagnosticsConnectionString");
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
// Provide the configSetter with the initial value
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (anotherSender, 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();
}
}
};
});
var account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
// Create the table and add some dummy data.
CloudTableClient tableClient = new CloudTableClient(account.TableEndpoint.AbsoluteUri, account.Credentials);
tableClient.CreateTableIfNotExist("Person");
PersonTableStorageContext ctx = new PersonTableStorageContext();
Person person1 = new Person("DefaultPartition", "Row1")
{
Name = "Ared", Age = 24
};
Person person2 = new Person("DefaultPartition", "Row2")
{
Name = "Lante", Age = 24
};
Person person3 = new Person("DefaultPartition", "Row3")
{
Name = "Bright", Age = 24
};
this.InsertEntityIfNotExist(ctx, person1);
this.InsertEntityIfNotExist(ctx, person2);
this.InsertEntityIfNotExist(ctx, person3);
return(base.OnStart());
}
private static void StartDiagnosticMonitor()
{
var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
config.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(AzureConstants.LogsConfiguration.ScheduledTransferMinutes);
ConfigureTraceListener(RoleEnvironment.GetConfigurationSettingValue("TraceEventTypeFilter"));
DiagnosticMonitor.Start(AzureConstants.LogsConfiguration.DefaultStorageConfigSetting, config);
}
public override bool OnStart()
{
ServicePointManager.DefaultConnectionLimit = 12;
DiagnosticMonitor.Start(AzureConnectionStrings.Diagnostics);
RoleEnvironment.Changing += RoleEnvironmentChanging;
ApplicationStorageInitializer.Initialize();
return(base.OnStart());
}
private static void StartDiagnosticMonitor()
{
var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
config.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(AzureConstants.LogsConfiguration.ScheduledTransferMinutes);
ConfigureTraceListener(RoleEnvironment.GetConfigurationSettingValue("TraceEventTypeFilter"));
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", config);
}
public override bool OnStart()
{
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString");
RoleEnvironment.Changing += RoleEnvironmentChanging;
GlobalSetup.InitIfNeeded();
return(base.OnStart());
}
void ConfigureDiagnostics()
{
var everySecond = 1.Seconds();
var dmc = DiagnosticMonitor.GetDefaultInitialConfiguration();
dmc.Logs.ScheduledTransferPeriod = everySecond;
dmc.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", dmc);
}
public override bool OnStart()
{
DiagnosticMonitor.Start("DiagnosticsConnectionString");
// 关于处理配置的变化请查看MSDN http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
return(base.OnStart());
}
private static void InitializeDiagnostics()
{
DiagnosticMonitorConfiguration diagMonitorConfig = DiagnosticMonitor.GetDefaultInitialConfiguration();
LocalResource localResource = CreateLocalResource(diagMonitorConfig);
diagMonitorConfig.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1.0);
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diagMonitorConfig);
WebRoleErrorLoggingFilePath = Path.Combine(localResource.RootPath, "WorkerRoleErrors.log");
Trace.Listeners.Add(new DiagnosticMonitorTraceListener());
}
public override bool OnStart()
{
DiagnosticMonitor.Start("DiagnosticsConnectionString");
// 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()
{
// 启动AzureLocalStorageTraceListner, 在web.config取消相关节点
DiagnosticMonitorConfiguration diagnosticConfig = DiagnosticMonitor.GetDefaultInitialConfiguration();
diagnosticConfig.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
diagnosticConfig.Directories.DataSources.Add(AzureLocalStorageTraceListener.GetLogDirectory());
return(base.OnStart());
}
private void SetupDiagnostics()
{
Trace.WriteLine("Setting up diagnostics", "Information");
DiagnosticMonitorConfiguration diagConfig = DiagnosticMonitor.GetDefaultInitialConfiguration();
// Add performance counter monitoring for configured counters
// Run typeperf.exe /q to query the counter list
string perfCounterString = RoleEnvironment.GetConfigurationSettingValue("PerformanceCounters");
if (!string.IsNullOrEmpty(perfCounterString))
{
IList <string> perfCounters = perfCounterString.Split(',').ToList();
// Setup each counter specified in comma delimitered string
foreach (string perfCounter in perfCounters)
{
diagConfig.PerformanceCounters.DataSources.Add(
new PerformanceCounterConfiguration
{
CounterSpecifier = perfCounter,
SampleRate = TimeSpan.FromSeconds(DefaultSampleRate)
}
);
}
// Update counter information in Azure every 30 seconds
diagConfig.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(0.5);
}
diagConfig.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = TimeSpan.FromMinutes(0.5);
// Specify a logging level to filter records to transfer
diagConfig.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
// Set scheduled transfer interval for user's Windows Azure Logs to 1 minute
diagConfig.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(5);
diagConfig.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(5);
Microsoft.WindowsAzure.Diagnostics.CrashDumps.EnableCollection(true);
//Event Logs
// Add event collection from the Windows Event Log
diagConfig.WindowsEventLog.DataSources.Add("System!*");
diagConfig.WindowsEventLog.DataSources.Add("Application!*");
diagConfig.WindowsEventLog.DataSources.Add("Security!*");
// Start the diagnostic monitor with this custom configuration
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diagConfig);
}
///// <summary>
///// configure the Role including the connection string
///// </summary>
private void ConfigureDiagnostics()
{
DiagnosticMonitorConfiguration config = DiagnosticMonitor.GetDefaultInitialConfiguration();
config.Logs.BufferQuotaInMB = 500;
config.Logs.ScheduledTransferLogLevelFilter = Microsoft.WindowsAzure.Diagnostics.LogLevel.Information;
config.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1d);
DiagnosticMonitor.Start(
"Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString",
config);
}
// Start Windows Azure Diagnostics Monitor
private void StartDiagnosticMonitor()
{
// Enable Diagnostics trace listener (needed for WCF service)
Trace.Listeners.Add(new DiagnosticMonitorTraceListener());
// Get Diagnostics and Performance Counter Capture Frequency (in minutes)
TimeSpan timeSpan = TimeSpan.FromMinutes(
Double.Parse(RoleEnvironment.GetConfigurationSettingValue("DiagnosticsAndPerformanceCounterCaptureFrequencyInMinutes")));
var cfg = DiagnosticMonitor.GetDefaultInitialConfiguration();
cfg.Logs.ScheduledTransferPeriod = timeSpan;
cfg.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
// Infrastructure logs
cfg.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = timeSpan;
cfg.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = LogLevel.Error;
cfg.DiagnosticInfrastructureLogs.BufferQuotaInMB = 10;
// Add event collection from the Windows Event Log
cfg.WindowsEventLog.DataSources.Add("System!*");
cfg.WindowsEventLog.ScheduledTransferPeriod = timeSpan;
cfg.WindowsEventLog.DataSources.Add("Application!*[System[Provider[@Name='HostableWebCore']]]");
// Add performance counter monitoring
cfg.PerformanceCounters.DataSources.Add(
new PerformanceCounterConfiguration()
{
CounterSpecifier = @"\Processor(_Total)\% Processor Time",
SampleRate = timeSpan
});
cfg.PerformanceCounters.DataSources.Add(
new PerformanceCounterConfiguration()
{
CounterSpecifier = @"\Memory\Available Mbytes",
SampleRate = timeSpan
});
cfg.PerformanceCounters.ScheduledTransferPeriod = timeSpan;
// Start Diagnostics
diagnosticMonitor = DiagnosticMonitor.Start(storageAccount, cfg);
}
