/// <summary>
/// Initializes a new instance of the <see cref="PersistenceChannel" /> class.
/// </summary>
/// <param name="storageDirectoryPath">
/// Full path of a directory name. Under this folder all the transmissions will be saved.
/// Setting this value groups channels, even from different processes.
/// If 2 (or more) channels has the same <c>storageFolderName</c> only one channel will perform the sending even if the
/// channel is in a different process/AppDomain/Thread.
/// </param>
/// <param name="sendersCount">
/// Defines the number of senders. A sender is a long-running thread that sends telemetry batches in intervals defined
/// by <see cref="SendingInterval" />.
/// So the amount of senders also defined the maximum amount of http channels opened at the same time.
/// </param>
public PersistenceChannel(string storageDirectoryPath = null, int sendersCount = 1)
{
_storage = new StorageService();
_storage.Init(storageDirectoryPath);
_transmitter = new PersistenceTransmitter(_storage, sendersCount);
_flushManager = new FlushManager(_storage);
EndpointAddress = TelemetryServiceEndpoint;
}
/// <summary>
/// Initializes a new instance of the <see cref="PersistenceTransmitter" /> class.
/// </summary>
/// <param name="storage">The transmissions storage.</param>
/// <param name="sendersCount">The number of senders to create.</param>
/// <param name="createSenders">
/// A boolean value that indicates if this class should try and create senders. This is a
/// workaround for unit tests purposes only.
/// </param>
internal PersistenceTransmitter(BaseStorageService storage, int sendersCount, bool createSenders = true)
{
_storage = storage;
if (createSenders)
{
for (int i = 0; i < sendersCount; i++)
{
_senders.Add(new Sender(_storage, this));
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Sender" /> class.
/// </summary>
/// <param name="storage">The storage that holds the transmissions to send.</param>
/// <param name="transmitter">
/// The persistence transmitter that manages this Sender.
/// The transmitter will be used as a configuration class, it exposes properties like SendingInterval that will be read
/// by Sender.
/// </param>
/// <param name="startSending">
/// A boolean value that determines if Sender should start sending immediately. This is only
/// used for unit tests.
/// </param>
internal Sender(BaseStorageService storage, PersistenceTransmitter transmitter, bool startSending = true)
{
_stopped = false;
DelayHandler = new AutoResetEvent(false);
_stoppedHandler = new AutoResetEvent(false);
_drainingTimeout = TimeSpan.FromSeconds(100);
_defaultSendingInterval = TimeSpan.FromSeconds(5);
_transmitter = transmitter;
_storage = storage;
if (startSending)
{
// It is currently possible for the long - running task to be executed(and thereby block during WaitOne) on the UI thread when
// called by a task scheduled on the UI thread. Explicitly specifying TaskScheduler.Default
// when calling StartNew guarantees that Sender never blocks the main thread.
Task.Factory.StartNew(SendLoop, CancellationToken.None, TaskCreationOptions.LongRunning,
TaskScheduler.Default)
.ContinueWith(
t => PersistenceChannelDebugLog.WriteException(t.Exception, "Sender: Failure in SendLoop"),
TaskContinuationOptions.OnlyOnFaulted);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FlushManager" /> class.
/// </summary>
/// <param name="storage">The storage that persists the telemetries.</param>
internal FlushManager(BaseStorageService storage)
{
_storage = storage;
}