public override bool OnStart()
{
var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
var cloudStorageAccount =
CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString"));
TimeSpan transferPeriod;
if (!TimeSpan.TryParse(RoleEnvironment.GetConfigurationSettingValue("Diagnostics.ScheduledTransferPeriod"), out transferPeriod))
{
transferPeriod = TimeSpan.FromMinutes(1);
}
TimeSpan sampleRate;
if (!TimeSpan.TryParse(RoleEnvironment.GetConfigurationSettingValue("Diagnostics.PerformanceCounterSampleRate"), out sampleRate))
{
sampleRate = TimeSpan.FromSeconds(30);
}
LogLevel logLevel;
if (!Enum.TryParse <LogLevel>(RoleEnvironment.GetConfigurationSettingValue("Diagnostics.LogLevelFilter"), out logLevel))
{
logLevel = LogLevel.Verbose;
}
// Setup performance counters
config.PerformanceCounters.DataSources.Add(
new PerformanceCounterConfiguration
{
CounterSpecifier = @"\Processor(_Total)\% Processor Time",
SampleRate = sampleRate
});
config.PerformanceCounters.ScheduledTransferPeriod = transferPeriod;
// Setup logs
config.Logs.ScheduledTransferPeriod = transferPeriod;
config.Logs.ScheduledTransferLogLevelFilter = logLevel;
DiagnosticMonitor.Start(cloudStorageAccount.ToString(), config);
return(base.OnStart());
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
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) =>
{
configSetter(Microsoft.WindowsAzure.ServiceRuntime.RoleEnvironment.GetConfigurationSettingValue(configName));
});
return(base.OnStart());
}
public override bool OnStart()
{
// 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.
DiagnosticMonitorConfiguration dmc = DiagnosticMonitor.GetDefaultInitialConfiguration();
dmc.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
dmc.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", dmc);
return(base.OnStart());
}
public override bool OnStart()
{
DiagnosticMonitor.Start("DiagnosticsConnectionString");
// Restart the role upon all configuration changes
// Note: To customize the handling of configuration changes,
// remove this line and register custom event handlers instead.
// See the MSDN topic on “Managing Configuration Changes” for further details
// (http://go.microsoft.com/fwlink/?LinkId=166357).
RoleEnvironment.Changing += RoleEnvironmentChanging;
Microsoft.WindowsAzure.CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
});
return(base.OnStart());
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
// In Cloud, we are going to put all App log into Table WADLogsTable
if (!RoleEnvironment.IsEmulated)
{
var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
config.Logs.ScheduledTransferPeriod = System.TimeSpan.FromMinutes(1.0);
config.Logs.ScheduledTransferLogLevelFilter = LogLevel.Information;
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", config);
}
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
return(base.OnStart());
}
private void InitDiagnostics()
{
#if DEBUG
// Get the default initial configuration for DiagnosticMonitor.
DiagnosticMonitorConfiguration diagnosticConfiguration = DiagnosticMonitor.GetDefaultInitialConfiguration();
// Filter the logs so that only error-level logs are transferred to persistent storage.
diagnosticConfiguration.Logs.ScheduledTransferLogLevelFilter = LogLevel.Undefined;
// Schedule a transfer period of 30 minutes.
diagnosticConfiguration.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(2.0);
// Specify a buffer quota of 1GB.
diagnosticConfiguration.Logs.BufferQuotaInMB = 1024;
// Start the DiagnosticMonitor using the diagnosticConfig and our connection string.
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diagnosticConfiguration);
#endif
}
private void InitDiagnostics()
{
var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
int logLevelTransferTime = 0;
int.TryParse(RoleEnvironment.GetConfigurationSettingValue("LogLevelTransferTime"), out logLevelTransferTime);
if (logLevelTransferTime == 0)
{
logLevelTransferTime = 5;
}
config.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(logLevelTransferTime);
config.Logs.ScheduledTransferLogLevelFilter = LogLevel.Undefined;
// Start the diagnostic monitor with the modified configuration.
DiagnosticMonitor.Start("AzureStorageAccountConnectionString", config);
}
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) =>
{
configSetter(Microsoft.WindowsAzure.ServiceRuntime.RoleEnvironment.GetConfigurationSettingValue(configName));
});
CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
NumbersQueue = account.CreateCloudQueueClient().GetQueueReference("numbers");
return(base.OnStart());
}
public override bool OnStart()
{
//Set up CPU and memory monitoring
DiagnosticMonitorConfiguration config = DiagnosticMonitor.GetDefaultInitialConfiguration();
config.PerformanceCounters.DataSources.Add(new PerformanceCounterConfiguration()
{
SampleRate = TimeSpan.FromSeconds(5),
CounterSpecifier = @"\Processor(_Total)\% Processor Time"
});
config.PerformanceCounters.DataSources.Add(new PerformanceCounterConfiguration()
{
SampleRate = TimeSpan.FromSeconds(5),
CounterSpecifier = @"\Memory\Available MBytes"
});
config.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", config);
return(base.OnStart());
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
DiagnosticMonitor.Start("DiagnosticsConnectionString");
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
if (_server == null)
{
_server = _server = new FtpServer(new AzureFileSystemFactory());
}
_server.NewConnection += ServerNewConnection;
return(base.OnStart());
}
public override bool OnStart()
{
// This role is starting with a custom configuration for the purpose of the sample.
var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
// Adding performance counters to the default diagnostic configuration
config.PerformanceCounters.DataSources.Add(
new PerformanceCounterConfiguration()
{
CounterSpecifier = @"\Processor(_Total)\% Processor Time",
SampleRate = TimeSpan.FromSeconds(5)
});
config.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = LogLevel.Error;
config.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = TimeSpan.FromMinutes(5);
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", config);
return(base.OnStart());
}
public override bool OnStart()
{
var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
var cloudStorageAccount =
CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString"));
var transferPeriod = TimeSpan.FromMinutes(5);
var logLevel = LogLevel.Verbose;
config.Logs.ScheduledTransferPeriod = transferPeriod;
config.Logs.ScheduledTransferLogLevelFilter = logLevel;
DiagnosticMonitor.Start(cloudStorageAccount, config);
Trace.Listeners.Add(new Microsoft.WindowsAzure.Diagnostics.DiagnosticMonitorTraceListener());
Trace.AutoFlush = true;
return(base.OnStart());
}
public override bool OnStart( )
{
DiagnosticMonitor.Start("DiagnosticsConnectionString");
RoleEnvironment.Changing += new EventHandler <RoleEnvironmentChangingEventArgs>(RoleEnvironmentChanging);
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)));
CloudStorageAccount storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
container = storageAccount.CreateCloudBlobClient( ).GetContainerReference("fotogolpics");
queue = storageAccount.CreateCloudQueueClient( ).GetQueueReference("fotogolthumbs");
Trace.TraceInformation("Creating container and queue...");
bool storageInitialized = false;
while (!storageInitialized)
{
try
{
container.CreateIfNotExist( );
BlobContainerPermissions permissions = container.GetPermissions( );
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
container.SetPermissions(permissions);
queue.CreateIfNotExist( );
storageInitialized = true;
}
catch (StorageClientException e)
{
if (e.ErrorCode != StorageErrorCode.TransportError)
{
throw;
}
Trace.TraceError("Storage services initialization failure. Check your storage account configuration settings. If running locally, ensure that the Development Storage service is running. Message: '{0}'", new object[] { e.Message });
Thread.Sleep(5000);
}
}
return(base.OnStart( ));
}
public static void Configurar()
{
TimeSpan span = TimeSpan.FromMinutes(1);
Trace.WriteLine("Configurando diagnósticos.");
DiagnosticMonitorConfiguration config = DiagnosticMonitor.GetDefaultInitialConfiguration();
config.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = LogLevel.Information;
config.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = span;
config.Logs.ScheduledTransferLogLevelFilter = LogLevel.Information;
config.Logs.ScheduledTransferPeriod = span;
config.WindowsEventLog.DataSources.Add("System!*");
config.WindowsEventLog.DataSources.Add("Application!*");
config.WindowsEventLog.ScheduledTransferLogLevelFilter = LogLevel.Error;
config.WindowsEventLog.ScheduledTransferPeriod = span;
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", config);
}
/// <summary>
/// Initializes Master worker role instance.
/// </summary>
/// <returns>True if initialization succeeds, False if it fails.</returns>
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
// Initiaize azure diagnostics.
DiagnosticMonitorConfiguration config = DiagnosticMonitor.GetDefaultInitialConfiguration();
// The log level filtering is imposed at the trace source, so set it to the max
// level here.
config.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
config.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
EnablePerfCounterCollection(config);
DiagnosticMonitor.Start("DiagnosticsConnectionString", config);
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
return(base.OnStart());
}
static void SetupDiagnostics()
{
var cfg = DiagnosticMonitor.GetDefaultInitialConfiguration();
if (CollectPerfCounters)
{
AddPerformanceCounter(cfg, @"\Processor(_Total)\% Processor Time", TimeSpan.FromSeconds(5));
AddPerformanceCounter(cfg, @"\Memory\Available Mbytes", TimeSpan.FromSeconds(5));
}
if (CollectWindowsEventLogs)
{
AddEventSource(cfg, "System!*");
AddEventSource(cfg, "Application!*");
}
cfg.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = LogLevel.Information;
cfg.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = TimeSpan.FromMinutes(5);
CrashDumps.EnableCollection(FullCrashDumps);
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", cfg);
}
public override bool OnStart()
{
DiagnosticMonitor.Start(AzureConnectionStrings.Diagnostics);
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += (sender, e) =>
{
if (e.Changes.Any(change => change is RoleEnvironmentConfigurationSettingChange))
{
// Set e.Cancel to true to restart this role instance
e.Cancel = true;
}
};
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)));
ApplicationStorageInitializer.Initialize();
return(base.OnStart());
}
public override bool OnStart()
{
System.Diagnostics.Trace.Write("Role was started");
//Enabling Diagnostic Monitor
DiagnosticMonitorConfiguration config = DiagnosticMonitor.GetDefaultInitialConfiguration();
//config.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = LogLevel.Error;
//config.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = TimeSpan.FromMinutes(10);
//config.WindowsEventLog.DataSources.Add("Application!*");
//config.WindowsEventLog.ScheduledTransferPeriod = TimeSpan.FromMinutes(10);
DiagnosticMonitor.Start("DiagnosticsConnectionString", config);
//Enabling Crash Dumps
//Microsoft.WindowsAzure.Diagnostics.CrashDumps.EnableCollection(false);
// For information on handling configuration changes
RoleEnvironment.Changing += RoleEnvironmentChanging;
return(base.OnStart());
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
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 += (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());
}
// 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 void SetupDiagnostics()
{
// DiagnosticMonitorConfiguration : http://msdn.microsoft.com/en-us/library/ee773135.aspx
DiagnosticMonitorConfiguration diagConfig = DiagnosticMonitor.GetDefaultInitialConfiguration();
// Windows event logs
diagConfig.WindowsEventLog.DataSources.Add("System!*");
diagConfig.WindowsEventLog.DataSources.Add("Application!*");
diagConfig.WindowsEventLog.ScheduledTransferLogLevelFilter = LogLevel.Information;
diagConfig.WindowsEventLog.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
// Azure application logs
diagConfig.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
diagConfig.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
// Performance counters
diagConfig.PerformanceCounters.DataSources.Add(
new PerformanceCounterConfiguration()
{
CounterSpecifier = @"\Processor(_Total)\% Processor Time",
SampleRate = TimeSpan.FromMinutes(1)
});
diagConfig.PerformanceCounters.DataSources.Add(
new PerformanceCounterConfiguration()
{
CounterSpecifier = @"\Memory\Available Mbytes",
SampleRate = TimeSpan.FromMinutes(1)
});
diagConfig.PerformanceCounters.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diagConfig);
// use Azure configuration as setting publisher
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
});
}
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);
}
else
{
ConfigureDiagnostics(configuration);
roleInstanceDiagnosticManager.SetCurrentConfiguration(configuration);
}
}
private void StartDiagnosticMonitor()
{
if (CloudEnvironment.IsAvailable)
{
using (CloudEnvironment.EnsureSafeHttpContext())
{
var storageAccount = ConfigurationManager.AppSettings[CommonConsts.ConfigSettingStorageAccount];
var storageKey = ConfigurationManager.AppSettings[CommonConsts.ConfigSettingStorageAccountKey];
var diagnosticConfig = DiagnosticMonitor.GetDefaultInitialConfiguration();
var diagnosticStorage = new CloudStorageAccount(new StorageCredentialsAccountAndKey(storageAccount, storageKey), true);
// Configure the scheduled transfer period for all logs.
diagnosticConfig.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
diagnosticConfig.Logs.ScheduledTransferPeriod = TimeSpan.FromSeconds(10);
// Configure the logs levels for scheduled transfers.
diagnosticConfig.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = LogLevel.Error;
diagnosticConfig.Logs.ScheduledTransferLogLevelFilter = LogLevel.Undefined;
this.diagnosticMonitor = DiagnosticMonitor.Start(diagnosticStorage, diagnosticConfig);
}
}
}
private void ConfigureAzureDiagnostics(string logDir)
{
var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
config.ConfigurationChangePollInterval = TimeSpan.FromMinutes(5);
config.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = Microsoft.WindowsAzure.Diagnostics.LogLevel.Verbose;
config.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
config.DiagnosticInfrastructureLogs.BufferQuotaInMB = 100;
var dumps = config.Directories.DataSources.Single(dir => String.Equals(dir.Container, "wad-crash-dumps"));
config.Directories.BufferQuotaInMB = 2048;
config.Directories.DataSources.Clear();
config.Directories.DataSources.Add(dumps);
config.Directories.DataSources.Add(new DirectoryConfiguration()
{
Container = "wad-joblogs",
Path = Path.Combine(logDir, "Jobs"),
DirectoryQuotaInMB = 100
});
config.Directories.DataSources.Add(new DirectoryConfiguration()
{
Container = "wad-hostlogs",
Path = Path.Combine(logDir, "Host"),
DirectoryQuotaInMB = 100
});
config.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
config.WindowsEventLog.DataSources.Add("Application");
config.WindowsEventLog.BufferQuotaInMB = 100;
_logger.Info("Enabling Azure Diagnostics");
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", config);
_logger.Info("Enabled Azure Diagnostics");
}
private void ConfigureAzureDiagnostics()
{
var traceListener = new DiagnosticMonitorTraceListener();
Trace.Listeners.Add(traceListener);
var dmc = DiagnosticMonitor.GetDefaultInitialConfiguration();
//set threshold to verbose, what gets logged is controled by the log4net level
dmc.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
TimeSpan transferPeriod = TimeSpan.FromMinutes(this.ScheduledTransferPeriod);
dmc.Logs.ScheduledTransferPeriod = transferPeriod;
dmc.WindowsEventLog.ScheduledTransferPeriod = transferPeriod;
// (;) delimited list of event logs
foreach (string log in this.EventLogs.Split(';'))
{
dmc.WindowsEventLog.DataSources.Add(log);
}
DiagnosticMonitor.Start(KeyConnectionString, dmc);
}
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;
SetupEnvironmentChangeHandlers();
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()
{
DiagnosticMonitorConfiguration dmc = DiagnosticMonitor.GetDefaultInitialConfiguration();
dmc.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
dmc.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", dmc);
foreach (var rie in RoleEnvironment.CurrentRoleInstance.InstanceEndpoints)
{
var endpoint = rie.Value;
if (endpoint.Protocol == "http")
{
string baseUri = string.Format("{0}://{1}",
endpoint.Protocol, endpoint.IPEndpoint);
Trace.TraceInformation(String.Format("Starting OWIN at {0}", baseUri));
Proxy.Start(baseUri);
}
}
return(base.OnStart());
}
public override bool OnStart()
{
RoleEnvironment.Changing += (sender, e) => {
if (e.Changes
.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any(x => x.ConfigurationSettingName != MaintenanceMode.MaintenanceModeSettingName))
{
Trace.TraceInformation("Recycling worker role because of configuration change");
e.Cancel = true;
}
};
RoleEnvironment.Changed += (sender, e) => {
if (e.Changes
.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any(x => x.ConfigurationSettingName == MaintenanceMode.MaintenanceModeSettingName))
{
Trace.TraceInformation("Refreshing maintenance mode because of configuration change");
MaintenanceMode.RefreshIsInMaintainanceMode();
}
};
MaintenanceMode.RefreshIsInMaintainanceMode();
var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
var cloudStorageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString"));
TimeSpan transferPeriod;
if (!TimeSpan.TryParse(RoleEnvironment.GetConfigurationSettingValue("Diagnostics.ScheduledTransferPeriod"), out transferPeriod))
{
transferPeriod = TimeSpan.FromMinutes(1);
}
TimeSpan sampleRate;
if (!TimeSpan.TryParse(RoleEnvironment.GetConfigurationSettingValue("Diagnostics.PerformanceCounterSampleRate"), out sampleRate))
{
sampleRate = TimeSpan.FromSeconds(30);
}
LogLevel logLevel;
if (!Enum.TryParse(RoleEnvironment.GetConfigurationSettingValue("Diagnostics.LogLevelFilter"), out logLevel))
{
logLevel = LogLevel.Verbose;
}
// Setup performance counters
config.PerformanceCounters.DataSources.Add(
new PerformanceCounterConfiguration {
CounterSpecifier = @"\Processor(_Total)\% Processor Time",
SampleRate = sampleRate
});
#if !LOCAL
foreach (var counterName in
new[]
{
Infrastructure.Azure.Instrumentation.SessionSubscriptionReceiverInstrumentation.TotalSessionsCounterName,
Infrastructure.Azure.Instrumentation.SessionSubscriptionReceiverInstrumentation.CurrentSessionsCounterName,
Infrastructure.Azure.Instrumentation.SubscriptionReceiverInstrumentation.TotalMessagesCounterName,
Infrastructure.Azure.Instrumentation.SubscriptionReceiverInstrumentation.TotalMessagesSuccessfullyProcessedCounterName,
Infrastructure.Azure.Instrumentation.SubscriptionReceiverInstrumentation.TotalMessagesUnsuccessfullyProcessedCounterName,
Infrastructure.Azure.Instrumentation.SubscriptionReceiverInstrumentation.TotalMessagesCompletedCounterName,
Infrastructure.Azure.Instrumentation.SubscriptionReceiverInstrumentation.TotalMessagesNotCompletedCounterName,
Infrastructure.Azure.Instrumentation.SubscriptionReceiverInstrumentation.MessagesReceivedPerSecondCounterName,
Infrastructure.Azure.Instrumentation.SubscriptionReceiverInstrumentation.AverageMessageProcessingTimeCounterName,
Infrastructure.Azure.Instrumentation.SubscriptionReceiverInstrumentation.CurrentMessagesInProcessCounterName,
})
{
config.PerformanceCounters.DataSources.Add(
new PerformanceCounterConfiguration
{
CounterSpecifier = @"\" + Infrastructure.Azure.Instrumentation.Constants.ReceiversPerformanceCountersCategory + @"(*)\" + counterName,
SampleRate = sampleRate
});
}
foreach (var counterName in
new[]
{
Infrastructure.Azure.Instrumentation.EventStoreBusPublisherInstrumentation.CurrentEventPublishersCounterName,
Infrastructure.Azure.Instrumentation.EventStoreBusPublisherInstrumentation.EventPublishingRequestsPerSecondCounterName,
Infrastructure.Azure.Instrumentation.EventStoreBusPublisherInstrumentation.EventsPublishedPerSecondCounterName,
Infrastructure.Azure.Instrumentation.EventStoreBusPublisherInstrumentation.TotalEventsPublishedCounterName,
Infrastructure.Azure.Instrumentation.EventStoreBusPublisherInstrumentation.TotalEventsPublishingRequestsCounterName,
})
{
config.PerformanceCounters.DataSources.Add(
new PerformanceCounterConfiguration
{
CounterSpecifier = @"\" + Infrastructure.Azure.Instrumentation.Constants.EventPublishersPerformanceCountersCategory + @"(*)\" + counterName,
SampleRate = sampleRate
});
}
#endif
config.PerformanceCounters.ScheduledTransferPeriod = transferPeriod;
// Setup logs
config.Logs.ScheduledTransferPeriod = transferPeriod;
config.Logs.ScheduledTransferLogLevelFilter = logLevel;
// DiagnosticMonitor.Start(cloudStorageAccount, config);
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", config);
Trace.Listeners.Add(new DiagnosticMonitorTraceListener());
Trace.AutoFlush = true;
Database.DefaultConnectionFactory = new ServiceConfigurationSettingConnectionFactory(Database.DefaultConnectionFactory);
return(base.OnStart());
}
public override bool OnStart()
{
var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
TimeSpan transferPeriod;
if (!TimeSpan.TryParse(RoleEnvironment.GetConfigurationSettingValue("Diagnostics.ScheduledTransferPeriod"), out transferPeriod))
{
transferPeriod = TimeSpan.FromMinutes(1);
}
TimeSpan sampleRate;
if (!TimeSpan.TryParse(RoleEnvironment.GetConfigurationSettingValue("Diagnostics.PerformanceCounterSampleRate"), out sampleRate))
{
sampleRate = TimeSpan.FromSeconds(30);
}
LogLevel logLevel;
if (!Enum.TryParse <LogLevel>(RoleEnvironment.GetConfigurationSettingValue("Diagnostics.LogLevelFilter"), out logLevel))
{
logLevel = LogLevel.Verbose;
}
// Setup performance counters
config.PerformanceCounters.DataSources.Add(
new PerformanceCounterConfiguration
{
CounterSpecifier = @"\Processor(_Total)\% Processor Time",
SampleRate = sampleRate
});
config.PerformanceCounters.ScheduledTransferPeriod = transferPeriod;
#if !LOCAL
foreach (var counterName in
new[]
{
Infrastructure.Azure.Instrumentation.EventStoreBusPublisherInstrumentation.CurrentEventPublishersCounterName,
Infrastructure.Azure.Instrumentation.EventStoreBusPublisherInstrumentation.EventPublishingRequestsPerSecondCounterName,
Infrastructure.Azure.Instrumentation.EventStoreBusPublisherInstrumentation.EventsPublishedPerSecondCounterName,
Infrastructure.Azure.Instrumentation.EventStoreBusPublisherInstrumentation.TotalEventsPublishedCounterName,
Infrastructure.Azure.Instrumentation.EventStoreBusPublisherInstrumentation.TotalEventsPublishingRequestsCounterName,
})
{
config.PerformanceCounters.DataSources.Add(
new PerformanceCounterConfiguration
{
CounterSpecifier = @"\" + Infrastructure.Azure.Instrumentation.Constants.EventPublishersPerformanceCountersCategory + @"(*)\" + counterName,
SampleRate = sampleRate
});
}
#endif
// Setup logs
config.Logs.ScheduledTransferPeriod = transferPeriod;
config.Logs.ScheduledTransferLogLevelFilter = logLevel;
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", config);
return(base.OnStart());
}
public static void RegisterSignalRPerfCounters()
{
TimeSpan ts = new TimeSpan(0, 0, 10);
RoleInstanceDiagnosticManager roleInstanceDiagnosticManager =
new RoleInstanceDiagnosticManager(
RoleEnvironment.GetConfigurationSettingValue("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString"),
RoleEnvironment.DeploymentId,
RoleEnvironment.CurrentRoleInstance.Role.Name,
RoleEnvironment.CurrentRoleInstance.Id);
// Get the current diagnostic monitor for the role.
var config = roleInstanceDiagnosticManager.GetCurrentConfiguration() ?? DiagnosticMonitor.GetDefaultInitialConfiguration();
string connectionString = RoleEnvironment.GetConfigurationSettingValue("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString");
string deploymentID = RoleEnvironment.DeploymentId;
string roleName = RoleEnvironment.CurrentRoleInstance.Role.Name;
// Get the DeploymentDiagnosticManager object for your deployment.
DeploymentDiagnosticManager diagManager = new DeploymentDiagnosticManager(connectionString, deploymentID);
var signalRCategoryName = createSignalRCategoryName();
RegisterCounter("Connections Connected", ts, signalRCategoryName, config);
RegisterCounter("Connections Reconnected", ts, signalRCategoryName, config);
RegisterCounter("Connections Disconnected", ts, signalRCategoryName, config);
RegisterCounter("Connections Current", ts, signalRCategoryName, config);
RegisterCounter("Connection Messages Received Total", ts, signalRCategoryName, config);
RegisterCounter("Connection Messages Sent Total", ts, signalRCategoryName, config);
RegisterCounter("Connection Messages Received/Sec", ts, signalRCategoryName, config);
RegisterCounter("Connection Messages Sent/Sec", ts, signalRCategoryName, config);
RegisterCounter("Message Bus Messages Received Total", ts, signalRCategoryName, config);
RegisterCounter("Message Bus Messages Received/Sec", ts, signalRCategoryName, config);
RegisterCounter("Scaleout Message Bus Messages Received/Sec", ts, signalRCategoryName, config);
RegisterCounter("Message Bus Messages Published Total", ts, signalRCategoryName, config);
RegisterCounter("Message Bus Messages Published/Sec", ts, signalRCategoryName, config);
RegisterCounter("Message Bus Subscribers Current", ts, signalRCategoryName, config);
RegisterCounter("Message Bus Subscribers Total", ts, signalRCategoryName, config);
RegisterCounter("Message Bus Subscribers/Sec", ts, signalRCategoryName, config);
RegisterCounter("Message Bus Allocated Workers", ts, signalRCategoryName, config);
RegisterCounter("Message Bus Busy Workers", ts, signalRCategoryName, config);
RegisterCounter("Message Bus Topics Current", ts, signalRCategoryName, config);
RegisterCounter("Errors: All Total", ts, signalRCategoryName, config);
RegisterCounter("Errors: All/Sec", ts, signalRCategoryName, config);
RegisterCounter("Errors: Hub Resolution Total", ts, signalRCategoryName, config);
RegisterCounter("Errors: Hub Resolution/Sec", ts, signalRCategoryName, config);
RegisterCounter("Errors: Hub Invocation Total", ts, signalRCategoryName, config);
RegisterCounter("Errors: Hub Invocation/Sec", ts, signalRCategoryName, config);
RegisterCounter("Errors: Tranport Total", ts, signalRCategoryName, config);
RegisterCounter("Errors: Transport/Sec", ts, signalRCategoryName, config);
RegisterCounter("Scaleout Streams Total", ts, signalRCategoryName, config);
RegisterCounter("Scaleout Streams Open", ts, signalRCategoryName, config);
RegisterCounter("Scaleout Streams Buffering", ts, signalRCategoryName, config);
RegisterCounter("Scaleout Errors Total", ts, signalRCategoryName, config);
RegisterCounter("Scaleout Errors/Sec", ts, signalRCategoryName, config);
RegisterCounter("Scaleout Send Queue Length", ts, signalRCategoryName, config);
// useful for checking that it is not the category name that is issue
RegisterCounter("Connection Failures", ts, "TCPV6", config);
// Apply the updated configuration to the diagnostic monitor.
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", config);
return;
}
