public void CanSetEnvelopeNameForSupportedTypes()
        {
            string testEnvelopeName = "Non_Standard*Envelope.Name";

            var at   = new AvailabilityTelemetry();
            var dt   = new DependencyTelemetry();
            var et   = new EventTelemetry();
            var ext  = new ExceptionTelemetry();
            var mt   = new MetricTelemetry();
            var pvpt = new PageViewPerformanceTelemetry();
            var pvt  = new PageViewTelemetry();
            var rt   = new RequestTelemetry();

#pragma warning disable CS0618 // Type or member is obsolete
            var pct = new PerformanceCounterTelemetry();
            var sst = new SessionStateTelemetry();
#pragma warning restore CS0618 // Type or member is obsolete

            Assert.IsTrue(at.TrySetEnvelopeName(testEnvelopeName));
            Assert.IsTrue(dt.TrySetEnvelopeName(testEnvelopeName));
            Assert.IsTrue(et.TrySetEnvelopeName(testEnvelopeName));
            Assert.IsTrue(ext.TrySetEnvelopeName(testEnvelopeName));
            Assert.IsTrue(mt.TrySetEnvelopeName(testEnvelopeName));
            Assert.IsTrue(pvpt.TrySetEnvelopeName(testEnvelopeName));
            Assert.IsTrue(pvt.TrySetEnvelopeName(testEnvelopeName));
            Assert.IsTrue(rt.TrySetEnvelopeName(testEnvelopeName));
            Assert.IsTrue(pct.TrySetEnvelopeName(testEnvelopeName));
            Assert.IsTrue(sst.TrySetEnvelopeName(testEnvelopeName));

            Assert.AreEqual(testEnvelopeName, at.GetEnvelopeName());
            Assert.AreEqual(testEnvelopeName, dt.GetEnvelopeName());
            Assert.AreEqual(testEnvelopeName, et.GetEnvelopeName());
            Assert.AreEqual(testEnvelopeName, ext.GetEnvelopeName());
            Assert.AreEqual(testEnvelopeName, mt.GetEnvelopeName());
            Assert.AreEqual(testEnvelopeName, pvpt.GetEnvelopeName());
            Assert.AreEqual(testEnvelopeName, pvt.GetEnvelopeName());
            Assert.AreEqual(testEnvelopeName, rt.GetEnvelopeName());
            Assert.AreEqual(testEnvelopeName, pct.Data.GetEnvelopeName());
            Assert.AreEqual(testEnvelopeName, sst.Data.GetEnvelopeName());
        }
Example #2
0
        private bool LogPerfEvent(PSQoSEvent qos)
        {
            bool sent = false;

            if (qos != null)
            {
                foreach (TelemetryClient client in TelemetryClients)
                {
                    var perf = new PageViewPerformanceTelemetry(qos.Name)
                    {
                        Id            = qos.Id,
                        DomProcessing = qos.ProcessingTime,
                        PerfTotal     = qos.ProcessingTime,
                        Timestamp     = qos.StartTime
                    };
                    LoadTelemetryClientContext(qos, perf.Context);
                    PopulatePropertiesFromQos(qos, perf.Properties);

                    client.Track(perf);
                    sent = true;
                }
            }
            return(sent);
        }
Example #3
0
        private static void SerializeTelemetryItem(ITelemetry telemetryItem, JsonSerializationWriter jsonSerializationWriter)
        {
            jsonSerializationWriter.WriteStartObject();

            if (telemetryItem is EventTelemetry)
            {
                EventTelemetry eventTelemetry = telemetryItem as EventTelemetry;
                Utils.CopyDictionary(telemetryItem.Context.GlobalProperties, eventTelemetry.Data.properties);

                SerializeHelper(telemetryItem, jsonSerializationWriter, eventTelemetry.BaseType, EventTelemetry.TelemetryName);
            }
            else if (telemetryItem is ExceptionTelemetry)
            {
                ExceptionTelemetry exTelemetry = telemetryItem as ExceptionTelemetry;
                Utils.CopyDictionary(telemetryItem.Context.GlobalProperties, exTelemetry.Data.Data.properties);

                SerializeHelper(telemetryItem, jsonSerializationWriter, exTelemetry.BaseType, ExceptionTelemetry.TelemetryName);
            }
            else if (telemetryItem is MetricTelemetry)
            {
                MetricTelemetry mTelemetry = telemetryItem as MetricTelemetry;
                Utils.CopyDictionary(telemetryItem.Context.GlobalProperties, mTelemetry.Data.properties);

                SerializeHelper(telemetryItem, jsonSerializationWriter, mTelemetry.BaseType, MetricTelemetry.TelemetryName);
            }
            else if (telemetryItem is PageViewTelemetry)
            {
                PageViewTelemetry pvTelemetry = telemetryItem as PageViewTelemetry;
                Utils.CopyDictionary(telemetryItem.Context.GlobalProperties, pvTelemetry.Data.properties);

                SerializeHelper(telemetryItem, jsonSerializationWriter, pvTelemetry.BaseType, PageViewTelemetry.TelemetryName);
            }
            else if (telemetryItem is PageViewPerformanceTelemetry)
            {
                PageViewPerformanceTelemetry pvptelemetry = telemetryItem as PageViewPerformanceTelemetry;
                Utils.CopyDictionary(telemetryItem.Context.GlobalProperties, pvptelemetry.Data.properties);

                SerializeHelper(telemetryItem, jsonSerializationWriter, PageViewPerformanceTelemetry.BaseType, PageViewPerformanceTelemetry.TelemetryName);
            }
            else if (telemetryItem is DependencyTelemetry)
            {
                DependencyTelemetry depTelemetry = telemetryItem as DependencyTelemetry;
                Utils.CopyDictionary(telemetryItem.Context.GlobalProperties, depTelemetry.InternalData.properties);

                SerializeHelper(telemetryItem, jsonSerializationWriter, depTelemetry.BaseType, DependencyTelemetry.TelemetryName);
            }
            else if (telemetryItem is RequestTelemetry)
            {
                RequestTelemetry reqTelemetry = telemetryItem as RequestTelemetry;
                Utils.CopyDictionary(telemetryItem.Context.GlobalProperties, reqTelemetry.Data.properties);

                SerializeHelper(telemetryItem, jsonSerializationWriter, reqTelemetry.BaseType, RequestTelemetry.TelemetryName);
            }
#pragma warning disable 618
            else if (telemetryItem is PerformanceCounterTelemetry)
            {
                PerformanceCounterTelemetry pcTelemetry = telemetryItem as PerformanceCounterTelemetry;
                Utils.CopyDictionary(telemetryItem.Context.GlobalProperties, pcTelemetry.Properties);

                SerializeHelper(telemetryItem, jsonSerializationWriter, pcTelemetry.Data.BaseType, MetricTelemetry.TelemetryName);
            }
            else if (telemetryItem is SessionStateTelemetry)
            {
                SessionStateTelemetry ssTelemetry = telemetryItem as SessionStateTelemetry;
                SerializeHelper(telemetryItem, jsonSerializationWriter, ssTelemetry.Data.BaseType, EventTelemetry.TelemetryName);
            }
#pragma warning restore 618
            else if (telemetryItem is TraceTelemetry)
            {
                TraceTelemetry traceTelemetry = telemetryItem as TraceTelemetry;
                Utils.CopyDictionary(telemetryItem.Context.GlobalProperties, traceTelemetry.Data.properties);

                SerializeHelper(telemetryItem, jsonSerializationWriter, traceTelemetry.BaseType, TraceTelemetry.TelemetryName);
            }
            else if (telemetryItem is AvailabilityTelemetry)
            {
                AvailabilityTelemetry availabilityTelemetry = telemetryItem as AvailabilityTelemetry;
                Utils.CopyDictionary(telemetryItem.Context.GlobalProperties, availabilityTelemetry.Data.properties);

                SerializeHelper(telemetryItem, jsonSerializationWriter, availabilityTelemetry.BaseType, AvailabilityTelemetry.TelemetryName);
            }
            else
            {
                string msg = string.Format(CultureInfo.InvariantCulture, "Unknown telemetry type: {0}", telemetryItem.GetType());
                CoreEventSource.Log.LogVerbose(msg);
            }

            jsonSerializationWriter.WriteEndObject();
        }
Example #4
0
 public Task TrackPageViewPerformance(PageViewPerformanceTelemetry pageViewPerformance)
 {
     return(Task.CompletedTask);
 }