public void InitializeReturnsApplicationInsightsConfiguration()
{
var applicationInsightsConfiguration = ApplicationInsights.Initialize(InstrumentationKey);
Assert.NotNull(applicationInsightsConfiguration);
Assert.Equal(InstrumentationKey, applicationInsightsConfiguration.TelemetryConfiguration.InstrumentationKey);
}
public override bool Init(IDictionary <string, string> jobArgsDictionary)
{
try
{
var instrumentationKey = JobConfigurationManager.TryGetArgument(jobArgsDictionary, JobArgumentNames.InstrumentationKey);
ApplicationInsights.Initialize(instrumentationKey);
_loggerFactory = LoggingSetup.CreateLoggerFactory();
_logger = _loggerFactory.CreateLogger <Job>();
var databaseConnectionString = JobConfigurationManager.GetArgument(jobArgsDictionary, JobArgumentNames.StatisticsDatabase);
_targetDatabase = new SqlConnectionStringBuilder(databaseConnectionString);
_minAgeInDays = JobConfigurationManager.TryGetIntArgument(jobArgsDictionary, "MinAgeInDays") ?? DefaultMinAgeInDays;
Trace.TraceInformation("Min age in days: " + _minAgeInDays);
return(true);
}
catch (Exception exception)
{
_logger.LogCritical("Job failed to initialize. {Exception}", exception);
}
return(false);
}
public void InitializeSetsHeartbeatIntervalAndDiagnosticsTelemetryModule()
{
var heartbeatInterval = TimeSpan.FromMinutes(1);
var applicationInsightsConfiguration = ApplicationInsights.Initialize(InstrumentationKey, heartbeatInterval);
Assert.NotNull(applicationInsightsConfiguration.DiagnosticsTelemetryModule);
Assert.Equal(heartbeatInterval, applicationInsightsConfiguration.DiagnosticsTelemetryModule.HeartbeatInterval);
}
private static ApplicationInsightsConfiguration InitializeApplicationInsights(RefreshableConfiguration configuration)
{
var instrumentationKey = configuration.Root.GetValue <string>("ApplicationInsights_InstrumentationKey");
var heartbeatIntervalSeconds = configuration.Root.GetValue("ApplicationInsights_HeartbeatIntervalSeconds", 60);
var applicationInsightsConfiguration = ApplicationInsights.Initialize(
instrumentationKey,
TimeSpan.FromSeconds(heartbeatIntervalSeconds));
applicationInsightsConfiguration.TelemetryConfiguration.TelemetryInitializers.Add(new AzureWebAppTelemetryInitializer());
RegisterApplicationInsightsTelemetryModules(applicationInsightsConfiguration.TelemetryConfiguration);
return(applicationInsightsConfiguration);
}
public override bool Init(IDictionary <string, string> jobArgsDictionary)
{
try
{
var instrumentationKey = JobConfigurationManager.TryGetArgument(jobArgsDictionary, JobArgumentNames.InstrumentationKey);
ApplicationInsights.Initialize(instrumentationKey);
var loggerConfiguration = LoggingSetup.CreateDefaultLoggerConfiguration(ConsoleLogOnly);
var loggerFactory = LoggingSetup.CreateLoggerFactory(loggerConfiguration);
Logger = loggerFactory.CreateLogger <Job>();
var databaseConnectionString = JobConfigurationManager.GetArgument(jobArgsDictionary, JobArgumentNames.GalleryDatabase);
GalleryDatabase = new SqlConnectionStringBuilder(databaseConnectionString);
}
catch (Exception exception)
{
Logger.LogCritical(LogEvents.JobInitFailed, exception, "Failed to initialize job!");
return(false);
}
return(true);
}
/// <summary>
/// This is a static method to run a job whose args are passed in
/// By default,
/// a) The job will be run continuously in a while loop. Could be overridden using 'once' argument
/// b) The sleep duration between each run when running continuously is 5000 milliSeconds. Could be overridden using '-Sleep' argument
/// </summary>
/// <param name="job">Job to run</param>
/// <param name="commandLineArgs">Args contains args to the job runner like (dbg, once and so on) and for the job itself</param>
/// <returns></returns>
public static async Task Run(JobBase job, string[] commandLineArgs)
{
if (commandLineArgs.Length > 0 && string.Equals(commandLineArgs[0], "-" + JobArgumentNames.Dbg, StringComparison.OrdinalIgnoreCase))
{
commandLineArgs = commandLineArgs.Skip(1).ToArray();
Debugger.Launch();
}
// Configure logging before Application Insights is enabled.
// This is done so, in case Application Insights fails to initialize, we still see output.
var loggerFactory = ConfigureLogging(job);
try
{
_logger.LogInformation("Started...");
// Get the args passed in or provided as an env variable based on jobName as a dictionary of <string argName, string argValue>
var jobArgsDictionary = JobConfigurationManager.GetJobArgsDictionary(loggerFactory.CreateLogger(typeof(JobConfigurationManager)), commandLineArgs, job.JobName, (ISecretReaderFactory)ServiceContainer.GetService(typeof(ISecretReaderFactory)));
// Setup logging
if (!ApplicationInsights.Initialized)
{
string instrumentationKey = JobConfigurationManager.TryGetArgument(jobArgsDictionary, JobArgumentNames.InstrumentationKey);
if (!string.IsNullOrWhiteSpace(instrumentationKey))
{
ApplicationInsights.Initialize(instrumentationKey);
}
}
// Configure our logging again with Application Insights initialized.
loggerFactory = ConfigureLogging(job);
var runContinuously = !JobConfigurationManager.TryGetBoolArgument(jobArgsDictionary, JobArgumentNames.Once);
var sleepDuration = JobConfigurationManager.TryGetIntArgument(jobArgsDictionary, JobArgumentNames.Sleep); // sleep is in milliseconds
if (!sleepDuration.HasValue)
{
sleepDuration = JobConfigurationManager.TryGetIntArgument(jobArgsDictionary, JobArgumentNames.Interval);
if (sleepDuration.HasValue)
{
sleepDuration = sleepDuration.Value * 1000; // interval is in seconds
}
}
if (sleepDuration == null)
{
_logger.LogInformation("SleepDuration is not provided or is not a valid integer. Unit is milliSeconds. Assuming default of 5000 ms...");
sleepDuration = 5000;
}
// Ensure that SSLv3 is disabled and that Tls v1.2 is enabled.
ServicePointManager.SecurityProtocol &= ~SecurityProtocolType.Ssl3;
ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls12;
// Run the job loop
await JobLoop(job, runContinuously, sleepDuration.Value, jobArgsDictionary);
}
catch (Exception ex)
{
_logger.LogError("Job runner threw an exception: {Exception}", ex);
}
}
public void InitializeRegistersTelemetryContextInitializer()
{
var applicationInsightsConfiguration = ApplicationInsights.Initialize(InstrumentationKey);
Assert.Contains(applicationInsightsConfiguration.TelemetryConfiguration.TelemetryInitializers, ti => ti is TelemetryContextInitializer);
}
public override bool Init(IDictionary <string, string> jobArgsDictionary)
{
try
{
if (!ApplicationInsights.Initialized)
{
string instrumentationKey = JobConfigurationManager.TryGetArgument(jobArgsDictionary, JobArgumentNames.InstrumentationKey);
if (!string.IsNullOrWhiteSpace(instrumentationKey))
{
ApplicationInsights.Initialize(instrumentationKey);
}
}
_loggerFactory = LoggingSetup.CreateLoggerFactory();
_logger = _loggerFactory.CreateLogger <Job>();
// Configure job
_galleryBaseAddress = JobConfigurationManager.GetArgument(jobArgsDictionary, JobArgumentNames.GalleryBaseAddress);
var storageConnectionString = JobConfigurationManager.GetArgument(jobArgsDictionary, JobArgumentNames.DataStorageAccount);
_cloudStorageAccount = CreateCloudStorageAccount(JobArgumentNames.DataStorageAccount, storageConnectionString);
_containerName = JobConfigurationManager.GetArgument(jobArgsDictionary, JobArgumentNames.ContainerName);
_runValidationTasks = JobConfigurationManager.GetArgument(jobArgsDictionary, JobArgumentNames.RunValidationTasks).Split(';');
_requestValidationTasks = JobConfigurationManager.GetArgument(jobArgsDictionary, JobArgumentNames.RequestValidationTasks).Split(';');
// Add validators
if (_runValidationTasks.Contains(UnzipValidator.ValidatorName))
{
_validators.Add(new UnzipValidator(_loggerFactory));
}
if (_runValidationTasks.Contains(VcsValidator.ValidatorName))
{
// if contact alias set, use it, if not, use submitter alias.
string submitterAlias = JobConfigurationManager.GetArgument(jobArgsDictionary, JobArgumentNames.VcsValidatorSubmitterAlias);
string contactAlias = JobConfigurationManager.TryGetArgument(jobArgsDictionary, JobArgumentNames.VcsContactAlias)
?? submitterAlias;
_validators.Add(new VcsValidator(
JobConfigurationManager.GetArgument(jobArgsDictionary, JobArgumentNames.VcsValidatorServiceUrl),
JobConfigurationManager.GetArgument(jobArgsDictionary, JobArgumentNames.VcsValidatorCallbackUrl),
contactAlias,
submitterAlias,
JobConfigurationManager.GetArgument(jobArgsDictionary, JobArgumentNames.VcsPackageUrlTemplate),
_loggerFactory));
}
return(true);
}
catch (Exception ex)
{
if (_logger != null)
{
_logger.LogError(TraceEvent.CommandLineProcessingFailed, ex, "Exception occurred while processing command line arguments");
}
else
{
Trace.TraceError("Exception occurred while processing command line arguments: {0}", ex);
}
}
return(false);
}
// This method is auto-detected by the OWIN pipeline. DO NOT RENAME IT!
public static void Configuration(IAppBuilder app)
{
// Tune ServicePointManager
// (based on http://social.technet.microsoft.com/Forums/en-US/windowsazuredata/thread/d84ba34b-b0e0-4961-a167-bbe7618beb83 and https://msdn.microsoft.com/en-us/library/system.net.servicepointmanager.aspx)
ServicePointManager.DefaultConnectionLimit = 500;
ServicePointManager.UseNagleAlgorithm = false;
ServicePointManager.Expect100Continue = false;
// Ensure that SSLv3 is disabled and that Tls v1.2 is enabled.
ServicePointManager.SecurityProtocol &= ~SecurityProtocolType.Ssl3;
ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls12;
// Setting time out for all RegEx objects. Noted in remarks at https://msdn.microsoft.com/en-us/library/system.text.regularexpressions.regex.matchtimeout%28v=vs.110%29.aspx
AppDomain.CurrentDomain.SetData("REGEX_DEFAULT_MATCH_TIMEOUT", TimeSpan.FromSeconds(10));
// Register IoC
app.UseAutofacInjection(GlobalConfiguration.Configuration);
var dependencyResolver = DependencyResolver.Current;
// Register Elmah
var elmahServiceCenter = new DependencyResolverServiceProviderAdapter(dependencyResolver);
ServiceCenter.Current = _ => elmahServiceCenter;
// Get config
var config = dependencyResolver.GetService <IGalleryConfigurationService>();
var auth = dependencyResolver.GetService <AuthenticationService>();
// Configure machine key for session persistence across slots
SessionPersistence.Setup(config);
// Refresh the content for the ContentObjectService to guarantee it has loaded the latest configuration on startup.
var contentObjectService = dependencyResolver.GetService <IContentObjectService>();
HostingEnvironment.QueueBackgroundWorkItem(async token =>
{
while (!token.IsCancellationRequested)
{
await contentObjectService.Refresh();
await Task.Delay(ContentObjectService.RefreshInterval, token);
}
});
// Setup telemetry
var instrumentationKey = config.Current.AppInsightsInstrumentationKey;
if (!string.IsNullOrEmpty(instrumentationKey))
{
var heartbeatIntervalSeconds = config.Current.AppInsightsHeartbeatIntervalSeconds;
if (heartbeatIntervalSeconds > 0)
{
// Configure instrumentation key, heartbeat interval,
// and register NuGet.Services.Logging.TelemetryContextInitializer.
ApplicationInsights.Initialize(instrumentationKey, TimeSpan.FromSeconds(heartbeatIntervalSeconds));
}
else
{
// Configure instrumentation key,
// and register NuGet.Services.Logging.TelemetryContextInitializer.
ApplicationInsights.Initialize(instrumentationKey);
}
// Add enrichers
TelemetryConfiguration.Active.TelemetryInitializers.Add(new DeploymentIdTelemetryEnricher());
TelemetryConfiguration.Active.TelemetryInitializers.Add(new ClientInformationTelemetryEnricher());
var telemetryProcessorChainBuilder = TelemetryConfiguration.Active.TelemetryProcessorChainBuilder;
// Add processors
telemetryProcessorChainBuilder.Use(next =>
{
var processor = new RequestTelemetryProcessor(next);
processor.SuccessfulResponseCodes.Add(400);
processor.SuccessfulResponseCodes.Add(404);
processor.SuccessfulResponseCodes.Add(405);
return(processor);
});
telemetryProcessorChainBuilder.Use(next => new ClientTelemetryPIIProcessor(next));
var telemetry = dependencyResolver.GetService <TelemetryClientWrapper>();
telemetryProcessorChainBuilder.Use(
next => new ExceptionTelemetryProcessor(next, telemetry.UnderlyingClient));
// Note: sampling rate must be a factor 100/N where N is a whole number
// e.g.: 50 (= 100/2), 33.33 (= 100/3), 25 (= 100/4), ...
// https://azure.microsoft.com/en-us/documentation/articles/app-insights-sampling/
var instrumentationSamplingPercentage = config.Current.AppInsightsSamplingPercentage;
if (instrumentationSamplingPercentage > 0 && instrumentationSamplingPercentage < 100)
{
telemetryProcessorChainBuilder.UseSampling(instrumentationSamplingPercentage);
}
telemetryProcessorChainBuilder.Build();
}
// Configure logging
app.SetLoggerFactory(new DiagnosticsLoggerFactory());
// Remove X-AspNetMvc-Version header
MvcHandler.DisableMvcResponseHeader = true;
if (config.Current.RequireSSL)
{
// Put a middleware at the top of the stack to force the user over to SSL
if (config.Current.ForceSslExclusion == null)
{
app.UseForceSsl(config.Current.SSLPort);
}
else
{
app.UseForceSsl(config.Current.SSLPort, config.Current.ForceSslExclusion);
}
}
// Get the local user auth provider, if present and attach it first
Authenticator localUserAuthenticator;
if (auth.Authenticators.TryGetValue(Authenticator.GetName(typeof(LocalUserAuthenticator)), out localUserAuthenticator))
{
// Configure cookie auth now
localUserAuthenticator.Startup(config, app).Wait();
}
// Attach external sign-in cookie middleware
app.SetDefaultSignInAsAuthenticationType(AuthenticationTypes.External);
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = AuthenticationTypes.External,
AuthenticationMode = AuthenticationMode.Passive,
CookieName = ".AspNet." + AuthenticationTypes.External,
ExpireTimeSpan = TimeSpan.FromMinutes(5)
});
// Attach non-cookie auth providers
var nonCookieAuthers = auth
.Authenticators
.Where(p => !String.Equals(
p.Key,
Authenticator.GetName(typeof(LocalUserAuthenticator)),
StringComparison.OrdinalIgnoreCase))
.Select(p => p.Value);
foreach (var auther in nonCookieAuthers)
{
auther.Startup(config, app).Wait();
}
var featureFlags = DependencyResolver.Current.GetService <IFeatureFlagCacheService>();
if (featureFlags != null)
{
StartFeatureFlags(featureFlags);
}
// Catch unobserved exceptions from threads before they cause IIS to crash:
TaskScheduler.UnobservedTaskException += (sender, exArgs) =>
{
// Send to AppInsights
try
{
var telemetryClient = new TelemetryClient();
telemetryClient.TrackException(exArgs.Exception, new Dictionary <string, string>()
{
{ "ExceptionOrigin", "UnobservedTaskException" }
});
}
catch (Exception)
{
// this is a tragic moment... swallow Exception to prevent crashing IIS
}
// Send to ELMAH
try
{
HttpContext current = HttpContext.Current;
if (current != null)
{
var errorSignal = ErrorSignal.FromContext(current);
if (errorSignal != null)
{
errorSignal.Raise(exArgs.Exception, current);
}
}
}
catch (Exception)
{
// more tragedy... swallow Exception to prevent crashing IIS
}
exArgs.SetObserved();
};
HasRun = true;
}