AspNetWebStack/src/System.Web.Http/Tracing/Tracers/HttpParameterBindingTracer.cs at master · Adroit-Data/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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
// 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.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding;
using System.Web.Http.Properties;
using System.Web.Http.Services;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer to wrap an <see cref="HttpParameterBinding"/>.
    /// Its primary purpose is to monitor <see cref="ExecuteBindingAsync"/>.
    /// </summary>
    internal class HttpParameterBindingTracer : HttpParameterBinding, IValueProviderParameterBinding, IDecorator<HttpParameterBinding>
    {
        private const string ExecuteBindingAsyncMethodName = "ExecuteBindingAsync";

        public HttpParameterBindingTracer(HttpParameterBinding innerBinding, ITraceWriter traceWriter) : base(innerBinding.Descriptor)
        {
            Contract.Assert(innerBinding != null);
            Contract.Assert(traceWriter != null);

            InnerBinding = innerBinding;
            TraceWriter = traceWriter;
        }

        public HttpParameterBinding Inner
        {
            get { return InnerBinding; }
        }

        protected HttpParameterBinding InnerBinding { get; private set; }

        protected ITraceWriter TraceWriter { get; private set; }

        public override string ErrorMessage
        {
            get
            {
                return InnerBinding.ErrorMessage;
            }
        }

        public override bool WillReadBody
        {
            get
            {
                return InnerBinding.WillReadBody;
            }
        }

        public IEnumerable<ValueProviderFactory> ValueProviderFactories
        {
            get
            {
                IValueProviderParameterBinding valueProviderParameterBinding = InnerBinding as IValueProviderParameterBinding;
                return valueProviderParameterBinding != null ? valueProviderParameterBinding.ValueProviderFactories : Enumerable.Empty<ValueProviderFactory>();
            }
        }

        public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            return TraceWriter.TraceBeginEndAsync(
                actionContext.Request,
                TraceCategories.ModelBindingCategory,
                TraceLevel.Info,
                InnerBinding.GetType().Name,
                ExecuteBindingAsyncMethodName,
                beginTrace: (tr) =>
                {
                    tr.Message = Error.Format(SRResources.TraceBeginParameterBind,
                                              InnerBinding.Descriptor.ParameterName);
                },

                execute: () => InnerBinding.ExecuteBindingAsync(metadataProvider, actionContext, cancellationToken),

                endTrace: (tr) =>
                {
                    string parameterName = InnerBinding.Descriptor.ParameterName;

                    // Model binding error for this parameter shows the error
                    if (!actionContext.ModelState.IsValid && actionContext.ModelState.ContainsKey(parameterName))
                    {
                        tr.Message = Error.Format(SRResources.TraceModelStateInvalidMessage,
                                                  FormattingUtilities.ModelStateToString(
                                                       actionContext.ModelState));
                    }
                    else
                    {
                        tr.Message = actionContext.ActionArguments.ContainsKey(parameterName)
                                         ? Error.Format(SRResources.TraceEndParameterBind, parameterName,
                                                        FormattingUtilities.ValueToString(
                                                             actionContext.ActionArguments[parameterName],
                                                             CultureInfo.CurrentCulture))
                                         : Error.Format(SRResources.TraceEndParameterBindNoBind,
                                                        parameterName);
                    }
                },
                errorTrace: null);
        }
    }
}