static void Main(string[] args)
{
// Create a LoggerFactory responsible for internal logging
var loggerFactory = LoggerFactory.Create(builder => builder
.SetMinimumLevel(LogLevel.Debug)
.AddConsole());
var logger = loggerFactory.CreateLogger("Main");
// Manually setup the configuration for the library
var configuration = new Configuration
{
ServiceName = "DemoApp",
ServiceType = "ConsoleApp",
LogGroupName = "DemoApp",
EnvironmentOverride = Environments.EC2,
AgentEndPoint = "tcp://127.0.0.1:25888"
};
// create the logger using a DefaultEnvironment which will write over TCP
var environment = new DefaultEnvironment(configuration, loggerFactory);
var metrics = new MetricsLogger(environment, loggerFactory);
for (int i = 0; i < 10; i++)
{
EmitMetrics(logger, metrics);
}
logger.LogInformation("Shutting down");
environment.Sink.Shutdown().Wait(TimeSpan.FromSeconds(120));
}
/// <summary>
/// A simple function that takes a string and does a ToUpper
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
/// <returns></returns>
public string FunctionHandler(string input, ILambdaContext context)
{
var envProvider = new EnvironmentProvider(EnvironmentConfigurationProvider.Config, new ResourceFetcher());
var logger = new MetricsLogger();
var dimensionSet = new DimensionSet();
dimensionSet.AddDimension("Service", "Aggregator");
dimensionSet.AddDimension("Region", "us-west-2");
logger.PutDimensions(dimensionSet);
logger.SetNamespace("EMFLambda");
logger.PutMetric("ProcessingLatency", 101, Unit.MILLISECONDS);
logger.PutMetric("ProcessingLatency", 100, Unit.MILLISECONDS);
logger.PutMetric("ProcessingLatency", 99, Unit.MILLISECONDS);
logger.PutMetric("Count", 3, Unit.COUNT);
logger.PutProperty("AccountId", "123456789");
logger.PutProperty("RequestId", "422b1569-16f6-4a03-b8f0-fe3fd9b100f8");
logger.PutProperty("DeviceId", "61270781-c6ac-46f1-baf7-22c808af8162");
Dictionary <string, object> payLoad = new Dictionary <string, object>
{
{ "sampleTime", 123456789 },
{ "temperature", 273.0 },
{ "pressure", 101.3 }
};
logger.PutProperty("Payload", payLoad);
logger.Flush();
return(input?.ToUpper());
}
private RunDependencies CreateDependencies(TraceLevel traceLevel = TraceLevel.Info, IScriptHostEnvironment environment = null)
{
var dependencies = new RunDependencies();
var functionTraceWriter = new TestTraceWriter(System.Diagnostics.TraceLevel.Verbose);
var traceWriter = new TestTraceWriter(System.Diagnostics.TraceLevel.Verbose);
var scriptHostConfiguration = new ScriptHostConfiguration
{
HostConfig = new JobHostConfiguration(),
TraceWriter = traceWriter,
FileLoggingMode = FileLoggingMode.Always,
FileWatchingEnabled = true
};
scriptHostConfiguration.HostConfig.Tracing.ConsoleLevel = System.Diagnostics.TraceLevel.Verbose;
var eventManager = new ScriptEventManager();
var host = new Mock <ScriptHost>(environment ?? new NullScriptHostEnvironment(), eventManager, scriptHostConfiguration, null, null);
var traceWriterFactory = new Mock <IFunctionTraceWriterFactory>();
traceWriterFactory.Setup(f => f.Create(It.IsAny <string>(), null))
.Returns(functionTraceWriter);
host.SetupGet(h => h.IsPrimary).Returns(true);
host.SetupGet(h => h.FunctionTraceWriterFactory).Returns(traceWriterFactory.Object);
var entrypointResolver = new Mock <IFunctionEntryPointResolver>();
var compilation = new Mock <IDotNetCompilation>();
compilation.Setup(c => c.GetDiagnostics())
.Returns(ImmutableArray <Diagnostic> .Empty);
var compilationService = new Mock <ICompilationService <IDotNetCompilation> >();
compilationService.Setup(s => s.SupportedFileTypes)
.Returns(() => new[] { ".csx" });
compilationService.Setup(s => s.GetFunctionCompilationAsync(It.IsAny <FunctionMetadata>()))
.ReturnsAsync(compilation.Object);
var compilationServiceFactory = new Mock <ICompilationServiceFactory <ICompilationService <IDotNetCompilation>, IFunctionMetadataResolver> >();
compilationServiceFactory.Setup(f => f.CreateService(ScriptType.CSharp, It.IsAny <IFunctionMetadataResolver>()))
.Returns(compilationService.Object);
var metricsLogger = new MetricsLogger();
scriptHostConfiguration.HostConfig.AddService <IMetricsLogger>(metricsLogger);
return(new RunDependencies
{
Host = host,
EntrypointResolver = entrypointResolver,
Compilation = compilation,
CompilationService = compilationService,
CompilationServiceFactory = compilationServiceFactory,
TraceWriterFactory = traceWriterFactory,
TraceWriter = functionTraceWriter
});
}
// saves the game settings
public void SaveSettings()
{
// uses the metric logger to save the settings
MetricsLogger prefLog = new MetricsLogger();
// adjusts the volume
// TODO: maybe move this function or put it into this game settings file.
SettingsInterface.AdjustVolume();
// Saving Content to Fle
// sets the logger file
prefLog.SetLoggerFile(FILE_NAME);
// TODO: add function to metrics to see if the file exists.
// see what happens if the file isn't there.
// adds the contents
// master volume
prefLog.AddMetricToLogger(LBL_MASTER_VOL, masterVolume);
// bgm volume
prefLog.AddMetricToLogger(LBL_BGM_VOL, bgmVolume);
// sound effects
prefLog.AddMetricToLogger(LBL_SFX_VOL, sfxVolume);
// saves the data
prefLog.SaveMetrics();
}
// loads the game settings
public void LoadSettings()
{
MetricsLogger prefLog = new MetricsLogger();
// sets the logger file
prefLog.SetLoggerFile(FILE_NAME);
prefLog.LoadMetrics();
// get the contents
float value;
// master volume
value = prefLog.GetMetricFromLogger(LBL_MASTER_VOL);
SetMasterVolume(value);
// bgm
value = prefLog.GetMetricFromLogger(LBL_BGM_VOL);
SetBgmVolume(value);
// sound effects
value = prefLog.GetMetricFromLogger(LBL_SFX_VOL);
SetSfxVolume(value);
// adjust all volume settings
SettingsInterface.AdjustVolume();
}
// TODO: DI (FACAVAL) Use test helpers to create host and inject services
private RunDependencies CreateDependencies(Action <IServiceCollection> configureServices = null)
{
var dependencies = new RunDependencies();
TestLoggerProvider loggerProvider = new TestLoggerProvider();
ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
var eventManager = new ScriptEventManager();
var entrypointResolver = new Mock <IFunctionEntryPointResolver>();
var compilation = new Mock <IDotNetCompilation>();
compilation.Setup(c => c.GetDiagnostics())
.Returns(ImmutableArray <Diagnostic> .Empty);
var compilationService = new Mock <ICompilationService <IDotNetCompilation> >();
compilationService.Setup(s => s.SupportedFileTypes)
.Returns(() => new[] { ".csx" });
compilationService.Setup(s => s.GetFunctionCompilationAsync(It.IsAny <FunctionMetadata>()))
.ReturnsAsync(compilation.Object);
var compilationServiceFactory = new Mock <ICompilationServiceFactory <ICompilationService <IDotNetCompilation>, IFunctionMetadataResolver> >();
compilationServiceFactory.Setup(f => f.CreateService(DotNetScriptTypes.CSharp, It.IsAny <IFunctionMetadataResolver>()))
.Returns(compilationService.Object);
var metricsLogger = new MetricsLogger();
var hostBuilder = new HostBuilder()
.ConfigureDefaultTestWebScriptHost(o =>
{
o.ScriptPath = TestHelpers.FunctionsTestDirectory;
o.LogPath = TestHelpers.GetHostLogFileDirectory().Parent.FullName;
});
if (configureServices != null)
{
hostBuilder.ConfigureServices(configureServices);
}
var host = hostBuilder.Build();
var scriptHost = host.GetScriptHost();
return(new RunDependencies
{
Host = scriptHost,
EntrypointResolver = entrypointResolver,
Compilation = compilation,
CompilationService = compilationService,
CompilationServiceFactory = compilationServiceFactory,
LoggerProvider = loggerProvider,
LoggerFactory = loggerFactory,
MetricsLogger = metricsLogger
});
}
private void LogMetric(String metricName)
{
MetricsLogger logger = new MetricsLogger(new EnvironmentProvider(EnvironmentConfigurationProvider.Config, new ResourceFetcher()), NullLoggerFactory.Instance);
logger.PutDimensions(_dimensions);
logger.PutMetric(metricName, 100, Unit.MILLISECONDS);
logger.Flush();
}
private RunDependencies CreateDependencies(IScriptHostEnvironment environment = null)
{
var dependencies = new RunDependencies();
var scriptHostConfiguration = new ScriptHostConfiguration
{
HostConfig = new JobHostConfiguration(),
FileLoggingMode = FileLoggingMode.Always,
FileWatchingEnabled = true,
BindingProviders = new List <ScriptBindingProvider>()
};
TestLoggerProvider loggerProvider = new TestLoggerProvider();
ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
scriptHostConfiguration.HostConfig.LoggerFactory = loggerFactory;
var eventManager = new ScriptEventManager();
var host = new Mock <ScriptHost>(environment ?? new NullScriptHostEnvironment(), eventManager, scriptHostConfiguration, null, null, null);
host.CallBase = true;
host.SetupGet(h => h.IsPrimary).Returns(true);
var entrypointResolver = new Mock <IFunctionEntryPointResolver>();
var compilation = new Mock <IDotNetCompilation>();
compilation.Setup(c => c.GetDiagnostics())
.Returns(ImmutableArray <Diagnostic> .Empty);
var compilationService = new Mock <ICompilationService <IDotNetCompilation> >();
compilationService.Setup(s => s.SupportedFileTypes)
.Returns(() => new[] { ".csx" });
compilationService.Setup(s => s.GetFunctionCompilationAsync(It.IsAny <FunctionMetadata>()))
.ReturnsAsync(compilation.Object);
var compilationServiceFactory = new Mock <ICompilationServiceFactory <ICompilationService <IDotNetCompilation>, IFunctionMetadataResolver> >();
compilationServiceFactory.Setup(f => f.CreateService(ScriptType.CSharp, It.IsAny <IFunctionMetadataResolver>()))
.Returns(compilationService.Object);
var metricsLogger = new MetricsLogger();
scriptHostConfiguration.HostConfig.AddService <IMetricsLogger>(metricsLogger);
return(new RunDependencies
{
Host = host,
EntrypointResolver = entrypointResolver,
Compilation = compilation,
CompilationService = compilationService,
CompilationServiceFactory = compilationServiceFactory,
LoggerProvider = loggerProvider
});
}
public DynamicServiceReporter(IMetricsRegistry registry,
ZmqContext context, IRubyServiceHost service_host) {
service_host_ = service_host;
reporter_ = new NopMetricsReporter();
period_ = 5;
period_unit_ = TimeUnit.Seconds;
registry_ = registry;
logger_ = MetricsLogger.ForCurrentProcess;
context_ = context;
}
static void Main(string[] args)
{
var init = true;
var configuration = new Configuration
{
LogGroupName = "/Canary/Dotnet/CloudWatchAgent/Metrics",
EnvironmentOverride = Environments.ECS,
AgentEndPoint = "tcp://127.0.0.1:25888"
};
var loggerFactory = LoggerFactory.Create(builder =>
builder
.SetMinimumLevel(LogLevel.Information)
.AddConsole());
EnvironmentConfigurationProvider.Config = configuration;
// get the assembly version (this does not reflect NuGet pre-releases)
var packageVersion = GetPackageVersion();
while (true)
{
using (var logger = new MetricsLogger(loggerFactory))
{
logger.SetNamespace("Canary");
var dimensionSet = new DimensionSet();
dimensionSet.AddDimension("Runtime", "Dotnet");
dimensionSet.AddDimension("Platform", "ECS");
dimensionSet.AddDimension("Agent", "CloudWatchAgent");
dimensionSet.AddDimension("Version", packageVersion);
logger.SetDimensions(dimensionSet);
using (var currentProcess = System.Diagnostics.Process.GetCurrentProcess())
{
// https://github.com/dotnet/corefx/blob/3633ea2c6bf9d52029681efeedd84fd7a06eb6ba/src/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Linux.cs#L137
logger.PutMetric("Memory.RSS", currentProcess.WorkingSet64, Unit.BYTES);
}
logger.PutMetric("Invoke", 1, Unit.NONE);
if (init)
{
init = false;
logger.PutMetric("Init", 1, Unit.NONE);
}
logger.PutMetric("Memory.HeapUsed", GC.GetTotalMemory(false), Unit.BYTES);
}
Thread.Sleep(1_000);
}
}
void Awake()
{
if (_instance == null)
{ // gameobject was created in editor
_instance = this;
DontDestroyOnLoad(this.gameObject);
}
else if (_instance != this)
{ // duplicate gameobject not needed
DestroyImmediate(this.gameObject);
}
}
public MetricsLoggerTests()
{
_fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
_logger = _fixture.Create <ILoggerFactory>();
_environment = _fixture.Create <IEnvironment>();
_environmentProvider = _fixture.Create <IEnvironmentProvider>();
_sink = new MockSink();
_environment.Sink.Returns(_sink);
_environmentProvider.ResolveEnvironment().Returns(_environment);
_metricsLogger = new MetricsLogger(_environmentProvider, _logger);
}
public void TestFlushWithDefaultDimensionDefined()
{
MetricsContext metricsContext = new MetricsContext();
metricsContext.DefaultDimensions.Dimensions.Add("foo", "bar");
_metricsLogger = new MetricsLogger(_environment, metricsContext, _logger);
string logGroup = "TestLogGroup";
_environment.LogGroupName.Returns(logGroup);
_metricsLogger.Flush();
ExpectDimension("foo", "bar");
ExpectDimension("LogGroup", null);
}
public void Init(TracingOptions options)
{
Options = options;
if (Options.Enabled)
{
var logger = new MetricsLogger();
TraceManager.SamplingRate = Options.Rate;
TraceManager.RegisterTracer(new ZipkinTracer(new HttpZipkinSender(Options.TraceEndpoint, "application/json"), new JSONSpanSerializer(), new Statistics()));
TraceManager.Start(logger);
}
LogManager.Configuration.AddTarget(new ZipkinLogTarget());
LogManager.Configuration.AddRule(LogLevel.Warn, LogLevel.Error, nameof(ZipkinLogTarget));
LogManager.ReconfigExistingLoggers();
}
public static void InitProviders(NetworkSettings settings, string tag)
{
RouterProvider = new RouterProvider(settings);
ConnectionProvider = new ConnectionProvider(settings);
NodeProvider = new NodeProvider(settings);
ConnectionProvider.GenerateConnections();
Tag = tag;
var dbProvider = new InfluxDBProvider(tag);
MetricsLogger = new MetricsLogger(dbProvider);
MessagesDeliverFailed = 0;
MessagesUnDelivered = settings.MessagesSettings.Quantity;
}
public void TestOverrideDefaultDimensions()
{
var dimensionName = "dim";
var dimensionValue = "dimValue";
var defaultDimName = "defaultDim";
var defaultDimValue = "defaultDimValue";
MetricsContext metricsContext = new MetricsContext();
metricsContext.DefaultDimensions.AddDimension(defaultDimName, defaultDimValue);
metricsContext.SetDimensions(new DimensionSet(defaultDimName, defaultDimValue));
_metricsLogger = new MetricsLogger(_environment, metricsContext, _logger);
_metricsLogger.SetDimensions(new DimensionSet(dimensionName, dimensionValue));
_metricsLogger.Flush();
Assert.Single(_sink.MetricsContext.GetAllDimensionSets());
Assert.Null(_sink.MetricsContext.GetAllDimensionSets()[0].GetDimensionValue(defaultDimName));
}
// the amount of steps that have been completed.
// private int stepsCompleted = 0;
// destroys steps upon completing them.
// public bool destroySteps = true;
// Start is called before the first frame update
void Start()
{
// creates metric logger
if (logMetrics && logger == null)
{
logger = new MetricsLogger();
}
// starts the first step if there are steps
if (activeList && steps.Count > 0)
{
steps[currentStep].OnStepActivation();
}
// checks to see if the step list is active.
if (stepList != null)
{
// gets the text object.
if (stepList == null)
{
stepListText = stepList.GetComponent <Text>();
}
// starts list
RefreshStepList();
}
// if step children should be added.
if (addStepChildren)
{
List <Step> childSteps = new List <Step>();
GetComponentsInChildren <Step>(true, childSteps);
steps.AddRange(childSteps);
}
// adds checklist to step
foreach (Step step in steps)
{
step.checklist = this;
}
}
protected virtual void Initialize()
{
string hostLogPath = Path.Combine(ScriptConfig.RootLogPath, "Host");
FileUtility.EnsureDirectoryExists(hostLogPath);
string debugSentinelFileName = Path.Combine(hostLogPath, ScriptConstants.DebugSentinelFileName);
this.LastDebugNotify = File.GetLastWriteTime(debugSentinelFileName);
IMetricsLogger metricsLogger = ScriptConfig.HostConfig.GetService <IMetricsLogger>();
if (metricsLogger == null)
{
metricsLogger = new MetricsLogger();
ScriptConfig.HostConfig.AddService <IMetricsLogger>(metricsLogger);
}
using (metricsLogger.LatencyEvent(MetricEventNames.HostStartupLatency))
{
// read host.json and apply to JobHostConfiguration
string hostConfigFilePath = Path.Combine(ScriptConfig.RootScriptPath, ScriptConstants.HostMetadataFileName);
// If it doesn't exist, create an empty JSON file
if (!File.Exists(hostConfigFilePath))
{
File.WriteAllText(hostConfigFilePath, "{}");
}
if (ScriptConfig.HostConfig.IsDevelopment || InDebugMode)
{
// If we're in debug/development mode, use optimal debug settings
ScriptConfig.HostConfig.UseDevelopmentSettings();
}
string json = File.ReadAllText(hostConfigFilePath);
JObject hostConfig;
try
{
hostConfig = JObject.Parse(json);
}
catch (JsonException ex)
{
throw new FormatException(string.Format("Unable to parse {0} file.", ScriptConstants.HostMetadataFileName), ex);
}
ApplyConfiguration(hostConfig, ScriptConfig);
// Set up a host level TraceMonitor that will receive notification
// of ALL errors that occur. This allows us to inspect/log errors.
var traceMonitor = new TraceMonitor()
.Filter(p => { return(true); })
.Subscribe(HandleHostError);
ScriptConfig.HostConfig.Tracing.Tracers.Add(traceMonitor);
TraceLevel hostTraceLevel = ScriptConfig.HostConfig.Tracing.ConsoleLevel;
if (ScriptConfig.FileLoggingMode != FileLoggingMode.Never)
{
// Host file logging is only done conditionally
string hostLogFilePath = Path.Combine(ScriptConfig.RootLogPath, "Host");
TraceWriter fileTraceWriter = new FileTraceWriter(hostLogFilePath, hostTraceLevel).Conditional(p => FileLoggingEnabled);
if (TraceWriter != null)
{
// create a composite writer so our host logs are written to both
TraceWriter = new CompositeTraceWriter(new[] { TraceWriter, fileTraceWriter });
}
else
{
TraceWriter = fileTraceWriter;
}
}
if (TraceWriter != null)
{
ScriptConfig.HostConfig.Tracing.Tracers.Add(TraceWriter);
}
else
{
// if no TraceWriter has been configured, default it to Console
TraceWriter = new ConsoleTraceWriter(hostTraceLevel);
}
_debugModeFileWatcher = new AutoRecoveringFileSystemWatcher(hostLogPath, ScriptConstants.DebugSentinelFileName,
includeSubdirectories: false, changeTypes: WatcherChangeTypes.Created | WatcherChangeTypes.Changed);
_debugModeFileWatcher.Changed += OnDebugModeFileChanged;
var storageString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.Storage);
Task <BlobLeaseManager> blobManagerCreation = null;
if (storageString == null)
{
// Disable core storage
ScriptConfig.HostConfig.StorageConnectionString = null;
blobManagerCreation = Task.FromResult <BlobLeaseManager>(null);
}
else
{
blobManagerCreation = BlobLeaseManager.CreateAsync(storageString, TimeSpan.FromSeconds(15), ScriptConfig.HostConfig.HostId, InstanceId, TraceWriter);
}
var bindingProviders = LoadBindingProviders(ScriptConfig, hostConfig, TraceWriter);
ScriptConfig.BindingProviders = bindingProviders;
TraceWriter.Info(string.Format(CultureInfo.InvariantCulture, "Reading host configuration file '{0}'", hostConfigFilePath));
if (ScriptConfig.FileWatchingEnabled)
{
_scriptFileWatcher = new AutoRecoveringFileSystemWatcher(ScriptConfig.RootScriptPath);
_scriptFileWatcher.Changed += OnFileChanged;
}
// If a file change should result in a restart, we debounce the event to
// ensure that only a single restart is triggered within a specific time window.
// This allows us to deal with a large set of file change events that might
// result from a bulk copy/unzip operation. In such cases, we only want to
// restart after ALL the operations are complete and there is a quiet period.
_restart = (e) =>
{
TraceWriter.Info(string.Format(CultureInfo.InvariantCulture, "File change of type '{0}' detected for '{1}'", e.ChangeType, e.FullPath));
TraceWriter.Info("Host configuration has changed. Signaling restart.");
RestartHost();
};
_restart = _restart.Debounce(500);
// take a snapshot so we can detect function additions/removals
_directoryCountSnapshot = Directory.EnumerateDirectories(ScriptConfig.RootScriptPath).Count();
List <FunctionDescriptorProvider> descriptionProviders = new List <FunctionDescriptorProvider>()
{
new ScriptFunctionDescriptorProvider(this, ScriptConfig),
new NodeFunctionDescriptorProvider(this, ScriptConfig),
new DotNetFunctionDescriptorProvider(this, ScriptConfig),
new PowerShellFunctionDescriptorProvider(this, ScriptConfig)
};
// Allow BindingProviders to initialize
foreach (var bindingProvider in ScriptConfig.BindingProviders)
{
try
{
bindingProvider.Initialize();
}
catch (Exception ex)
{
// If we're unable to initialize a binding provider for any reason, log the error
// and continue
TraceWriter.Error(string.Format("Error initializing binding provider '{0}'", bindingProvider.GetType().FullName), ex);
}
}
// Create the lease manager that will keep handle the primary host blob lease acquisition and renewal
// and subscribe for change notifications.
_blobLeaseManager = blobManagerCreation.GetAwaiter().GetResult();
if (_blobLeaseManager != null)
{
_blobLeaseManager.HasLeaseChanged += BlobLeaseManagerHasLeaseChanged;
}
// read all script functions and apply to JobHostConfiguration
Collection <FunctionDescriptor> functions = ReadFunctions(descriptionProviders);
Collection <CustomAttributeBuilder> typeAttributes = CreateTypeAttributes(ScriptConfig);
string defaultNamespace = "Host";
string typeName = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", defaultNamespace, "Functions");
TraceWriter.Info(string.Format(CultureInfo.InvariantCulture, "Generating {0} job function(s)", functions.Count));
Type type = FunctionGenerator.Generate(HostAssemblyName, typeName, typeAttributes, functions);
List <Type> types = new List <Type>();
types.Add(type);
ScriptConfig.HostConfig.TypeLocator = new TypeLocator(types);
Functions = functions;
if (ScriptConfig.FileLoggingMode != FileLoggingMode.Never)
{
PurgeOldLogDirectories();
}
}
}
