[
  {
    "Time": "2015-12-16T10:00:01.0000000Z",
    "Id": "01",
    "P1": 15,
    "P2": 30,
    "P3": 10,
  },
  {
    "Time": "2015-12-16T10:00:01.0000000Z",
    "Id": "02",
    "P1": 25,
    "P2": 40,
    "P3": 20,
  },
  {
    "Time": "2015-12-16T10:00:01.0000000Z",
    "Id": "03",
    "P1": 45,
    "P2": 18,
    "P3": 5,
  },
  {
    "Time": "2015-12-16T10:00:01.0000000Z",
    "Id": "04",
    "P1": 20,
    "P2": 23,
    "P3": 56,
  }
]

-- Find devices that it's at least 1 minute that don't send a message
WITH
OneEvent AS /* generate one event per period, any event */
(
                SELECT COUNT(*) As eventCount
                FROM DeviceEvents TIMESTAMP BY DeviceEvents.[timestamp]
                GROUP BY TumblingWindow(s, 60)
),
AllDevices AS /* generate one event per deviceId per period */
(
                SELECT ReferenceData.deviceId
                FROM OneEvent JOIN ReferenceData
                ON OneEvent.eventCount - OneEvent.eventCount = ReferenceData.deviceId - ReferenceData.deviceId
),
ActualCounts AS /* compute how many events have been received in the time window from each device */
(
                SELECT deviceId,
                       COUNT(*) AS eventCount
                FROM DeviceEvents TIMESTAMP BY DeviceEvents.[timestamp]
                GROUP BY TumblingWindow(s, 60), deviceId
)
/* left join AllDevices with ActualCounts to find devices with zero events */
SELECT
      AllDevices.deviceId,
      CASE WHEN ActualCounts.eventCount IS NULL THEN 0
           ELSE ActualCounts.eventCount
      END AS eventCount,
      System.Timestamp AS [timestamp]
FROM
AllDevices LEFT JOIN ActualCounts
ON
ActualCounts.deviceId = AllDevices.deviceId
AND DATEDIFF(ms, ActualCounts, AllDevices) = 0

-- Find devices that it's at least 1 minute that don't send a message
WITH
OneEvent AS /* generate one event per period, any event */
(
                SELECT COUNT(*) As eventCount
                FROM DeviceEvents TIMESTAMP BY DeviceEvents.[timestamp]
                GROUP BY TumblingWindow(s, 60)
),
AllDevices AS /* generate one event per deviceId per period */
(
                SELECT ReferenceData.deviceId
                FROM OneEvent JOIN ReferenceData
                ON OneEvent.eventCount - OneEvent.eventCount = ReferenceData.deviceId - ReferenceData.deviceId
),
ActualCounts AS /* compute how many events have been received in the time window from each device */
(
                SELECT deviceId,
                       COUNT(*) AS eventCount
                FROM DeviceEvents TIMESTAMP BY DeviceEvents.[timestamp]
                GROUP BY TumblingWindow(s, 60), deviceId
)
/* left join AllDevices with ActualCounts to find devices with zero events */
SELECT
      AllDevices.deviceId,
      CASE WHEN ActualCounts.eventCount IS NULL THEN 0
           ELSE ActualCounts.eventCount
      END AS eventCount,
      System.Timestamp AS [timestamp]
FROM
AllDevices LEFT JOIN ActualCounts
ON
ActualCounts.deviceId = AllDevices.deviceId
AND DATEDIFF(ms, ActualCounts, AllDevices) = 0
WHERE ActualCounts.eventCount IS NULL

# To login to Azure Resource Manager
Login-AzureRmAccount

# Select a default subscription for your current session in case your account has multiple Azure subscriptions
Get-AzureRmSubscription –SubscriptionName “Paolo's Azure Account” | Select-AzureRmSubscription

# Initialize Variables
$resourceGroupName = 'StreamAnalyticsWestEuropeResourceGroup'
$deploymentName = 'StreamAnalyticsIoTDemo'
$location = "West Europe"
$templateFolderName = 'C:\Projects\Azure\StreamAnalytics\TestFiles\ARM\'
$templateFile = $templateFolderName + 'azuredeploy.json'
$templateParameterFile = $templateFolderName + 'azuredeploy-parameters.json'

# Check if the resource group for the Stream Analytics job already exists
$resourceGroup = Get-AzureRmResourceGroup -Name $resourceGroupName `
                                          -ErrorAction Ignore

if (!$resourceGroup)
{
    # Create the resource group if it does not exists
    Write-Host 'Creating' $resourceGroupName 'resource group...'
    $stopWatch = [Diagnostics.Stopwatch]::StartNew()
    New-AzureRmResourceGroup -Name $resourceGroupName `
                             -Location $location `
                             -ErrorAction Stop
    $stopWatch.Stop()
    Write-Host 'The resource group' $resourceGroupName ' has been successfully created in' $stopWatch.Elapsed.TotalSeconds 'seconds'
}
else
{
    Write-Host 'The resource group' $resourceGroupName 'already exists'
}

# Check if a deployment with the specified name already exists
$deployment = Get-AzureRmResourceGroupDeployment -Name $deploymentName `
                                                 -ResourceGroupName $resourceGroupName

if ($deployment)
{
    # Delete the resource group if it already exists
    Write-Host 'The' $deploymentName 'deployment already exists. Deleting the deployment...'
    $stopWatch = [Diagnostics.Stopwatch]::StartNew()
    Remove-AzureRmResourceGroupDeployment -Name $deploymentName `
                                          -ResourceGroupName $resourceGroupName `
                                          -Force `
                                          -ErrorAction Stop
    $stopWatch.Stop()
    Write-Host 'The deployment' $deploymentName ' has been successfully deleted in ' $stopWatch.Elapsed.TotalSeconds 'seconds'
}

# Create the resource group deployment
Write-Host 'Adding deployment' $deploymentName 'to' $resourceGroupName 'resource group...'
$stopWatch = [Diagnostics.Stopwatch]::StartNew()
New-AzureRmResourceGroupDeployment -Name $deploymentName `
                                   -ResourceGroupName $resourceGroupName `
                                   -TemplateFile $templateFile `
                                   -TemplateParameterFile $templateParameterFile `
                                   -ErrorAction Stop
$stopWatch.Stop()
$deployment = Get-AzureRmResourceGroupDeployment -ResourceGroupName $resourceGroupName `
                                                 -Name $deploymentName `
                                                 -ErrorAction Stop
Write-Host 'Operation Complete'
Write-Host '=================='
Write-Host 'Provisioning State :' $deployment[0].ProvisioningState
Write-Host 'Time elapsed :' $stopWatch.Elapsed.TotalSeconds 'seconds'

#region Copyright
//=======================================================================================
// Microsoft Azure Customer Advisory Team  
//
// This sample is supplemental to the technical guidance published on the community
// blog at http://blogs.msdn.com/b/paolos/. 
// 
// Author: Paolo Salvatori
//=======================================================================================
// Copyright © 2015 Microsoft Corporation. All rights reserved.
// 
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER 
// EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF 
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. YOU BEAR THE RISK OF USING IT.
//=======================================================================================
#endregion

#region Using Directives
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using Microsoft.ServiceBus.Messaging; 
using System.Threading.Tasks;
#endregion

namespace Microsoft.AzureCat.ServiceBusExtensions
{
  /// <summary>
  /// This class contains extensions methods for the EventHubClient class
  /// </summary>
  public static class EventHubClientExtensions
  {
    #region Private Constants
    //*******************************
    // Formats
    //*******************************
    private const string EventDataListCannotBeNullOrEmpty = "The eventDataEnumerable parameter cannot be null or empty.";
    private const string SendPartitionedBatchFormat = "[EventHubClient.SendPartitionedBatch] Batch Sent: BatchSizeInBytes=[{0}] MessageCount=[{1}]";
    private const string SendPartitionedBatchAsyncFormat = "[EventHubClient.SendPartitionedBatchAsync] Batch Sent: BatchSizeInBytes=[{0}] MessageCount=[{1}]";
    #endregion

    #region Public Methods
    /// <summary>
    /// Asynchronously sends a batch of event data to the same partition.
    /// All the event data in the batch need to have the same value in the Partitionkey property.
    /// If the batch size is greater than the maximum batch size, 
    /// the method partitions the original batch into multiple batches, 
    /// each smaller in size than the maximum batch size.
    /// </summary>
    /// <param name="eventHubClient">The current EventHubClient object.</param>
    /// <param name="eventDataEnumerable">An IEnumerable object containing event data instances.</param>
    /// <param name="trace">true to cause a message to be written; otherwise, false.</param>
    /// <returns>The asynchronous operation.</returns>
    public async static Task SendPartitionedBatchAsync(this EventHubClient eventHubClient, IEnumerable<EventData> eventDataEnumerable, bool trace = false)
    {
      var eventDataList = eventDataEnumerable as IList<EventData> ?? eventDataEnumerable.ToList();
      if (eventDataEnumerable == null || !eventDataList.Any())
      {
        throw new ArgumentNullException(EventDataListCannotBeNullOrEmpty);
      }

      var batchList = new List<EventData>();
      long batchSize = 0;

      foreach (var eventData in eventDataList)
      {
        if ((batchSize + eventData.SerializedSizeInBytes) > Constants.MaxBathSizeInBytes)
        {
          // Send current batch
          await eventHubClient.SendBatchAsync(batchList);
          Trace.WriteLineIf(trace, string.Format(SendPartitionedBatchAsyncFormat, batchSize, batchList.Count));

          // Initialize a new batch
          batchList = new List<EventData> { eventData };
          batchSize = eventData.SerializedSizeInBytes;
        }
        else
        {
          // Add the EventData to the current batch
          batchList.Add(eventData);
          batchSize += eventData.SerializedSizeInBytes;
        }
      }
      // The final batch is sent outside of the loop
      await eventHubClient.SendBatchAsync(batchList);
      Trace.WriteLineIf(trace, string.Format(SendPartitionedBatchAsyncFormat, batchSize, batchList.Count));
    }

    /// <summary>
    /// Asynchronously sends a batch of event data to the same partition.
    /// All the event data in the batch need to have the same value in the Partitionkey property.
    /// If the batch size is greater than the maximum batch size, 
    /// the method partitions the original batch into multiple batches, 
    /// each smaller in size than the maximum batch size.
    /// </summary>
    /// <param name="eventHubClient">The current EventHubClient object.</param>
    /// <param name="eventDataEnumerable">An IEnumerable object containing event data instances.</param>
    /// <param name="trace">true to cause a message to be written; otherwise, false.</param>
    public static void SendPartitionedBatch(this EventHubClient eventHubClient, IEnumerable<EventData> eventDataEnumerable, bool trace = false)
    {
      var eventDataList = eventDataEnumerable as IList<EventData> ?? eventDataEnumerable.ToList();
      if (eventDataEnumerable == null || !eventDataList.Any())
      {
        throw new ArgumentNullException(EventDataListCannotBeNullOrEmpty);
      }

      var batchList = new List<EventData>();
      long batchSize = 0;

      foreach (var eventData in eventDataList)
      {
        if ((batchSize + eventData.SerializedSizeInBytes) > Constants.MaxBathSizeInBytes)
        {
          // Send current batch
          eventHubClient.SendBatch(batchList);
          Trace.WriteLineIf(trace, string.Format(SendPartitionedBatchFormat, batchSize, batchList.Count));

          // Initialize a new batch
          batchList = new List<EventData> { eventData };
          batchSize = eventData.SerializedSizeInBytes;
        }
        else
        {
          // Add the EventData to the current batch
          batchList.Add(eventData);
          batchSize += eventData.SerializedSizeInBytes;
        }
      }
      // The final batch is sent outside of the loop
      eventHubClient.SendBatch(batchList);
      Trace.WriteLineIf(trace, string.Format(SendPartitionedBatchFormat, batchSize, batchList.Count));
    } 
    #endregion
  }
}

#region Using Directives 
using System; 
using Newtonsoft.Json;  
#endregion 
 
namespace Microsoft.AzureCat.Samples.Entities 
{ 
    [Serializable] 
    public class Payload 
    { 
        /// <summary> 
        /// Gets or sets the device id. 
        /// </summary> 
        [JsonProperty(PropertyName = "eventId", Order = 1)] 
        public int EventId { get; set; } 
 
        /// <summary> 
        /// Gets or sets the device id. 
        /// </summary> 
        [JsonProperty(PropertyName = "deviceId", Order = 2)] 
        public int DeviceId { get; set; } 
 
        /// <summary> 
        /// Gets or sets the device value. 
        /// </summary> 
        [JsonProperty(PropertyName = "value", Order = 3)] 
        public int Value { get; set; } 
 
        /// <summary> 
        /// Gets or sets the event timestamp. 
        /// </summary> 
        [JsonProperty(PropertyName = "timestamp", Order = 4)] 
        public DateTime Timestamp { get; set; } 
    } 
}

#region Using Directives
using System;
using System.Diagnostics.Tracing;
using System.Runtime.CompilerServices;
using Microsoft.WindowsAzure.ServiceRuntime;

#endregion

namespace Microsoft.AzureCat.Samples.Helpers
{
    [EventSource(Name = "TraceEventSource")]
    public sealed class TraceEventSource : EventSource
    {
        #region Internal Enums
        public class Keywords
        {
            public const EventKeywords EventHub = (EventKeywords)1;
            public const EventKeywords DataBase = (EventKeywords)2;
            public const EventKeywords Diagnostic = (EventKeywords)4;
            public const EventKeywords Performance = (EventKeywords)8;
        }
        #endregion

        #region Public Static Properties
        public static readonly TraceEventSource Log = new TraceEventSource(); 
        #endregion

        #region Private Methods
        [Event(1,
       Message = "TraceIn",
       Keywords = Keywords.Diagnostic,
       Level = EventLevel.Verbose)]
        private void TraceIn(string application,
                             string instance,
                             Guid activityId,
                             string description,
                             string source,
                             string method)
        {
            if (string.IsNullOrWhiteSpace(application) ||
                string.IsNullOrWhiteSpace(instance))
            {
                return;
            }
            WriteEvent(1, application, instance, activityId, description, source, method);
        }

        [Event(2,
               Message = "TraceOut",
               Keywords = Keywords.Diagnostic,
               Level = EventLevel.Verbose)]
        private void TraceOut(string application,
                              string instance,
                              Guid activityId,
                              string description,
                              string source,
                              string method)
        {
            if (string.IsNullOrWhiteSpace(application) ||
                string.IsNullOrWhiteSpace(instance))
            {
                return;
            }
            WriteEvent(2, application, instance, activityId, description, source, method);
        }

        [Event(3,
               Message = "TraceApi",
               Keywords = Keywords.Diagnostic,
               Level = EventLevel.Informational)]
        private void TraceExec(string application,
                               string instance,
                               Guid activityId,
                               double elapsed,
                               string description,
                               string source,
                               string method)
        {
            if (string.IsNullOrWhiteSpace(application) ||
                string.IsNullOrWhiteSpace(instance) ||
                string.IsNullOrWhiteSpace(description))
            {
                return;
            }
            WriteEvent(3, application, instance, activityId, elapsed, description, source, method);
        }

        [Event(4,
               Message = "TraceInfo",
               Keywords = Keywords.Diagnostic,
               Level = EventLevel.Informational)]
        private void TraceInfo(string application,
                               string instance,
                               string description,
                               string source,
                               string method)
        {
            if (string.IsNullOrWhiteSpace(application) ||
                string.IsNullOrWhiteSpace(instance) ||
                string.IsNullOrWhiteSpace(description))
            {
                return;
            }
            WriteEvent(4, application, instance, description, source, method);
        }

        [Event(5,
               Message = "TraceError",
               Keywords = Keywords.Diagnostic,
               Level = EventLevel.Error)]
        private void TraceError(string application,
                                string instance,
                                Guid activityId,
                                string exception,
                                string innerException,
                                string source,
                                string method)
        {
            if (string.IsNullOrWhiteSpace(application) ||
                string.IsNullOrWhiteSpace(instance) ||
                string.IsNullOrWhiteSpace(exception))
            {
                return;
            }
            WriteEvent(5, application, instance, activityId, exception, string.IsNullOrWhiteSpace(innerException) ? string.Empty : innerException, source, method);
        }

        [Event(6,
               Message = "OpenPartition",
               Keywords = Keywords.EventHub,
               Level = EventLevel.Informational)]
        private void OpenPartition(string application, 
                                   string instance, 
                                   string eventHub, 
                                   string consumerGroup, 
                                   string partitionId, 
                                   string source, 
                                   string method)
        {
            if (string.IsNullOrWhiteSpace(application) ||
                string.IsNullOrWhiteSpace(instance) ||
                string.IsNullOrWhiteSpace(eventHub) ||
                string.IsNullOrWhiteSpace(consumerGroup) ||
                string.IsNullOrWhiteSpace(partitionId))
            {
                return;
            }
            WriteEvent(6, application, instance, eventHub, consumerGroup, partitionId, source, method);
        }

        [Event(7,
               Message = "ClosePartition",
               Keywords = Keywords.EventHub,
               Level = EventLevel.Informational)]
        private void ClosePartition(string application, 
                                    string instance, 
                                    string eventHub, 
                                    string consumerGroup, 
                                    string partitionId, 
                                    string reason, 
                                    string source, 
                                    string method)
        {
            if (string.IsNullOrWhiteSpace(application) ||
                string.IsNullOrWhiteSpace(instance) ||
                string.IsNullOrWhiteSpace(eventHub) ||
                string.IsNullOrWhiteSpace(consumerGroup) ||
                string.IsNullOrWhiteSpace(partitionId))
            {
                return;
            }
            WriteEvent(7, application, instance, eventHub, consumerGroup, partitionId, reason, source, method);
        }

        [Event(8,
               Message = "ProcessEvents",
               Keywords = Keywords.EventHub,
               Level = EventLevel.Informational)]
        private void ProcessEvents(string application, 
                                   string instance, 
                                   string eventHub, 
                                   string consumerGroup, 
                                   string partitionId, 
                                   int messageCount, 
                                   string source, 
                                   string method)
        {
            if (string.IsNullOrWhiteSpace(application) ||
                string.IsNullOrWhiteSpace(instance) ||
                string.IsNullOrWhiteSpace(eventHub) ||
                string.IsNullOrWhiteSpace(consumerGroup) ||
                string.IsNullOrWhiteSpace(partitionId))
            {
                return;
            }
            if (IsEnabled())
            {
                WriteEvent(8, application, instance, eventHub, consumerGroup, partitionId, messageCount, source, method);
            }
        } 
        #endregion

        #region Public Methods
        [NonEvent]
        public void TraceApi(TimeSpan elapsed,
                             string description,
                             [CallerFilePath] string source = "",
                             [CallerMemberName] string method = "")
        {
            if (IsEnabled())
            {
                TraceExec(RoleEnvironment.CurrentRoleInstance.Role.Name,
                          RoleEnvironment.CurrentRoleInstance.Id,
                          Guid.NewGuid(),
                          elapsed.TotalMilliseconds,
                          description,
                          source,
                          method);
            }
        }

        [NonEvent]
        public void TraceApi(Guid activityId,
                             TimeSpan elapsed,
                             string description,
                             [CallerFilePath] string source = "",
                             [CallerMemberName] string method = "")
        {
            if (IsEnabled())
            {
                TraceExec(RoleEnvironment.CurrentRoleInstance.Role.Name,
                          RoleEnvironment.CurrentRoleInstance.Id,
                          activityId,
                          elapsed.TotalMilliseconds,
                          description,
                          source,
                          method);
            }
        }

        [NonEvent]
        public void TraceIn([CallerFilePath] string source = "",
                            [CallerMemberName] string method = "")
        {
            if (IsEnabled())
            {
                TraceIn(RoleEnvironment.CurrentRoleInstance.Role.Name,
                        RoleEnvironment.CurrentRoleInstance.Id,
                        Guid.NewGuid(),
                        string.Empty,
                        source,
                        method);
            }
        }

        [NonEvent]
        public void TraceOut([CallerFilePath] string source = "",
                             [CallerMemberName] string method = "")
        {
            if (IsEnabled())
            {
                TraceOut(RoleEnvironment.CurrentRoleInstance.Role.Name,
                         RoleEnvironment.CurrentRoleInstance.Id,
                         Guid.NewGuid(),
                         string.Empty,
                         source,
                         method);
            }
        }

        [NonEvent]
        public void TraceInfo(string description, 
                              [CallerFilePath] string source = "", 
                              [CallerMemberName] string method = "")
        {
            if (IsEnabled())
            {
                TraceInfo(RoleEnvironment.CurrentRoleInstance.Role.Name,
                          RoleEnvironment.CurrentRoleInstance.Id,
                          description,
                          source,
                          method);
            }
        }

        [NonEvent]
        public void TraceError(string exception, 
                               string innerException,
                               [CallerFilePath] string source = "", 
                               [CallerMemberName] string method = "")
        {
            if (string.IsNullOrWhiteSpace(exception))
            {
                return;
            }
            if (IsEnabled())
            {
                TraceError(RoleEnvironment.CurrentRoleInstance.Role.Name,
                           RoleEnvironment.CurrentRoleInstance.Id,
                           Guid.NewGuid(),
                           exception, 
                           string.IsNullOrWhiteSpace(innerException) ? string.Empty : innerException,
                           source,
                           method);
            }
        }

       [NonEvent]
        public void OpenPartition(string eventHub, 
                                  string consumerGroup, 
                                  string partitionId,
                                  [CallerFilePath] string source = "",
                                  [CallerMemberName] string method = "")
        {
            if (string.IsNullOrWhiteSpace(eventHub) ||
                string.IsNullOrWhiteSpace(consumerGroup) ||
                string.IsNullOrWhiteSpace(partitionId))
            {
                return;
            }
            if (IsEnabled())
            {
                OpenPartition(RoleEnvironment.CurrentRoleInstance.Role.Name,
                              RoleEnvironment.CurrentRoleInstance.Id,
                              eventHub,
                              consumerGroup,
                              partitionId,
                              source,
                              method);
            }
        }

        [NonEvent]
       public void ClosePartition(string eventHub, 
                                  string consumerGroup, 
                                  string partitionId,
                                  string reason,
                                  [CallerFilePath] string source = "",
                                  [CallerMemberName] string method = "")
        {
            if (string.IsNullOrWhiteSpace(eventHub) ||
                string.IsNullOrWhiteSpace(consumerGroup) ||
                string.IsNullOrWhiteSpace(partitionId))
            {
                return;
            }
            if (IsEnabled())
            {
                ClosePartition(RoleEnvironment.CurrentRoleInstance.Role.Name,
                               RoleEnvironment.CurrentRoleInstance.Id,
                               eventHub,
                               consumerGroup,
                               partitionId,
                               reason,
                               source,
                               method);
            }
        }

        [NonEvent]
        public void ProcessEvents(string eventHub, 
                                  string consumerGroup, 
                                  string partitionId, 
                                  int messageCount,
                                  [CallerFilePath] string source = "",
                                  [CallerMemberName] string method = "")
        {
            if (string.IsNullOrWhiteSpace(eventHub) ||
                string.IsNullOrWhiteSpace(consumerGroup) ||
                string.IsNullOrWhiteSpace(partitionId))
            {
                return;
            }
            if (IsEnabled())
            {
                ProcessEvents(RoleEnvironment.CurrentRoleInstance.Role.Name,
                              RoleEnvironment.CurrentRoleInstance.Id,
                              eventHub,
                              consumerGroup,
                              partitionId,
                              messageCount,
                              source,
                              method);
            }
        }

        #endregion
    }
}

#region Using Directives
using System;
using System.Linq;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.ServiceBus.Messaging;
using Microsoft.WindowsAzure.ServiceRuntime;
using Microsoft.AzureCat.Samples.Helpers;
#endregion

namespace Microsoft.AzureCat.Samples.EventProcessorHostWorkerRole
{
    public class WorkerRole : RoleEntryPoint
    {
        #region Private Constants
        //*******************************
        // Messages & Formats
        //*******************************
        private const string RoleEnvironmentSettingFormat = "Configuration Setting [{0}] = [{1}].";
        private const string RoleEnvironmentConfigurationSettingChangedFormat = "The setting [{0}] is changed: new value = [{1}].";
        private const string RoleEnvironmentConfigurationSettingChangingFormat = "The setting [{0}] is changing: old value = [{1}].";
        private const string RoleEnvironmentTopologyChangedFormat = "The  topology for the [{0}] role is changed.";
        private const string RoleEnvironmentTopologyChangingFormat = "The  topology for the [{0}] role is changing.";
        private const string RoleInstanceCountFormat = "[Role {0}] instance count = [{1}].";
        private const string RoleInstanceEndpointCountFormat = "[Role {0}] instance endpoints count = [{1}].";
        private const string RoleInstanceEndpointFormat = "[Role {0}] instance endpoint [{1}]: protocol = [{2}] address = [{3}] port = [{4}].";
        private const string RoleInstanceIdFormat = "[Role {0}] instance Id = [{1}].";
        private const string RoleInstanceStatusFormat = "[Role {0}] instance Id = [{1}] Status = [{2}].";
        private const string Unknown = "Unknown";
        private const string RegisteringEventProcessor = "Registering Event Processor [EventProcessor]... ";
        private const string EventProcessorRegistered = "Event Processor [EventProcessor] successfully registered. ";

        //*******************************
        // Settings
        //*******************************
        private const string SqlDatabaseConnectionStringSetting = "SqlDatabaseConnectionString";
        private const string StorageAccountConnectionStringSetting = "StorageAccountConnectionString";
        private const string ServiceBusConnectionStringSetting = "ServiceBusConnectionString";
        private const string EventHubNameSetting = "EventHubName";
        private const string ConsumerGroupNameSetting = "ConsumerGroupName";
        #endregion

        #region Private Fields
        private string eventHubName;
        private string consumerGroupName;
        private string sqlDatabaseConnectionString;
        private string storageAccountConnectionString;
        private string serviceBusConnectionString;
        private EventProcessorHost eventProcessorHost;
        #endregion

        #region Public Methods
        public override void Run()
        {
            try
            {
                // TraceIn
                TraceEventSource.Log.TraceIn();
                
                while (true)
                {
                    Thread.Sleep(10000);
                }
                // ReSharper disable once FunctionNeverReturns
            }
            catch (Exception ex)
            {
                // Trace Exception
                TraceEventSource.Log.TraceError(ex.Message, 
                                                   ex.InnerException != null ?
                                                   ex.InnerException.Message :
                                                   string.Empty);
            }
            finally
            {
                // TraceOut
                TraceEventSource.Log.TraceOut();
            }
        }

        public override bool OnStart()
        {
            try
            {
                // TraceIn
                TraceEventSource.Log.TraceIn();

                // Set Default values for the ServicePointManager
                ServicePointManager.DefaultConnectionLimit = Environment.ProcessorCount * 120;
                ServicePointManager.UseNagleAlgorithm = false;
                ServicePointManager.Expect100Continue = false;

                // Setting RoleEnvironment event handlers
                RoleEnvironment.Changed += RoleEnvironment_Changed;
                RoleEnvironment.Changing += RoleEnvironment_Changing;
                RoleEnvironment.StatusCheck += RoleEnvironment_StatusCheck;
                RoleEnvironment.Stopping += RoleEnvironment_Stopping;

                // Read Configuration Settings
                ReadConfigurationSettings();

                // Start Event Processor
                StartEventProcessorAsync().Wait();

                // Run base.OnStart method
                return base.OnStart();
            }
            catch (Exception ex)
            {
                // Trace Exception
                TraceEventSource.Log.TraceError(ex.Message,
                                                   ex.InnerException != null ?
                                                   ex.InnerException.Message :
                                                   string.Empty);
                return false;
            }
            finally
            {
                // TraceOut
                TraceEventSource.Log.TraceOut();
            }
        }
        #endregion

        #region Private Methods

        private void ReadConfigurationSettings()
        {
            // Read sql database connectionstring setting  
            sqlDatabaseConnectionString = CloudConfigurationHelper.GetSetting(SqlDatabaseConnectionStringSetting);
            TraceEventSource.Log.TraceInfo(string.Format(RoleEnvironmentSettingFormat,
                                                        SqlDatabaseConnectionStringSetting,
                                                        sqlDatabaseConnectionString));

            // Read storage account connectionstring setting  
            storageAccountConnectionString = CloudConfigurationHelper.GetSetting(StorageAccountConnectionStringSetting);
            TraceEventSource.Log.TraceInfo(string.Format(RoleEnvironmentSettingFormat,
                                                        StorageAccountConnectionStringSetting,
                                                        storageAccountConnectionString));

            // Read service bus connectionstring setting  
            serviceBusConnectionString = CloudConfigurationHelper.GetSetting(ServiceBusConnectionStringSetting);
            TraceEventSource.Log.TraceInfo(string.Format(RoleEnvironmentSettingFormat,
                                                        ServiceBusConnectionStringSetting,
                                                        serviceBusConnectionString));
            
            // Read event hub name setting
            eventHubName = CloudConfigurationHelper.GetSetting(EventHubNameSetting);
            TraceEventSource.Log.TraceInfo(string.Format(RoleEnvironmentSettingFormat,
                                                        ServiceBusConnectionStringSetting,
                                                        serviceBusConnectionString));

            // Read event consumer group name setting
            consumerGroupName = CloudConfigurationHelper.GetSetting(ConsumerGroupNameSetting);
            TraceEventSource.Log.TraceInfo(string.Format(RoleEnvironmentSettingFormat,
                                                        ServiceBusConnectionStringSetting,
                                                        serviceBusConnectionString));
        }

        private async Task StartEventProcessorAsync()
        {
            try
            {
                // TraceIn
                TraceEventSource.Log.TraceIn();
                var eventHubClient = EventHubClient.CreateFromConnectionString(serviceBusConnectionString, eventHubName);

                // Get the default Consumer Group
                eventProcessorHost = new EventProcessorHost(RoleEnvironment.CurrentRoleInstance.Id,
                                                            eventHubClient.Path.ToLower(),
                                                            consumerGroupName.ToLower(),
                                                            serviceBusConnectionString,
                                                            storageAccountConnectionString)
                {
                    PartitionManagerOptions = new PartitionManagerOptions
                    {
                        AcquireInterval = TimeSpan.FromSeconds(10), // Default is 10 seconds
                        RenewInterval = TimeSpan.FromSeconds(10), // Default is 10 seconds
                        LeaseInterval = TimeSpan.FromSeconds(30) // Default value is 30 seconds
                    }
                };
                TraceEventSource.Log.TraceInfo(RegisteringEventProcessor);
                var eventProcessorOptions = new EventProcessorOptions
                {
                    InvokeProcessorAfterReceiveTimeout = true,
                    MaxBatchSize = 100,
                    PrefetchCount = 100,
                    ReceiveTimeOut = TimeSpan.FromSeconds(30),
                };
                eventProcessorOptions.ExceptionReceived += eventProcessorOptions_ExceptionReceived;
                await eventProcessorHost.RegisterEventProcessorFactoryAsync(new EventProcessorFactory<EventProcessor>(sqlDatabaseConnectionString),
                                                                            eventProcessorOptions);
                TraceEventSource.Log.TraceInfo(EventProcessorRegistered);
            }
            catch (Exception ex)
            {
                // Trace Exception
                TraceEventSource.Log.TraceError(ex.Message,
                                                   ex.InnerException != null ?
                                                   ex.InnerException.Message :
                                                   string.Empty);
            }
            finally
            {
                // TraceOut
                TraceEventSource.Log.TraceOut();
            }
        }

        void eventProcessorOptions_ExceptionReceived(object sender, ExceptionReceivedEventArgs e)
        {
            if (e == null || e.Exception == null)
            {
                return;
            }

            // Trace Exception
            TraceEventSource.Log.TraceError(e.Exception.Message,
                                            e.Exception.InnerException != null ?
                                            e.Exception.InnerException.Message :
                                            string.Empty);
        }

        /// <summary>
        /// Occurs after a change to the service configuration is applied to the running instances of a role.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">Represents the arguments for the Changed event, which occurs after a configuration change has been applied to a role instance.</param>
        private static void RoleEnvironment_Changed(object sender, RoleEnvironmentChangedEventArgs e)
        {
            try
            {
                // TraceIn
                TraceEventSource.Log.TraceIn();

                // Get the list of configuration setting changes
                var settingChanges = e.Changes.OfType<RoleEnvironmentConfigurationSettingChange>();

                foreach (var settingChange in settingChanges)
                {
                    var value = CloudConfigurationHelper.GetSetting(settingChange.ConfigurationSettingName);
                    TraceEventSource.Log.TraceInfo(string.Format(RoleEnvironmentConfigurationSettingChangedFormat,
                                                                            settingChange.ConfigurationSettingName ?? string.Empty,
                                                                            string.IsNullOrEmpty(value) ? string.Empty : value));
                }

                // Get the list of configuration changes
                var topologyChanges = e.Changes.OfType<RoleEnvironmentTopologyChange>();

                foreach (var roleName in topologyChanges.Select(topologyChange => topologyChange.RoleName))
                {
                    TraceEventSource.Log.TraceInfo(string.Format(RoleEnvironmentTopologyChangedFormat,string.IsNullOrEmpty(roleName) ? Unknown : roleName));
                    if (string.IsNullOrEmpty(roleName))
                    {
                        continue;
                    }
                    var role = RoleEnvironment.Roles[roleName];
                    if (role == null)
                    {
                        continue;
                    }
                    TraceEventSource.Log.TraceInfo(string.Format(RoleInstanceCountFormat, roleName, role.Instances.Count));
                    foreach (var roleInstance in role.Instances)
                    {
                        TraceEventSource.Log.TraceInfo(string.Format(RoleInstanceIdFormat, roleName, roleInstance.Id));
                        TraceEventSource.Log.TraceInfo(string.Format(RoleInstanceEndpointCountFormat, roleName, roleInstance.InstanceEndpoints.Count));
                        foreach (var instanceEndpoint in roleInstance.InstanceEndpoints)
                        {
                            TraceEventSource.Log.TraceInfo(string.Format(RoleInstanceEndpointFormat,
                                                                            roleName,
                                                                            instanceEndpoint.Key,
                                                                            instanceEndpoint.Value.Protocol,
                                                                            instanceEndpoint.Value.IPEndpoint.Address,
                                                                            instanceEndpoint.Value.IPEndpoint.Port));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                // Trace Exception
                TraceEventSource.Log.TraceError(ex.Message,
                                                   ex.InnerException != null ?
                                                   ex.InnerException.Message :
                                                   string.Empty);
            }
            finally
            {
                // TraceOut
                TraceEventSource.Log.TraceOut();
            }
        }

        /// <summary>
        /// Occurs before a change to the service configuration is applied to the running instances of a role. 
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">presents the arguments for the Changing event, which occurs before a configuration change is applied to a role instance. </param>
        private static void RoleEnvironment_Changing(object sender, RoleEnvironmentChangingEventArgs e)
        {
            try
            {
                // TraceIn
                TraceEventSource.Log.TraceIn();

                // Get the list of configuration setting changes
                var settingChanges = e.Changes.OfType<RoleEnvironmentConfigurationSettingChange>();

                foreach (var settingChange in settingChanges)
                {
                    var value = CloudConfigurationHelper.GetSetting(settingChange.ConfigurationSettingName);
                    TraceEventSource.Log.TraceInfo(string.Format(RoleEnvironmentConfigurationSettingChangingFormat,
                                                                    settingChange.ConfigurationSettingName,
                                                                    string.IsNullOrEmpty(value) ? string.Empty : value));
                }

                // Get the list of configuration changes
                var topologyChanges = e.Changes.OfType<RoleEnvironmentTopologyChange>();

                foreach (var roleName in topologyChanges.Select(topologyChange => topologyChange.RoleName))
                {
                    TraceEventSource.Log.TraceInfo(string.Format(RoleEnvironmentTopologyChangingFormat,
                                                                    string.IsNullOrEmpty(roleName) ? Unknown : roleName));
                    if (string.IsNullOrEmpty(roleName))
                    {
                        continue;
                    }
                    var role = RoleEnvironment.Roles[roleName];
                    if (role == null)
                    {
                        continue;
                    }
                    TraceEventSource.Log.TraceInfo(string.Format(RoleInstanceCountFormat, roleName, role.Instances.Count));
                    foreach (var roleInstance in role.Instances)
                    {
                        TraceEventSource.Log.TraceInfo(string.Format(RoleInstanceIdFormat, roleName, roleInstance.Id));
                        TraceEventSource.Log.TraceInfo(string.Format(RoleInstanceEndpointCountFormat, roleName, roleInstance.InstanceEndpoints.Count));
                        foreach (var instanceEndpoint in roleInstance.InstanceEndpoints)
                        {
                            TraceEventSource.Log.TraceInfo(string.Format(RoleInstanceEndpointFormat,
                                                                            roleName,
                                                                            instanceEndpoint.Key,
                                                                            instanceEndpoint.Value.Protocol,
                                                                            instanceEndpoint.Value.IPEndpoint.Address,
                                                                            instanceEndpoint.Value.IPEndpoint.Port));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                // Trace Exception
                TraceEventSource.Log.TraceError(ex.Message,
                                                   ex.InnerException != null ?
                                                   ex.InnerException.Message :
                                                   string.Empty);
            }
            finally
            {
                // TraceOut
                TraceEventSource.Log.TraceOut();
            }
        }

        /// <summary>
        /// Occurs at a regular interval to indicate the status of a role instance. 
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">Represents the arguments for the StatusCheck event, which occurs at a regular interval to indicate the status of a role instance.</param>
        private static void RoleEnvironment_StatusCheck(object sender, RoleInstanceStatusCheckEventArgs e)
        {
            try
            {
                // TraceIn
                TraceEventSource.Log.TraceIn();

                // Write Role Instance Status
                TraceEventSource.Log.TraceInfo(string.Format(RoleInstanceStatusFormat,
                                                                RoleEnvironment.CurrentRoleInstance.Role.Name,
                                                                RoleEnvironment.CurrentRoleInstance.Id,
                                                                e.Status));
            }
            catch (Exception ex)
            {
                // Trace Exception
                TraceEventSource.Log.TraceError(ex.Message,
                                                   ex.InnerException != null ?
                                                   ex.InnerException.Message :
                                                   string.Empty);
            }
            finally
            {
                // TraceOut
                TraceEventSource.Log.TraceOut();
            }
        }

        /// <summary>
        /// Occurs when a role instance is about to be stopped. 
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">Represents the arguments for the Stopping event, which occurs when a role instance is being stopped. </param>
        private static void RoleEnvironment_Stopping(object sender, RoleEnvironmentStoppingEventArgs e)
        {
            try
            {
                // TraceIn
                TraceEventSource.Log.TraceIn();
            }
            catch (Exception ex)
            {
                // Trace Exception
                TraceEventSource.Log.TraceError(ex.Message,
                                                   ex.InnerException != null ?
                                                   ex.InnerException.Message :
                                                   string.Empty);
            }
            finally
            {
                // TraceOut
                TraceEventSource.Log.TraceOut();
            }
        }
        #endregion
    }
}

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <appSettings>
    <add key="namespace" value="[SERVICE BUS NAMESPACE]"/>
    <add key="keyName" value="[NAMESPACE LEVEL SAS KEY NAME]"/>
    <add key="keyValue" value="[NAMESPACE LEVEL SAS KEY VALUE]"/>
    <add key="eventHub" value="[EVENT HUB NAME]"/>
    <add key="partitionCount" value="16"/>
    <add key="retentionDays" value="7"/>
    <add key="location" value="Milan"/>
    <add key="deviceCount" value="10"/>
    <add key="eventInterval" value="1"/>
    <add key="minValue" value="20"/>
    <add key="maxValue" value="50"/>
  </appSettings>
  <system.serviceModel>
    <extensions>
      <!-- In this extension section we are introducing all known service bus extensions. User can remove the ones they don't need. -->
      <behaviorExtensions>
        <add name="connectionStatusBehavior"
          type="Microsoft.ServiceBus.Configuration.ConnectionStatusElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
        <add name="transportClientEndpointBehavior"
          type="Microsoft.ServiceBus.Configuration.TransportClientEndpointBehaviorElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
        <add name="serviceRegistrySettings"
          type="Microsoft.ServiceBus.Configuration.ServiceRegistrySettingsElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
      </behaviorExtensions>
      <bindingElementExtensions>
        <add name="netMessagingTransport"
          type="Microsoft.ServiceBus.Messaging.Configuration.NetMessagingTransportExtensionElement, Microsoft.ServiceBus,  Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
        <add name="tcpRelayTransport"
          type="Microsoft.ServiceBus.Configuration.TcpRelayTransportElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
        <add name="httpRelayTransport"
          type="Microsoft.ServiceBus.Configuration.HttpRelayTransportElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
        <add name="httpsRelayTransport"
          type="Microsoft.ServiceBus.Configuration.HttpsRelayTransportElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
        <add name="onewayRelayTransport"
          type="Microsoft.ServiceBus.Configuration.RelayedOnewayTransportElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
      </bindingElementExtensions>
      <bindingExtensions>
        <add name="basicHttpRelayBinding"
          type="Microsoft.ServiceBus.Configuration.BasicHttpRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
        <add name="webHttpRelayBinding"
          type="Microsoft.ServiceBus.Configuration.WebHttpRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
        <add name="ws2007HttpRelayBinding"
          type="Microsoft.ServiceBus.Configuration.WS2007HttpRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
        <add name="netTcpRelayBinding"
          type="Microsoft.ServiceBus.Configuration.NetTcpRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
        <add name="netOnewayRelayBinding"
          type="Microsoft.ServiceBus.Configuration.NetOnewayRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
        <add name="netEventRelayBinding"
          type="Microsoft.ServiceBus.Configuration.NetEventRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
        <add name="netMessagingBinding"
          type="Microsoft.ServiceBus.Messaging.Configuration.NetMessagingBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
      </bindingExtensions>
    </extensions>
  </system.serviceModel>
</configuration>