AspNetWebStack/src/System.Web.WebPages/Instrumentation/InstrumentationService.cs at master · develop9797/AspNetWebStack · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.IO;

namespace System.Web.WebPages.Instrumentation
{
    public class InstrumentationService
    {
        private static readonly bool _isAvailable = HttpContextAdapter.IsInstrumentationAvailable;
        private bool _localIsAvailable = _isAvailable && PageInstrumentationServiceAdapter.IsEnabled;

        private PageInstrumentationServiceAdapter _instrumentationServiceAdapter;
        private bool _isInstrumentationServiceAdapterInitialized;

        public InstrumentationService()
        {
            ExtractInstrumentationService = GetInstrumentationServiceUncached;
            CreateContext = CreateSystemWebContext;
        }

        public bool IsAvailable
        {
            get { return _localIsAvailable; }
            internal set { _localIsAvailable = value; }
        }

        internal Func<HttpContextBase, PageInstrumentationServiceAdapter> ExtractInstrumentationService { get; set; }
        internal Func<string, TextWriter, int, int, bool, PageExecutionContextAdapter> CreateContext { get; set; }

        public void BeginContext(HttpContextBase context, string virtualPath, TextWriter writer, int startPosition, int length, bool isLiteral)
        {
            if (IsAvailable)
            {
                PageInstrumentationServiceAdapter instrumentationService = GetInstrumentationService(context);
                if (instrumentationService != null && instrumentationService.ExecutionListeners.Count > 0)
                {
                    var instrumentationContext = CreateContext(virtualPath, writer, startPosition, length, isLiteral);
                    foreach (PageExecutionListenerAdapter listener in instrumentationService.ExecutionListeners)
                    {
                        listener.BeginContext(instrumentationContext);
                    }
                }
            }
        }

        public void EndContext(HttpContextBase context, string virtualPath, TextWriter writer, int startPosition, int length, bool isLiteral)
        {
            if (IsAvailable)
            {
                PageInstrumentationServiceAdapter instrumentationService = GetInstrumentationService(context);
                if (instrumentationService != null && instrumentationService.ExecutionListeners.Count > 0)
                {
                    var instrumentationContext = CreateContext(virtualPath, writer, startPosition, length, isLiteral);
                    foreach (PageExecutionListenerAdapter listener in instrumentationService.ExecutionListeners)
                    {
                        listener.EndContext(instrumentationContext);
                    }
                }
            }
        }

        private static PageExecutionContextAdapter CreateSystemWebContext(string virtualPath, TextWriter writer, int startPosition, int length, bool isLiteral)
        {
            return new PageExecutionContextAdapter()
            {
                VirtualPath = virtualPath,
                TextWriter = writer,
                StartPosition = startPosition,
                Length = length,
                IsLiteral = isLiteral
            };
        }

        private PageInstrumentationServiceAdapter GetInstrumentationService(HttpContextBase context)
        {
            // There seems to be the potential for the adapter to be null.
            if (!_isInstrumentationServiceAdapterInitialized)
            {
                _instrumentationServiceAdapter = ExtractInstrumentationService(context);

                _isInstrumentationServiceAdapterInitialized = true;
            }

            return _instrumentationServiceAdapter;
        }

        private PageInstrumentationServiceAdapter GetInstrumentationServiceUncached(HttpContextBase context)
        {
            HttpContextAdapter ctx = new HttpContextAdapter(context);
            return ctx.PageInstrumentation;
        }
    }
}