Merge pull request #443 from Microsoft/sergkanz/internalOperations

mark server telemetyr channel with internal SDK operation

Author: Sergey Kanzhelev

GlobalStaticVersion.props

@@ -8,7 +8,7 @@
     <SemanticVersionMajor>2</SemanticVersionMajor>
     <SemanticVersionMinor>3</SemanticVersionMinor>
     <SemanticVersionPatch>0</SemanticVersionPatch>
-    <PreReleaseMilestone>beta2</PreReleaseMilestone>
+    <PreReleaseMilestone>beta3</PreReleaseMilestone>
     <!-- 
       Date when Semantic Version was changed. 
       Update for every public release.

Test/ServerTelemetryChannel.Test/Shared.Tests/ServerTelemetryChannelTest.cs

@@ -13,6 +13,8 @@
     using Moq;
     using Assert = Xunit.Assert;
     using Helpers;
+    using System.Collections.Generic;
+    using Extensibility.Implementation;
 
 #if NET45
     using TaskEx = System.Threading.Tasks.Task;
@@ -348,5 +350,56 @@ public void PassesTelemetryToTelemetryProcessor()
                 Assert.Equal(telemetry, sentTelemetry);
             }
         }
+
+        [TestClass]
+        public class InternalOperation : ServerTelemetryChannelTest
+        {
+            class TransmissionStubChecksInternalOperation : Transmission
+            {
+                public Action<bool> WasCalled;
+
+                public override Task<HttpWebResponseWrapper> SendAsync()
+                {
+                    Assert.True(SdkInternalOperationsMonitor.IsEntered());
+                    this.WasCalled(true);
+                    return base.SendAsync();
+                }
+            }
+
+            class TelemetrySerializerStub : TelemetrySerializer
+            {
+                public Action<bool> WasCalled;
+
+                public TelemetrySerializerStub(Transmitter t) : base(t)
+                {
+                }
+
+                public override void Serialize(ICollection<ITelemetry> items)
+                {
+                    var transmission = new TransmissionStubChecksInternalOperation();
+                    transmission.WasCalled = this.WasCalled;
+                    base.Transmitter.Enqueue(transmission);
+                }
+            }
+
+            [TestMethod]
+            public void SendWillBeMarkedAsInternalOperation()
+            {
+                bool wasCalled = false;
+                var channel = new ServerTelemetryChannel();
+                channel.TelemetrySerializer = new TelemetrySerializerStub(channel.Transmitter) { WasCalled = (called) => { wasCalled = called; } };
+                channel.TelemetryBuffer = new TelemetryChannel.Implementation.TelemetryBuffer(channel.TelemetrySerializer, new WebApplicationLifecycle());
+                channel.TelemetryProcessor = channel.TelemetryBuffer;
+                channel.MaxTelemetryBufferCapacity = 1;
+                channel.Initialize(TelemetryConfiguration.CreateDefault());
+
+                var telemetry = new StubTelemetry();
+                channel.Send(telemetry);
+                Thread.Sleep(TimeSpan.FromSeconds(1));
+
+                Assert.True(wasCalled);
+            }
+        }
+
     }
 }

src/Core/Managed/Net46/Extensibility/Implementation/RichPayloadEventSource.cs

@@ -19,6 +19,10 @@
     using Microsoft.ApplicationInsights.DataContracts;
     using Microsoft.ApplicationInsights.Extensibility.Implementation.Tracing;
 #endif
+
+    /// <summary>
+    /// Event Source exposes Application Insights telemetry information as ETW events.
+    /// </summary>
     internal sealed partial class RichPayloadEventSource : IDisposable
     {
         /// <summary>RichPayloadEventSource instance.</summary>

src/Core/Managed/Shared/Extensibility/Implementation/RichPayloadEventSource.Keywords.cs

@@ -5,7 +5,10 @@
 #else
     using System.Diagnostics.Tracing;
 #endif
-
+    
+    /// <summary>
+    /// Event Source exposes Application Insights telemetry information as ETW events.
+    /// </summary>
     internal partial class RichPayloadEventSource
     {
         /// <summary>

src/Core/Managed/Shared/OperationTelemetryExtensions.cs

@@ -40,7 +40,9 @@ public static void Start(this OperationTelemetry telemetry, long timestamp)
             // Stopwatch.GetTimestamp() is used (instead of ElapsedTicks) as it is thread-safe.
             telemetry.BeginTimeInTicks = timestamp;
 
+#if !CORE_PCL
             RichPayloadEventSource.Log.ProcessOperationStart(telemetry);
+#endif
         }
 
         /// <summary>
@@ -111,7 +113,9 @@ private static void StopImpl(OperationTelemetry telemetry, TimeSpan duration)
                 telemetry.Timestamp = DateTimeOffset.UtcNow;
             }
 
+#if !CORE_PCL
             RichPayloadEventSource.Log.ProcessOperationStop(telemetry);
+#endif
         }
     }
 }

src/TelemetryChannels/ServerTelemetryChannel/Shared/Implementation/TelemetrySerializer.cs

@@ -8,8 +8,9 @@
 
     internal class TelemetrySerializer
     {
+        internal readonly Transmitter Transmitter;
+
         private const string DefaultEndpointAddress = "https://dc.services.visualstudio.com/v2/track";
-        private readonly Transmitter transmitter;        
         private Uri endpointAddress = new Uri(DefaultEndpointAddress);
 
         public TelemetrySerializer(Transmitter transmitter)
@@ -19,7 +20,7 @@ public TelemetrySerializer(Transmitter transmitter)
                 throw new ArgumentNullException("transmitter");
             }
 
-            this.transmitter = transmitter;
+            this.Transmitter = transmitter;
         }
 
         protected TelemetrySerializer()
@@ -64,7 +65,7 @@ public virtual void Serialize(ICollection<ITelemetry> items)
             }
 
             var transmission = new Transmission(this.endpointAddress, items);
-            this.transmitter.Enqueue(transmission);
+            this.Transmitter.Enqueue(transmission);
         }
     }
 }

src/TelemetryChannels/ServerTelemetryChannel/Shared/Implementation/TransmissionSender.cs

@@ -7,6 +7,7 @@
     using System.Runtime.Serialization;
     using System.Threading;
     using System.Threading.Tasks;
+    using Extensibility;
     using Microsoft.ApplicationInsights.Channel;
     using Microsoft.ApplicationInsights.Extensibility.Implementation;
 
@@ -143,46 +144,55 @@ protected void OnTransmissionSent(TransmissionProcessedEventArgs args)
 
         private async Task StartSending(Transmission transmission)
         {
-            Exception exception = null;
-            HttpWebResponseWrapper responseContent = null;
+            SdkInternalOperationsMonitor.Enter();
 
-            // Locally self-throttle this payload before we send it
-            Transmission acceptedTransmission = this.Throttle(transmission);
-
-            // Now that we've self-imposed a throttle, we can try to send the remaining data
             try
             {
-                TelemetryChannelEventSource.Log.TransmissionSendStarted(acceptedTransmission.Id);
-                responseContent = await acceptedTransmission.SendAsync().ConfigureAwait(false);          
-            }
-            catch (Exception e)
-            {
-                exception = e;
-            }
-            finally
-            {
-                int currentCapacity = Interlocked.Decrement(ref this.transmissionCount);
-                if (exception == null)
+                Exception exception = null;
+                HttpWebResponseWrapper responseContent = null;
+
+                // Locally self-throttle this payload before we send it
+                Transmission acceptedTransmission = this.Throttle(transmission);
+
+                // Now that we've self-imposed a throttle, we can try to send the remaining data
+                try
                 {
-                    TelemetryChannelEventSource.Log.TransmissionSentSuccessfully(acceptedTransmission.Id, currentCapacity);
+                    TelemetryChannelEventSource.Log.TransmissionSendStarted(acceptedTransmission.Id);
+                    responseContent = await acceptedTransmission.SendAsync().ConfigureAwait(false);
                 }
-                else
+                catch (Exception e)
                 {
-                    TelemetryChannelEventSource.Log.TransmissionSendingFailedWarning(acceptedTransmission.Id, exception.ToString());
+                    exception = e;
                 }
-
-                if (responseContent == null && exception is WebException)
+                finally
                 {
-                    HttpWebResponse response = (HttpWebResponse)((WebException)exception).Response;
-                    responseContent = new HttpWebResponseWrapper()
+                    int currentCapacity = Interlocked.Decrement(ref this.transmissionCount);
+                    if (exception == null)
                     {
-                        StatusCode = (int)response.StatusCode,
-                        StatusDescription = response.StatusDescription,
-                        RetryAfterHeader = response.Headers?.Get("Retry-After")
-                    };
-                }
+                        TelemetryChannelEventSource.Log.TransmissionSentSuccessfully(acceptedTransmission.Id, currentCapacity);
+                    }
+                    else
+                    {
+                        TelemetryChannelEventSource.Log.TransmissionSendingFailedWarning(acceptedTransmission.Id, exception.ToString());
+                    }
+
+                    if (responseContent == null && exception is WebException)
+                    {
+                        HttpWebResponse response = (HttpWebResponse)((WebException)exception).Response;
+                        responseContent = new HttpWebResponseWrapper()
+                        {
+                            StatusCode = (int)response.StatusCode,
+                            StatusDescription = response.StatusDescription,
+                            RetryAfterHeader = response.Headers?.Get("Retry-After")
+                        };
+                    }
 
-                this.OnTransmissionSent(new TransmissionProcessedEventArgs(acceptedTransmission, exception, responseContent));
+                    this.OnTransmissionSent(new TransmissionProcessedEventArgs(acceptedTransmission, exception, responseContent));
+                }
+            }
+            finally
+            {
+                SdkInternalOperationsMonitor.Exit();
             }
         }
 

src/TelemetryChannels/ServerTelemetryChannel/Shared/ServerTelemetryChannel.cs

@@ -16,7 +16,7 @@
     /// </summary>
     public sealed class ServerTelemetryChannel : ITelemetryChannel, ITelemetryModule
     {
-        internal readonly TelemetrySerializer TelemetrySerializer;
+        internal TelemetrySerializer TelemetrySerializer;
         internal TelemetryBuffer TelemetryBuffer;
         internal Transmitter Transmitter;