Exemplo n.º 1
0
        public async Task ConfigureSecretStore_WithDuplicateNames_MakesSubsetOfDuplicateSecretProviderNames()
        {
            // Arrange
            var    name = $"duplicate-name-{Guid.NewGuid()}";
            string secretName1 = "MySecret-1", secretName2 = "My-Secret2", secretName3 = "My-Secret3", secretName4 = $"My-Secret4";
            string secretValue1 = $"secret-{Guid.NewGuid()}",
                   secretValue2 = $"secret-{Guid.NewGuid()}",
                   secretValue3 = $"secret-{Guid.NewGuid()}",
                   secretValue4 = $"secret-{Guid.NewGuid()}";
            var builder         = new HostBuilder();

            // Act
            builder.ConfigureSecretStore((config, stores) =>
            {
                stores.AddProvider(new InMemorySecretProvider((secretName1, secretValue1)), options => options.Name = name)
                .AddProvider(new InMemorySecretProvider((secretName3, secretValue3)), options => options.Name       = "some other name")
                .AddProvider(new InMemoryCachedSecretProvider((secretName2, secretValue2)), options => options.Name = name)
                .AddProvider(new InMemorySecretProvider((secretName4, secretValue4)));
            });

            // Assert
            using (IHost host = builder.Build())
            {
                var             store    = host.Services.GetRequiredService <ISecretStore>();
                ISecretProvider provider = store.GetProvider(name);
                Assert.IsNotType <InMemoryCachedSecretProvider>(provider);
                Assert.Equal(secretValue1, await provider.GetRawSecretAsync(secretName1));
                Assert.Equal(secretValue2, await provider.GetRawSecretAsync(secretName2));
                await Assert.ThrowsAsync <SecretNotFoundException>(() => provider.GetRawSecretAsync(secretName3));

                await Assert.ThrowsAsync <SecretNotFoundException>(() => provider.GetRawSecretAsync(secretName4));
            }
        }
Exemplo n.º 2
0
        protected TableTransmitter(string tableName, ISecretProvider secretProvider, ILogger logger)
        {
            TableName = tableName;

            _secretProvider = secretProvider;
            _logger         = logger;
        }
Exemplo n.º 3
0
        // We need the package from nuget Microsoft.Rest.ClientRuntime.Azure.Authentication and Microsoft.Azure.DataLake.Store
        public static void MainMethod()
        {
            ISecretProvider secretProvider = KeyVaultSecretProvider.Instance;
            //tenantId = @"72f988bf-86f1-41af-91ab-2d7cd011db47";// For tenant Microsoft
            string tenantId = @"cdc5aeea-15c5-4db6-b079-fcadd2505dc2";// For tenant Torus

            string clientId  = secretProvider.GetSecretAsync("datacop-prod", "AdlsAadAuthAppId").Result;
            string clientKey = secretProvider.GetSecretAsync("datacop-prod", "AdlsAadAuthAppSecret").Result;

            Console.WriteLine($"For AAD application 'AdlsAadAuthApp'");

            Console.WriteLine($"clientId: {clientId}");
            Console.WriteLine($"clientKey: {clientKey}");
            dataLakeClient = new DataLakeClient(tenantId, clientId, clientKey);
            RunDemo();



            clientId  = secretProvider.GetSecretAsync("datacop-prod", "IDEAsBuildVNextAppId").Result;
            clientKey = secretProvider.GetSecretAsync("datacop-prod", "IDEAsBuildVNextAppSecret").Result;
            Console.WriteLine($"For AAD application 'IDEAsBuildVNextApp'");

            Console.WriteLine($"clientId: {clientId}");
            Console.WriteLine($"clientKey: {clientKey}");
            dataLakeClient = new DataLakeClient(tenantId, clientId, clientKey);
            RunDemo();
        }
        /// <summary>
        /// Adds an <see cref="ISecretProvider"/> implementation to the secret store of the application.
        /// </summary>
        /// <param name="secretProvider">The provider which secrets are added to the secret store.</param>
        /// <returns>
        ///     The extended secret store with the given <paramref name="secretProvider"/>.
        /// </returns>
        public SecretStoreBuilder AddProvider(ISecretProvider secretProvider)
        {
            Guard.NotNull(secretProvider, nameof(secretProvider));
            SecretStoreSources.Add(new SecretStoreSource(secretProvider));

            return(this);
        }
Exemplo n.º 5
0
        static void Main(string[] args)
        {
            ISecretProvider secretProvider = KeyVaultSecretProvider.Instance;
            //string connectionString = secretProvider.GetSecretAsync("datacop-prod", "IDEAsPortalPPEConnectionString").Result;
            string connectionString = secretProvider.GetSecretAsync("csharpmvcwebapikeyvault", "SQLConnectionString").Result;
            var    sqlDal           = new SqlDataAccessLayer(connectionString);
            //string cmdText = "SELECT Date, CONVERT(decimal, SUM([Value])) AS MetricValue FROM [DataQuality].[CommercialActiveUsageStats] WITH (NOLOCK) WHERE Date = @Date AND DataRefreshState = 'Stable' AND DateAggregationType = 'RL28' AND [Key] IN ('Platform_web_Count') AND [Workload] IN ('Exchange') GROUP BY Date ORDER BY Date DESC";
            string cmdText = @"SELECT count([userid]) as MetricValue
                                  FROM[dbo].[user_info]
                                where[userid] > 3";

            //Console.WriteLine(GetMetricValueAsDouble(sqlDal, "testName", CommandType.Text, cmdText, DateTime.UtcNow.AddDays(-1), 300).Result);
            cmdText = @"SELECT CAST(1 AS BIT) as MetricValue
                           FROM[dbo].[user_info]
                        where[userid] > 6";
            cmdText = @"SELECT CASE WHEN EXISTS (
                            SELECT *
                            FROM[dbo].[user_info]
                            where[userid] = 2
                        )
                        THEN CAST(1 AS BIT)
                        ELSE CAST(0 AS BIT) END
                        as MetricValue";
            Console.WriteLine(GetMetricValueAsBool(sqlDal, "testName", CommandType.Text, cmdText, DateTime.UtcNow.AddDays(-1), 300).Result);

            Console.ReadKey();
        }
Exemplo n.º 6
0
        public MemoryCachedSecretProvider(ISecretProvider secretProvider, ITelemetryProvider telemetryProvider)
        {
            this.secretProvider    = secretProvider;
            this.telemetryProvider = telemetryProvider;

            memoryCache = CreateMemoryCache();
        }
        public AzureServiceBusMultiThread()
        {
            ISecretProvider secretProvider             = KeyVaultSecretProvider.Instance;
            string          serviceBusConnectionString = secretProvider.GetSecretAsync(KeyVaultName, "ServiceBusConnectionString").Result;

            queueClient = new QueueClient(serviceBusConnectionString, QueueName);
        }
Exemplo n.º 8
0
 public LoginInfo(string userName, string userPasswordHash, ISecretProvider secretProvider, ISecretPersistor secretPersistor)
 {
     UserName         = userName;
     UserPasswordHash = userPasswordHash;
     SecretProvider   = secretProvider;
     SecretPersistor  = secretPersistor;
 }
        public BlobImageMediaServiceProvider(ISecretProvider secretProvider, ILogger <BlobImageMediaServiceProvider> logger)
        {
            Guard.NotNull(secretProvider, nameof(secretProvider));

            _logger         = logger;
            _secretProvider = secretProvider;
        }
Exemplo n.º 10
0
        private async Task <string> GetAuthorizationSecretAsync(AuthorizationFilterContext context)
        {
            ISecretProvider userDefinedSecretProvider =
                context.HttpContext.RequestServices.GetService <ICachedSecretProvider>()
                ?? context.HttpContext.RequestServices.GetService <ISecretProvider>();

            if (userDefinedSecretProvider is null)
            {
                throw new KeyNotFoundException(
                          $"No configured {nameof(ICachedSecretProvider)} or {nameof(ISecretProvider)} implementation found in the request service container. "
                          + "Please configure such an implementation (ex. in the Startup) of your application");
            }

            Task <string> rawSecretAsync = userDefinedSecretProvider.GetRawSecretAsync(_secretName);

            if (rawSecretAsync is null)
            {
                throw new InvalidOperationException(
                          $"Configured {nameof(ISecretProvider)} is not implemented correctly as it returns 'null' for a {nameof(Task)} value when calling {nameof(ISecretProvider.GetRawSecretAsync)}");
            }

            string foundSecret = await rawSecretAsync;

            if (foundSecret is null)
            {
                throw new SecretNotFoundException(_secretName);
            }

            return(foundSecret);
        }
        /// <summary>
        /// Creates an <see cref="ICachedSecretProvider" /> instance that will use a default <see cref="IMemoryCache"/> implementation
        /// to get SecretValues from the passed <paramref name="secretProvider"/>.
        /// </summary>
        /// <param name="secretProvider">An instantiated <see cref="ISecretProvider" /> that will only be called if the value is not cached</param>
        /// <param name="cachingDuration">The duration to cache secrets in memory</param>
        /// <returns>A secret provider that caches values</returns>
        /// <exception cref="ArgumentNullException">Thrown when the <paramref name="secretProvider"/> is <c>null</c>.</exception>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when the <paramref name="cachingDuration"/> is not a positive time duration.</exception>
        public static ICachedSecretProvider WithCaching(this ISecretProvider secretProvider, TimeSpan cachingDuration)
        {
            Guard.NotNull(secretProvider, nameof(secretProvider), "Requires a secret provider instance to include caching while retrieving secrets");
            Guard.NotLessThan(cachingDuration, TimeSpan.Zero, nameof(cachingDuration), "Requires a positive time duration in which the caching should take place");

            return(new CachedSecretProvider(secretProvider, new CacheConfiguration(cachingDuration)));
        }
Exemplo n.º 12
0
        private static void Initialize(string keyVaultName)
        {
            ISecretProvider secretProvider = KeyVaultSecretProvider.Instance;

            // PPE resource: api://ead06413-cb7c-408e-a533-2cdbe58bf3a6
            // Prod resource; api://9576eb06-ef2f-4f45-a131-e33d0e7ffb00

            // For ideas-prod-c14
            //Service = @"gdpr";
            //VirtualCluster = @"ideas-prod-c14";
            //WorkloadQueueName = @"gdpr";
            //string tenantId = @"cdc5aeea-15c5-4db6-b079-fcadd2505dc2";
            //string resource = @"api://9576eb06-ef2f-4f45-a131-e33d0e7ffb00";
            //string clientId = secretProvider.GetSecretAsync(keyVaultName, "GdprClientId").Result;
            //string clientSecret = secretProvider.GetSecretAsync(keyVaultName, "GdprClientSecret").Result;

            // For ideas-prod-build-c14
            Service           = @"pls";
            VirtualCluster    = @"ideas-prod-build-c14";
            WorkloadQueueName = @"build"; // The default value is "build".
            string tenantId     = @"72f988bf-86f1-41af-91ab-2d7cd011db47";
            string resource     = @"api://d42d6163-88e5-4339-bbb3-28ec2fb3c574";
            string clientId     = secretProvider.GetSecretAsync(keyVaultName, "PlsAadAuthAppId").Result;
            string clientSecret = secretProvider.GetSecretAsync(keyVaultName, "PlsAadAuthAppSecret").Result;

            Token = AzureActiveDirectoryToken.GetAccessTokenV1Async(tenantId, clientId, clientSecret, resource).Result;
        }
Exemplo n.º 13
0
        private Constant()
        {
            ISecretProvider secretProvider = KeyVaultSecretProvider.Instance;

            this.SQLAccountUserId   = secretProvider.GetSecretAsync("csharpmvcwebapikeyvault", "SQLAccountUserId").Result;
            this.SQLAccountPassword = secretProvider.GetSecretAsync("csharpmvcwebapikeyvault", "SQLAccountPassword").Result;
            this.StorageAccountKey  = secretProvider.GetSecretAsync("csharpmvcwebapikeyvault", "StorageAccountKey").Result;
        }
Exemplo n.º 14
0
 public Configuration(
     ISecretProvider secretProvider = null,
     DatabricksClientWrapper databricksClientWrapper = null,
     DataLakeClient dataLakeClient = null)
 {
     this.DataLakeClient          = dataLakeClient;
     this.DatabricksClientWrapper = databricksClientWrapper;
 }
Exemplo n.º 15
0
        public static X509Certificate2 GetCertificateFromBase64String()
        {
            ISecretProvider secretProvider = KeyVaultSecretProvider.Instance;
            var             bundle         = secretProvider.GetSecretAsync("datacop-prod", "CosmosRedmondClientCert").Result;

            byte[] privateKeyBytes = Convert.FromBase64String(bundle);
            return(new X509Certificate2(privateKeyBytes, (string)null, X509KeyStorageFlags.MachineKeySet));
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="DatabricksJobMetricsFunction"/> class.
        /// </summary>
        /// <param name="configuration">The application configuration to retrieve required runtime information for the Databricks connection and metric reporting.</param>
        /// <param name="secretProvider">The provider to retrieve secrets for the Databricks connection.</param>
        /// <exception cref="ArgumentNullException">Thrown when the <paramref name="configuration"/> or <paramref name="secretProvider"/> is <c>null</c>.</exception>
        public DatabricksJobMetricsFunction(IConfiguration configuration, ISecretProvider secretProvider)
        {
            Guard.NotNull(configuration, nameof(configuration), "Requires an application configuration instance to retrieve runtime information for the Databricks connection and metric reporting");
            Guard.NotNull(secretProvider, nameof(secretProvider), "Requires an secret provider instance to retrieve secrets for the Databricks connection");

            _configuration  = configuration;
            _secretProvider = secretProvider;
        }
        /// <summary>
        /// Gets the registered named <see cref="ISecretProvider"/> from the secret store.
        /// </summary>
        /// <param name="name">The name that was used to register the <see cref="ISecretProvider"/> in the secret store.</param>
        /// <exception cref="ArgumentException">Thrown when the <paramref name="name"/> is blank.</exception>
        /// <exception cref="KeyNotFoundException">Thrown when there was no <see cref="ISecretProvider"/> found in the secret store with the given <paramref name="name"/>.</exception>
        public ISecretProvider GetProvider(string name)
        {
            Guard.NotNullOrWhitespace(name, nameof(name), "Requires a non-blank name to retrieve the registered named secret provider");

            ISecretProvider subset = GetSingleOrSubsetSecretProvider(name);

            return(subset);
        }
Exemplo n.º 18
0
        protected override object OnExecute(CommandContext context)
        {
            if (context.Parameter is ISecretProvider)
            {
                _secret = (ISecretProvider)context.Parameter;
            }

            return(null);
        }
Exemplo n.º 19
0
        private static void Initialize(string keyVaultName)
        {
            ISecretProvider secretProvider = KeyVaultSecretProvider.Instance;
            string          applicationId  = secretProvider.GetSecretAsync(keyVaultName, "CloudScopeLogMonitorApplicationId").Result;
            string          clientId       = secretProvider.GetSecretAsync(keyVaultName, "BuildLogMonitorClientId").Result;
            string          clientKey      = secretProvider.GetSecretAsync(keyVaultName, "BuildLogMonitorClientKey").Result;

            cloudScopeLogProvider = new CloudScopeLogProvider(applicationId, clientId, clientKey);
        }
Exemplo n.º 20
0
        /// <summary>
        ///     Initializes a new instance of DeviceActor
        /// </summary>
        public DeviceActor(ActorHost actorHost, MessageProcessor messageProcessor, ISecretProvider secretProvider)
            : base(actorHost)
        {
            Guard.NotNull(messageProcessor, nameof(messageProcessor));
            Guard.NotNull(secretProvider, nameof(secretProvider));

            _secretProvider   = secretProvider;
            _messageProcessor = messageProcessor;
        }
Exemplo n.º 21
0
 public PortDetailsModel(
     IStoreWrapper dataStore,
     ISecretProvider secret,
     ILogger <PortDetailsModel> logger)
 {
     _dataStore = dataStore;
     _secret    = secret;
     _logger    = logger;
 }
Exemplo n.º 22
0
        /// <summary>
        /// Creating a new CachedSecretProvider with all required information
        /// </summary>
        /// <param name="secretProvider">The internal <see cref="ISecretProvider"/> used to retrieve the actual Secret Value, when not cached</param>
        /// <param name="cacheConfiguration">The <see cref="ICacheConfiguration"/> which defines how the cache works</param>
        /// <param name="memoryCache">A <see cref="IMemoryCache"/> implementation that can cache data in memory.</param>
        /// <exception cref="ArgumentNullException">The secretProvider and memoryCache parameters must not be null</exception>
        public CachedSecretProvider(ISecretProvider secretProvider, ICacheConfiguration cacheConfiguration, IMemoryCache memoryCache)
        {
            Guard.NotNull(secretProvider, nameof(secretProvider));
            Guard.NotNull(memoryCache, nameof(memoryCache));
            Guard.NotNull(cacheConfiguration, nameof(cacheConfiguration));

            _secretProvider     = secretProvider;
            _memoryCache        = memoryCache;
            _cacheConfiguration = cacheConfiguration;
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="AuthorizedSecretProvider"/> class.
        /// </summary>
        /// <param name="permittedRole">The role that is required to access the <paramref name="secretProvider"/>.</param>
        /// <param name="authorization">The instance to determine if the <paramref name="permittedRole"/> is considered authorized.</param>
        /// <param name="secretProvider">The actual provider to access the secrets.</param>
        /// <exception cref="ArgumentNullException">Thrown when the <paramref name="authorization"/> or <paramref name="secretProvider"/> is <c>null</c>.</exception>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when the <paramref name="permittedRole"/> is outside the bounds of the enumeration.</exception>
        public AuthorizedSecretProvider(Role permittedRole, IRoleAuthorization authorization, ISecretProvider secretProvider)
        {
            Guard.NotNull(authorization, nameof(authorization), "Requires an instance to determine if the current role is considered authorized");
            Guard.NotNull(secretProvider, nameof(secretProvider), "Requires an instance to access the authorized secrets");
            Guard.For <ArgumentOutOfRangeException>(() => !Enum.IsDefined(typeof(Role), permittedRole), "Requires the role to be inside the bounds of the enumeration");

            _permittedRole  = permittedRole;
            _authorization  = authorization;
            _secretProvider = secretProvider;
        }
        public static void MainMethod()
        {
            ISecretProvider secretProvider = KeyVaultSecretProvider.Instance;

            client_id     = "83ac8948-e5e1-4bbd-97ea-798a13dc8bc6";
            client_secret = secretProvider.GetSecretAsync("datacop-prod", "AADDataCopClientSecret").Result;
            resource      = "83ac8948-e5e1-4bbd-97ea-798a13dc8bc6";

            HttpClientDemo();
            HttpWebRequestDemo();
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="MutatedSecretNameSecretProvider"/> class.
        /// </summary>
        /// <param name="implementation">The actual <see cref="ISecretProvider"/> implementation to look up the secret.</param>
        /// <param name="mutateSecretName">The function to mutate the name of the secret before looking up the secret.</param>
        /// <param name="logger">The instance to log diagnostic messages during the secret name mutation.</param>
        /// <exception cref="ArgumentNullException">
        ///     Thrown when the <paramref name="implementation"/> or the <paramref name="mutateSecretName"/> is <c>null</c>.
        /// </exception>
        public MutatedSecretNameSecretProvider(ISecretProvider implementation, Func <string, string> mutateSecretName, ILogger logger)
        {
            Guard.NotNull(implementation, nameof(implementation), "Requires an secret provider instance to pass the mutated secret name to");
            Guard.NotNull(mutateSecretName, nameof(mutateSecretName),
                          "Requires an transformation function to mutate the incoming secret name to something that the actual secret provider can understand");

            _mutateSecretName = mutateSecretName;
            _implementation   = implementation;

            Logger = logger ?? NullLogger <MutatedSecretNameSecretProvider> .Instance;
        }
Exemplo n.º 26
0
 public AccountController(
     UserManager <BotUser> userManager,
     SignInManager <BotUser> signInManager,
     RoleManager <BotUserRole> roleManager,
     ILoggerFactory loggerFactory,
     ISecretProvider secretProvider)
 {
     this._userManager    = userManager;
     this._signInManager  = signInManager;
     this._roleManager    = roleManager;
     this._secretProvider = secretProvider;
     this._logger         = loggerFactory.CreateLogger <AccountController>();
 }
Exemplo n.º 27
0
        /// <summary>
        /// Initializes a new instance of the <see cref="SecretStoreSource"/> class.
        /// </summary>
        /// <param name="secretProvider">The secret provider to add to the secret store.</param>
        /// <param name="mutateSecretName">The optional mutation function to transform secret names.</param>
        /// <exception cref="ArgumentNullException">Thrown when the <paramref name="secretProvider"/> is <c>null</c>.</exception>
        public SecretStoreSource(ISecretProvider secretProvider, Func <string, string> mutateSecretName = null)
        {
            Guard.NotNull(secretProvider, nameof(secretProvider), "Requires a secret provider instance to register it in the secret store");

            _secretProvider = secretProvider;

            if (secretProvider is ICachedSecretProvider cachedSecretProvider)
            {
                CachedSecretProvider = cachedSecretProvider;
            }

            MutateSecretName = mutateSecretName;
        }
        /// <summary>
        /// Gets the registered named <see cref="ISecretProvider"/> from the secret store.
        /// </summary>
        /// <param name="name">The name that was used to register the <see cref="ISecretProvider"/> in the secret store.</param>
        /// <typeparam name="TSecretProvider">The concrete <see cref="ISecretProvider"/> type.</typeparam>
        /// <exception cref="ArgumentException">Thrown when the <paramref name="name"/> is blank.</exception>
        /// <exception cref="KeyNotFoundException">
        ///     Thrown when there was no <see cref="ISecretProvider"/> found in the secret store with the given <paramref name="name"/>,
        ///     or there were multiple <see cref="ISecretProvider"/> instances registered with the same name.
        /// </exception>
        /// <exception cref="InvalidCastException">Thrown when the registered <see cref="ISecretProvider"/> cannot be cast to the specific <typeparamref name="TSecretProvider"/>.</exception>
        public TSecretProvider GetProvider <TSecretProvider>(string name) where TSecretProvider : ISecretProvider
        {
            Guard.NotNullOrWhitespace(name, nameof(name), "Requires a non-blank name to retrieve the registered named secret provider");

            ISecretProvider provider = GetProvider(name);

            if (provider is TSecretProvider concreteProvider)
            {
                return(concreteProvider);
            }

            throw new InvalidCastException($"Cannot cast registered {nameof(ISecretProvider)} with name '{name}' to type '{typeof(TSecretProvider).Name}'");
        }
Exemplo n.º 29
0
        /// <summary>
        /// Initializes a new instance of the <see cref="SecretStoreSource"/> class.
        /// </summary>
        /// <param name="secretProvider">The secret provider to add to the secret store.</param>
        /// <param name="options">The optional options to configure the <see cref="ISecretProvider"/>. in the secret store.</param>
        /// <exception cref="ArgumentNullException">Thrown when the <paramref name="secretProvider"/> is <c>null</c>.</exception>
        public SecretStoreSource(ISecretProvider secretProvider, SecretProviderOptions options)
        {
            Guard.NotNull(secretProvider, nameof(secretProvider), "Requires a secret provider instance to register it in the secret store");

            _secretProvider = secretProvider;

            if (secretProvider is ICachedSecretProvider cachedSecretProvider)
            {
                CachedSecretProvider = cachedSecretProvider;
            }

            Options = options ?? new SecretProviderOptions();
        }
Exemplo n.º 30
0
        // The doc link: https://docs.microsoft.com/en-us/azure/azure-monitor/platform/data-collector-api
        // https://docs.microsoft.com/en-us/azure/azure-monitor/log-query/log-query-overview
        // Query doc: https://docs.microsoft.com/en-us/azure/azure-monitor/log-query/get-started-portal
        // Query url: https://ms.portal.azure.com/#@microsoft.onmicrosoft.com/resource/subscriptions/6f7fbe56-fb42-4e46-b14d-dfc86acf0e0f/resourceGroups/CSharpMVCWebAPIApplicationResourceGroup/providers/Microsoft.OperationalInsights/workspaces/CSharpMVCWebAPIApplication/logs
        // It will cost a long time to create a table when you send a log request to a new table first.
        public static void MainMethod()
        {
            ISecretProvider secretProvider  = KeyVaultSecretProvider.Instance;
            string          workspaceId     = secretProvider.GetSecretAsync("csharpmvcwebapikeyvault", "LogAnalyticsWorkspaceId").Result;
            string          primaryKey      = secretProvider.GetSecretAsync("csharpmvcwebapikeyvault", "LogAnalyticsPrimaryKey").Result;
            AzureMonitorLog azureMonitorLog = new AzureMonitorLog(workspaceId, primaryKey);

            // tagId is for separating different log locations
            string tagId   = "9491c703-f581-4635-98b3-c2781ae59de2";
            string message = "This is a test error log";

            azureMonitorLog.LogErrorAsync(tagId, message).Wait();
        }