/// <summary>
/// Construct a sink that saves logs to the specified storage account.
/// </summary>
/// <param name="storageAccount">The Cloud Storage Account to use to insert the log entries to.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <param name="batchSizeLimit"></param>
/// <param name="period"></param>
/// <param name="storageTableName">Table name that log entries will be written to. Note: Optional, setting this may impact performance</param>
/// <param name="additionalRowKeyPostfix">Additional postfix string that will be appended to row keys</param>
/// <param name="keyGenerator">Generates the PartitionKey and the RowKey</param>
/// <param name="propertyColumns">Specific properties to be written to columns. By default, all properties will be written to columns.</param>
/// <param name="bypassTableCreationValidation">Bypass the exception in case the table creation fails.</param>
/// <param name="cloudTableProvider">Cloud table provider to get current log table.</param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
public AzureBatchingTableStorageWithPropertiesSink(CloudStorageAccount storageAccount,
IFormatProvider formatProvider,
int batchSizeLimit,
TimeSpan period,
string storageTableName = null,
string additionalRowKeyPostfix = null,
IKeyGenerator keyGenerator = null,
string[] propertyColumns = null,
bool bypassTableCreationValidation = false,
ICloudTableProvider cloudTableProvider = null)
: base(batchSizeLimit, period)
{
if (string.IsNullOrEmpty(storageTableName))
{
storageTableName = "LogEventEntity";
}
_storageAccount = storageAccount;
_storageTableName = storageTableName;
_bypassTableCreationValidation = bypassTableCreationValidation;
_cloudTableProvider = cloudTableProvider ?? new DefaultCloudTableProvider();
_formatProvider = formatProvider;
_additionalRowKeyPostfix = additionalRowKeyPostfix;
_propertyColumns = propertyColumns;
_keyGenerator = keyGenerator ?? new PropertiesKeyGenerator();
}
public UpdateApplicationCodeFeatureStateCommandHandler(ICloudTableProvider tableProvider, AzureManagementSettings settings,
IEnumerable <IEventHandler <IApplicationCodeFeatureStateUpdated> > eventHandlers)
{
_tableProvider = tableProvider;
_settings = settings;
_eventHandlers = eventHandlers;
}
public CreateApplicationCommandHandler(ICloudTableProvider tableProvider, AzureManagementSettings settings,
IQueryHandler <GetOrganization, Organization> organizationQueryHandler)
{
_tableProvider = tableProvider;
_organizationQueryHandler = organizationQueryHandler;
_settings = settings;
}
public ListApplicationKeysQueryHandler(ICloudTableProvider tableProvider, AzureManagementSettings settings,
IQueryHandler <GetApplication, UserOrganizationApplication> getApplication)
{
_tableProvider = tableProvider;
_settings = settings;
_getApplication = getApplication;
}
/// <summary>
/// Adds a sink that writes log events as records in Azure Table Storage table (default name LogEventEntity) using the given
/// storage account connection string.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="connectionString">The Cloud Storage Account connection string to use to insert the log entries to.</param>
/// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <param name="storageTableName">Table name that log entries will be written to. Note: Optional, setting this may impact performance</param>
/// <param name="writeInBatches">Use a periodic batching sink, as opposed to a synchronous one-at-a-time sink; this alters the partition
/// key used for the events so is not enabled by default.</param>
/// <param name="batchPostingLimit">The maximum number of events to post in a single batch.</param>
/// <param name="period">The time to wait between checking for event batches.</param>
/// <param name="keyGenerator">The key generator used to create the PartitionKey and the RowKey for each log entry</param>
/// <param name="bypassTableCreationValidation">Bypass the exception in case the table creation fails.</param>
/// <param name="cloudTableProvider">Cloud table provider to get current log table.</param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration AzureTableStorage(
this LoggerSinkConfiguration loggerConfiguration,
string connectionString,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IFormatProvider formatProvider = null,
string storageTableName = null,
bool writeInBatches = false,
TimeSpan?period = null,
int?batchPostingLimit = null,
IKeyGenerator keyGenerator = null,
bool bypassTableCreationValidation = false,
ICloudTableProvider cloudTableProvider = null)
{
if (loggerConfiguration == null)
{
throw new ArgumentNullException(nameof(loggerConfiguration));
}
if (string.IsNullOrEmpty(connectionString))
{
throw new ArgumentNullException(nameof(connectionString));
}
try
{
var storageAccount = CloudStorageAccount.Parse(connectionString);
return(AzureTableStorage(loggerConfiguration, storageAccount, restrictedToMinimumLevel, formatProvider, storageTableName, writeInBatches, period, batchPostingLimit, keyGenerator, bypassTableCreationValidation, cloudTableProvider));
}
catch (Exception ex)
{
Debugging.SelfLog.WriteLine($"Error configuring AzureTableStorage: {ex}");
ILogEventSink sink = new LoggerConfiguration().CreateLogger();
return(loggerConfiguration.Sink(sink, restrictedToMinimumLevel));
}
}
/// <summary>
/// Construct a sink that saves logs to the specified storage account.
/// </summary>
/// <param name="storageAccount">The Cloud Storage Account to use to insert the log entries to.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <param name="batchSizeLimit"></param>
/// <param name="period"></param>
/// <param name="storageTableName">Table name that log entries will be written to. Note: Optional, setting this may impact performance</param>
/// <param name="keyGenerator">generator used for partition keys and row keys</param>
/// <param name="bypassTableCreationValidation">Bypass the exception in case the table creation fails.</param>
/// <param name="cloudTableProvider">Cloud table provider to get current log table.</param>
public AzureBatchingTableStorageSink(
CloudStorageAccount storageAccount,
IFormatProvider formatProvider,
int batchSizeLimit,
TimeSpan period,
string storageTableName = null,
IKeyGenerator keyGenerator = null,
bool bypassTableCreationValidation = false,
ICloudTableProvider cloudTableProvider = null)
: base(batchSizeLimit, period)
{
if (batchSizeLimit < 1 || batchSizeLimit > 100)
{
throw new ArgumentException("batchSizeLimit must be between 1 and 100 for Azure Table Storage");
}
_formatProvider = formatProvider;
_keyGenerator = keyGenerator ?? new DefaultKeyGenerator();
if (string.IsNullOrEmpty(storageTableName))
{
storageTableName = typeof(LogEventEntity).Name;
}
_storageAccount = storageAccount;
_storageTableName = storageTableName;
_bypassTableCreationValidation = bypassTableCreationValidation;
_cloudTableProvider = cloudTableProvider ?? new DefaultCloudTableProvider();
}
/// <summary>
/// Adds a sink that writes log events as records in an Azure Table Storage table (default LogEventEntity) using the given storage account.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="storageAccount">The Cloud Storage Account to use to insert the log entries to.</param>
/// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <param name="storageTableName">Table name that log entries will be written to. Note: Optional, setting this may impact performance</param>
/// <param name="writeInBatches">Use a periodic batching sink, as opposed to a synchronous one-at-a-time sink; this alters the partition
/// key used for the events so is not enabled by default.</param>
/// <param name="batchPostingLimit">The maximum number of events to post in a single batch.</param>
/// <param name="period">The time to wait between checking for event batches.</param>
/// <param name="keyGenerator">The key generator used to create the PartitionKey and the RowKey for each log entry</param>
/// <param name="bypassTableCreationValidation">Bypass the exception in case the table creation fails.</param>
/// <param name="cloudTableProvider">Cloud table provider to get current log table.</param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration AzureTableStorage(
this LoggerSinkConfiguration loggerConfiguration,
CloudStorageAccount storageAccount,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IFormatProvider formatProvider = null,
string storageTableName = null,
bool writeInBatches = false,
TimeSpan?period = null,
int?batchPostingLimit = null,
IKeyGenerator keyGenerator = null,
bool bypassTableCreationValidation = false,
ICloudTableProvider cloudTableProvider = null)
{
if (loggerConfiguration == null)
{
throw new ArgumentNullException(nameof(loggerConfiguration));
}
if (storageAccount == null)
{
throw new ArgumentNullException(nameof(storageAccount));
}
return(AzureTableStorage(
loggerConfiguration,
new JsonFormatter(formatProvider: formatProvider, closingDelimiter: ""),
storageAccount,
restrictedToMinimumLevel,
storageTableName,
writeInBatches,
period,
batchPostingLimit,
keyGenerator,
bypassTableCreationValidation,
cloudTableProvider));
}
public AzureTableSagaRepositoryContextFactory(ICloudTableProvider <TSaga> cloudTableProvider,
ISagaConsumeContextFactory <DatabaseContext <TSaga>, TSaga> factory,
ISagaKeyFormatter <TSaga> keyFormatter)
{
_cloudTableProvider = cloudTableProvider;
_factory = factory;
_keyFormatter = keyFormatter;
}
/// <summary>
/// Construct a sink that saves logs to the specified storage account.
/// </summary>
/// <param name="storageAccount">The Cloud Storage Account to use to insert the log entries to.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <param name="batchSizeLimit"></param>
/// <param name="period"></param>
/// <param name="storageTableName">Table name that log entries will be written to. Note: Optional, setting this may impact performance</param>
/// <param name="cloudTableProvider">Cloud table provider to get current log table.</param>
public AzureBatchingTableStorageSink(
CloudStorageAccount storageAccount,
IFormatProvider formatProvider,
int batchSizeLimit,
TimeSpan period,
string storageTableName = null,
ICloudTableProvider cloudTableProvider = null)
: this(storageAccount, formatProvider, batchSizeLimit, period, storageTableName, new DefaultKeyGenerator(), cloudTableProvider : cloudTableProvider)
{
}
/// <summary>
/// Adds a sink that writes log events as records in Azure Table Storage table (default name LogEventEntity) using the given
/// storage account name and Shared Access Signature (SAS) URL.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="formatter">Use a Serilog ITextFormatter such as CompactJsonFormatter to store object in data column of Azure table</param>
/// <param name="sharedAccessSignature">The storage account/table SAS key.</param>
/// <param name="accountName">The storage account name.</param>
/// <param name="tableEndpoint">The (optional) table endpoint. Only needed for testing.</param>
/// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="storageTableName">Table name that log entries will be written to. Note: Optional, setting this may impact performance</param>
/// <param name="writeInBatches">Use a periodic batching sink, as opposed to a synchronous one-at-a-time sink; this alters the partition
/// key used for the events so is not enabled by default.</param>
/// <param name="batchPostingLimit">The maximum number of events to post in a single batch.</param>
/// <param name="period">The time to wait between checking for event batches.</param>
/// <param name="keyGenerator">The key generator used to create the PartitionKey and the RowKey for each log entry</param>
/// <param name="cloudTableProvider">Cloud table provider to get current log table.</param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration AzureTableStorage(
this LoggerSinkConfiguration loggerConfiguration,
ITextFormatter formatter,
string sharedAccessSignature,
string accountName,
Uri tableEndpoint = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
string storageTableName = null,
bool writeInBatches = false,
TimeSpan?period = null,
int?batchPostingLimit = null,
IKeyGenerator keyGenerator = null,
ICloudTableProvider cloudTableProvider = null)
{
if (loggerConfiguration == null)
{
throw new ArgumentNullException(nameof(loggerConfiguration));
}
if (formatter == null)
{
throw new ArgumentNullException(nameof(formatter));
}
if (string.IsNullOrWhiteSpace(accountName))
{
throw new ArgumentNullException(nameof(accountName));
}
if (string.IsNullOrWhiteSpace(sharedAccessSignature))
{
throw new ArgumentNullException(nameof(sharedAccessSignature));
}
try
{
var credentials = new StorageCredentials(sharedAccessSignature);
CloudStorageAccount storageAccount;
if (tableEndpoint == null)
{
storageAccount = new CloudStorageAccount(credentials, accountName, endpointSuffix: null, useHttps: true);
}
else
{
storageAccount = new CloudStorageAccount(credentials, null, null, tableEndpoint, null);
}
// We set bypassTableCreationValidation to true explicitly here as the the SAS URL might not have enough permissions to query if the table exists.
return(AzureTableStorage(loggerConfiguration, formatter, storageAccount, restrictedToMinimumLevel, storageTableName, writeInBatches, period, batchPostingLimit, keyGenerator, true, cloudTableProvider));
}
catch (Exception ex)
{
Debugging.SelfLog.WriteLine($"Error configuring AzureTableStorage: {ex}");
ILogEventSink sink = new LoggerConfiguration().CreateLogger();
return(loggerConfiguration.Sink(sink, restrictedToMinimumLevel));
}
}
public TableUserStore(ICloudTableProvider tableProvider,
string userTableName,
string userNameIndexTableName,
string userLoginTableName,
string userLoginProviderKeyIndexTableName,
string userClaimTableName,
string userRoleTableName,
string userEmailIndexTableName)
{
_userTable = tableProvider.GetTable(userTableName);
_userLoginTable = tableProvider.GetTable(userLoginTableName);
_userClaimTable = tableProvider.GetTable(userClaimTableName);
_userRoleTable = tableProvider.GetTable(userRoleTableName);
_userNameIndexTable = tableProvider.GetTable(userNameIndexTableName);
_userLoginProviderKeyIndexTable = tableProvider.GetTable(userLoginProviderKeyIndexTableName);
_userEmailIndexTable = tableProvider.GetTable(userEmailIndexTableName);
}
/// <summary>
/// Adds a sink that writes log events as records in an Azure Table Storage table (default LogEventEntity) using the given storage account.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="formatter">Use a Serilog ITextFormatter such as CompactJsonFormatter to store object in data column of Azure table</param>
/// <param name="storageAccount">The Cloud Storage Account to use to insert the log entries to.</param>
/// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="storageTableName">Table name that log entries will be written to. Note: Optional, setting this may impact performance</param>
/// <param name="writeInBatches">Use a periodic batching sink, as opposed to a synchronous one-at-a-time sink; this alters the partition
/// key used for the events so is not enabled by default.</param>
/// <param name="batchPostingLimit">The maximum number of events to post in a single batch.</param>
/// <param name="period">The time to wait between checking for event batches.</param>
/// <param name="keyGenerator">The key generator used to create the PartitionKey and the RowKey for each log entry</param>
/// <param name="bypassTableCreationValidation">Bypass the exception in case the table creation fails.</param>
/// <param name="cloudTableProvider">Cloud table provider to get current log table.</param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration AzureTableStorage(
this LoggerSinkConfiguration loggerConfiguration,
ITextFormatter formatter,
CloudStorageAccount storageAccount,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
string storageTableName = null,
bool writeInBatches = false,
TimeSpan?period = null,
int?batchPostingLimit = null,
IKeyGenerator keyGenerator = null,
bool bypassTableCreationValidation = false,
ICloudTableProvider cloudTableProvider = null)
{
if (loggerConfiguration == null)
{
throw new ArgumentNullException(nameof(loggerConfiguration));
}
if (formatter == null)
{
throw new ArgumentNullException(nameof(formatter));
}
if (storageAccount == null)
{
throw new ArgumentNullException(nameof(storageAccount));
}
ILogEventSink sink;
try
{
sink = writeInBatches ?
(ILogEventSink) new AzureBatchingTableStorageSink(storageAccount, formatter, batchPostingLimit ?? DefaultBatchPostingLimit, period ?? DefaultPeriod, storageTableName, keyGenerator, bypassTableCreationValidation, cloudTableProvider) :
new AzureTableStorageSink(storageAccount, formatter, storageTableName, keyGenerator, bypassTableCreationValidation, cloudTableProvider);
}
catch (Exception ex)
{
Debugging.SelfLog.WriteLine($"Error configuring AzureTableStorage: {ex}");
sink = new LoggerConfiguration().CreateLogger();
}
return(loggerConfiguration.Sink(sink, restrictedToMinimumLevel));
}
/// <summary>
/// Construct a sink that saves logs to the specified storage account.
/// </summary>
/// <param name="storageAccount">The Cloud Storage Account to use to insert the log entries to.</param>
/// <param name="textFormatter"></param>
/// <param name="storageTableName">Table name that log entries will be written to. Note: Optional, setting this may impact performance</param>
/// <param name="keyGenerator">generator used to generate partition keys and row keys</param>
/// <param name="bypassTableCreationValidation">Bypass the exception in case the table creation fails.</param>
/// <param name="cloudTableProvider">Cloud table provider to get current log table.</param>
public AzureTableStorageSink(
CloudStorageAccount storageAccount,
ITextFormatter textFormatter,
string storageTableName = null,
IKeyGenerator keyGenerator = null,
bool bypassTableCreationValidation = false,
ICloudTableProvider cloudTableProvider = null)
{
_textFormatter = textFormatter;
_keyGenerator = keyGenerator ?? new DefaultKeyGenerator();
if (string.IsNullOrEmpty(storageTableName))
{
storageTableName = typeof(LogEventEntity).Name;
}
_storageAccount = storageAccount;
_storageTableName = storageTableName;
_bypassTableCreationValidation = bypassTableCreationValidation;
_cloudTableProvider = cloudTableProvider ?? new DefaultCloudTableProvider();
}
/// <summary>
/// Adds a sink that writes log events as records in Azure Table Storage table (default name LogEventEntity) using the given
/// storage account name and Shared Access Signature (SAS) URL.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="sharedAccessSignature">The storage account/table SAS key.</param>
/// <param name="accountName">The storage account name.</param>
/// <param name="tableEndpoint">The (optional) table endpoint. Only needed for testing.</param>
/// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <param name="storageTableName">Table name that log entries will be written to. Note: Optional, setting this may impact performance</param>
/// <param name="writeInBatches">Use a periodic batching sink, as opposed to a synchronous one-at-a-time sink; this alters the partition
/// key used for the events so is not enabled by default.</param>
/// <param name="batchPostingLimit">The maximum number of events to post in a single batch.</param>
/// <param name="period">The time to wait between checking for event batches.</param>
/// <param name="keyGenerator">The key generator used to create the PartitionKey and the RowKey for each log entry</param>
/// <param name="cloudTableProvider">Cloud table provider to get current log table.</param>
/// <returns>Logger configuration, allowing configuration to continue.</returns>
/// <exception cref="ArgumentNullException">A required parameter is null.</exception>
public static LoggerConfiguration AzureTableStorage(
this LoggerSinkConfiguration loggerConfiguration,
string sharedAccessSignature,
string accountName,
Uri tableEndpoint = null,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IFormatProvider formatProvider = null,
string storageTableName = null,
bool writeInBatches = false,
TimeSpan?period = null,
int?batchPostingLimit = null,
IKeyGenerator keyGenerator = null,
ICloudTableProvider cloudTableProvider = null)
{
if (loggerConfiguration == null)
{
throw new ArgumentNullException(nameof(loggerConfiguration));
}
if (string.IsNullOrWhiteSpace(accountName))
{
throw new ArgumentNullException(nameof(accountName));
}
if (string.IsNullOrWhiteSpace(sharedAccessSignature))
{
throw new ArgumentNullException(nameof(sharedAccessSignature));
}
return(AzureTableStorage(
loggerConfiguration,
new JsonFormatter(formatProvider: formatProvider, closingDelimiter: ""),
sharedAccessSignature,
accountName,
tableEndpoint,
restrictedToMinimumLevel,
storageTableName,
writeInBatches,
period,
batchPostingLimit,
keyGenerator,
cloudTableProvider));
}
public RegisterCodeFeatureCommandHandler(ICloudTableProvider tableProvider, AzureManagementSettings settings)
{
_tableProvider = tableProvider;
_settings = settings;
}
public GetApplicationQueryHandler(ICloudTableProvider tableProvider, AzureManagementSettings settings)
{
_tableProvider = tableProvider;
_settings = settings;
}
public ListOrganizationsQueryHandler(ICloudTableProvider tableProvider, AzureManagementSettings settings)
{
_tableProvider = tableProvider;
_settings = settings;
}
public UpdateCodeFeatureStateCommandHandler(ICloudTableProvider tableProvider)
{
_tableProvider = tableProvider;
}
public ListApplicationCodeFeaturesQueryHandler(ICloudTableProvider tableProvider, AzureManagementSettings settings)
{
_tableProvider = tableProvider;
_settings = settings;
}
public QueryCodeFeatureStateQueryHandler(ICloudTableProvider tableProvider)
{
_tableProvider = tableProvider;
}
public TableUserStore(ICloudTableProvider tableProvider)
: this(tableProvider, "authUser", "authUserNameIndex", "authUserLogin", "authUserLoginProviderKeyIndex", "authUserClaim", "authUserRole", "authUserEmailIndex")
{
}
public CloudCodeFeatureStateCacheProvider(ICloudTableProvider tableProvider)
{
_tableProvider = tableProvider;
}
public ResemblerUsageService(ICloudTableProvider cloudTableProvider, IUsageHashDecryptService usageHashDecryptService)
{
_cloudTableProvider = cloudTableProvider;
_usageHashDecryptService = usageHashDecryptService;
}
public CloudCodeFeatureStateCacheProvider(ICloudTableProvider tableProvider)
{
_tableProvider = tableProvider;
}
public CreateOrganizationCommandHandler(ICloudTableProvider tableProvider, AzureManagementSettings settings)
{
_tableProvider = tableProvider;
_settings = settings;
}