/// <summary>
        /// Implements initialization logic.
        /// </summary>
        /// <param name="platformContext">Http context.</param>
        /// <param name="requestTelemetry">Request telemetry object associated with the current request.</param>
        /// <param name="telemetry">Telemetry item to initialize.</param>
        protected override void OnInitializeTelemetry(HttpContext platformContext, RequestTelemetry requestTelemetry, ITelemetry telemetry)
        {
            if (string.IsNullOrEmpty(telemetry.Context.Operation.SyntheticSource))
            {
                if (platformContext != null)
                {
                    var request = platformContext.GetRequest();

                    if (request != null && !string.IsNullOrEmpty(request.UserAgent))
                    {
                        // We expect customers to configure telemetry initializer before they add it to active configuration
                        // So we will not protect fiterPatterns array with locks (to improve perf)
                        foreach (string pattern in this.filterPatterns)
                        {
                            if (!string.IsNullOrWhiteSpace(pattern) &&
                                request.UserAgent.IndexOf(pattern, StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                telemetry.Context.Operation.SyntheticSource = "Bot";
                                return;
                            }
                        }
                    }
                }
            }
        }

 /// <summary>
 /// Initializes the given <see cref="Microsoft.ApplicationInsights.Channel.ITelemetry"/>.
 /// </summary>
 public void Initialize(ITelemetry telemetry)
 {
     if (String.IsNullOrWhiteSpace(telemetry.Context.Component.Version))
     {
         telemetry.Context.Component.Version = _applicationVersion.Value;
     }
 }

 /// <summary>
 /// Sets <see cref="ITelemetry.Timestamp"/> to <see cref="DateTimeOffset.Now"/>.
 /// </summary>
 public void Initialize(ITelemetry telemetry)
 {
     if (telemetry.Timestamp == default(DateTimeOffset))
     {
         telemetry.Timestamp = Clock.Instance.Time;
     }
 }

        /// <summary>
        /// Initializes/Adds operation id to the existing telemetry item.
        /// </summary>
        /// <param name="telemetryItem">Target telemetry item to add operation id.</param>
        public void Initialize(ITelemetry telemetryItem)
        {
            var itemContext = telemetryItem.Context.Operation;

            if (string.IsNullOrEmpty(itemContext.ParentId) || string.IsNullOrEmpty(itemContext.Id) || string.IsNullOrEmpty(itemContext.Name))
            {
                var parentContext = AsyncLocalHelpers.GetCurrentOperationContext();
                if (parentContext != null)
                {
                    if (string.IsNullOrEmpty(itemContext.ParentId)
                        && !string.IsNullOrEmpty(parentContext.ParentOperationId))
                    {
                        itemContext.ParentId = parentContext.ParentOperationId;
                    }

                    if (string.IsNullOrEmpty(itemContext.Id)
                        && !string.IsNullOrEmpty(parentContext.RootOperationId))
                    {
                        itemContext.Id = parentContext.RootOperationId;
                    }

                    if (string.IsNullOrEmpty(itemContext.Name)
                        && !string.IsNullOrEmpty(parentContext.RootOperationName))
                    {
                        itemContext.Name = parentContext.RootOperationName;
                    }
                }
            }
        }

        /// <summary>
        /// Process a collected telemetry item.
        /// </summary>
        /// <param name="item">A collected Telemetry item.</param>
        public void Process(ITelemetry item)
        {
            if (this.SamplingPercentage < 100.0 - 1.0E-12)
            {
                // set sampling percentage on telemetry item, current codebase assumes it is the only one updating SamplingPercentage.
                var samplingSupportingTelemetry = item as ISupportSampling;

                if (samplingSupportingTelemetry != null)
                {
                    samplingSupportingTelemetry.SamplingPercentage = this.SamplingPercentage;
                }

                if (!this.IsSampledIn(item))
                {
                    if (TelemetryChannelEventSource.Log.IsVerboseEnabled)
                    {
                        TelemetryChannelEventSource.Log.ItemSampledOut(item.ToString());
                    }

                    return;
                }
            }

            this.Next.Process(item);
        }

 protected override void OnInitializeTelemetry(HttpContext platformContext, RequestTelemetry requestTelemetry, ITelemetry telemetry)
 {
     if (string.IsNullOrEmpty(telemetry.Context.Operation.Id))
     {
         telemetry.Context.Operation.Id = requestTelemetry.Id;
     }
 }

 public void Initialize(ITelemetry telemetry)
 {
     if (HttpContext.Current == null) return;
     var requestId = HttpContext.Current.Items[Constants.RequestIdKey];
     if (requestId == null || !string.IsNullOrEmpty(telemetry.Context.Operation.Id)) return;
     telemetry.Context.Operation.Id = requestId as string;
 }

        public void Initialize(ITelemetry telemetry)
        {
            try
            {
                var context = this.httpContextAccessor.HttpContext;

                if (context == null)
                {
                    //TODO: Diagnostics!
                    return;
                }

                if (context.RequestServices == null)
                {
                    //TODO: Diagnostics!
                    return;
                }

                var request = context.RequestServices.GetService<RequestTelemetry>();

                if (request == null)
                {
                    //TODO: Diagnostics!
                    return;
                }

                this.OnInitializeTelemetry(context, request, telemetry);
            }
            catch (Exception exp)
            {
                //TODO: Diagnostics!
                Debug.WriteLine(exp);
            }
        }

        /// <summary>
        /// Base implementation of the initialization method.
        /// </summary>
        /// <param name="telemetry">Telemetry item to initialize.</param>
        public void Initialize(ITelemetry telemetry)
        {
            try
            {
                var platformContext = this.ResolvePlatformContext();

                if (platformContext == null)
                {
                    WebEventSource.Log.WebTelemetryInitializerNotExecutedOnNullHttpContext();
                    return;
                }

                if (platformContext.GetRequest() == null)
                {
                    return;
                }

                var requestTelemetry = platformContext.ReadOrCreateRequestTelemetryPrivate();
                this.OnInitializeTelemetry(platformContext, requestTelemetry, telemetry);
            }
            catch (Exception exc)
            {
                WebEventSource.Log.WebTelemetryInitializerFailure(
                    this.GetType().FullName,
                    exc.ToInvariantString());
            }
        }

 /// <summary>
 /// Populates <see cref="ITelemetry.Sequence"/> with unique ID and sequential number.
 /// </summary>
 public void Initialize(ITelemetry telemetry)
 {
     if (string.IsNullOrEmpty(telemetry.Sequence))
     {
         telemetry.Sequence = this.stablePrefix + Interlocked.Increment(ref this.currentNumber);
     }
 }

 /// <summary>
 /// Initializes the given <see cref="Microsoft.ApplicationInsights.Channel.ITelemetry"/>.
 /// </summary>
 /// <param name="telemetry"></param>
 public void Initialize(ITelemetry telemetry)
 {
     if (String.IsNullOrWhiteSpace(telemetry.Context.Session.Id))
     {
         telemetry.Context.Session.Id = _sessionId.Value;
     }
 }

 public void Send(ITelemetry item)
 {
     lock ( lockobj )
     {
         items.Add(item);
     }
 }

 /// <summary>
 /// Initializes the given <see cref="Microsoft.ApplicationInsights.Channel.ITelemetry"/>.
 /// </summary>
 public void Initialize(ITelemetry telemetry)
 {
     if (String.IsNullOrWhiteSpace(telemetry.Context.Device.OperatingSystem))
     {
         telemetry.Context.Device.OperatingSystem = _osVersion.Value;
     }
 }

 public Car(ITelemetry telemetry, int carIdx)
 {
     this.telemetry = telemetry;
     this.carIdx = carIdx;
     this.driver = telemetry.SessionData.DriverInfo.CompetingDrivers[carIdx];
     this.Details = new CarDetails(telemetry, carIdx);
 }

        public void Initialize(ITelemetry telemetry)
        {
            var telemetryWithProperties = telemetry as ISupportProperties;

            if (telemetryWithProperties == null) return;

            // If already set, nothing to do.
            if (telemetryWithProperties.Properties.ContainsKey(Constants.ShellNameKey)) return;

            // Below algorithm copied from OrchardLog4netLogger.
            var ctx = HttpContext.Current;
            if (ctx == null)
                return;

            var runningShellTable = HostContainer.Resolve<IRunningShellTable>();
            if (runningShellTable == null)
                return;

            var shellSettings = runningShellTable.Match(new HttpContextWrapper(ctx));
            if (shellSettings == null)
                return;

            var orchardHost = HostContainer.Resolve<IOrchardHost>();
            if (orchardHost == null)
                return;

            var shellContext = orchardHost.GetShellContext(shellSettings);
            if (shellContext == null || shellContext.Settings == null)
                return;

            telemetryWithProperties.Properties[Constants.ShellNameKey] = shellContext.Settings.Name;
        }

 /// <summary>
 /// Initializes the telemetry.
 /// </summary>
 public void Initialize(ITelemetry telemetry)
 {
     if (telemetry.Context.Cloud.RoleInstance == null)
     {
         telemetry.Context.Cloud.RoleInstance = _hostName.Value;
     }
 }

 public void Initialize(ITelemetry telemetry)
 {
     if (!string.IsNullOrEmpty(this.appVersion))
     {
         telemetry.Context.Component.Version = this.appVersion;
     }
 }

        public void Initialize(ITelemetry telemetry)
        {
            try
            {
                var context = this.httpContextAccessor.HttpContext;

                if (context == null)
                {
                    AspNetCoreEventSource.Instance.LogTelemetryInitializerBaseInitializeContextNull();
                    return;
                }

                if (context.RequestServices == null)
                {
                    AspNetCoreEventSource.Instance.LogTelemetryInitializerBaseInitializeRequestServicesNull();
                    return;
                }

                var request = context.RequestServices.GetService<RequestTelemetry>();

                if (request == null)
                {
                    AspNetCoreEventSource.Instance.LogTelemetryInitializerBaseInitializeRequestNull();
                    return;
                }

                this.OnInitializeTelemetry(context, request, telemetry);
            }
            catch (Exception exp)
            {
                AspNetCoreEventSource.Instance.LogTelemetryInitializerBaseInitializeException(exp.ToString());
                Debug.WriteLine(exp);
            }
        }

        /// <summary>
        /// Implements initialization logic.
        /// </summary>
        /// <param name="platformContext">Http context.</param>
        /// <param name="requestTelemetry">Request telemetry object associated with the current request.</param>
        /// <param name="telemetry">Telemetry item to initialize.</param>
        protected override void OnInitializeTelemetry(HttpContext platformContext, RequestTelemetry requestTelemetry, ITelemetry telemetry)
        {
            if (platformContext != null)
            {
                var request = platformContext.GetRequest();

                if (request != null)
                {
                    foreach (var pattern in this.filterPatterns)
                    {
                        if (pattern.RegularExpression != null && request.UserAgent != null)
                        {
                            var match = pattern.RegularExpression.Match(request.UserAgent);
                            if (match.Success)
                            {
                                if (string.IsNullOrEmpty(telemetry.Context.Operation.SyntheticSource))
                                {
                                    telemetry.Context.Operation.SyntheticSource = !string.IsNullOrWhiteSpace(pattern.SourceName) ? pattern.SourceName : match.Value;
                                    return;
                                }
                            }
                        }
                    }
                }
            }
        }

        public void Send(ITelemetry item)
        {
            var timer = TimerStrategy();

            if (timer == null || MessageBroker == null)
            {
                return;
            }

            if (item is DependencyTelemetry)
            {
                var dependency = item as DependencyTelemetry;
                var timelineMessage = new DependencyTelemetryTimelineMessage(dependency);
                timelineMessage.Offset = timer.Point().Offset.Subtract(dependency.Duration);
                MessageBroker.Publish(timelineMessage);
            }

            if (item is TraceTelemetry)
            {
                TraceTelemetry t = new TraceTelemetry();

                var model = new TraceMessage
                {
                    Category = "Application Insights",
                    Message = t.SeverityLevel == null ? t.Message : t.SeverityLevel + ": " + t.Message,
                    FromFirst = timer.Point().Offset,
                    FromLast = CalculateFromLast(timer),
                    IndentLevel = 0
                };

                MessageBroker.Publish(model);
            }

            messageBroker.Publish(item);
        }