//------------------------------------------------------------------------------
// <copyright file="TraceContext.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

/*
 * The context for outputting trace information in the page.
 *
 * Copyright (c) 1999 Microsoft Corporation
 */
namespace System.Web {
    using System;
// 
    using System.Web.UI;
    using System.Web.Handlers;
    using System.Web.Util;
    using System.Web.SessionState;
    using System.Text;
    using System.Data;
    using System.Globalization;
    using System.Collections;
    using System.Collections.Specialized;
    using System.Diagnostics;
    using System.Security.Permissions;
    using System.Web.Configuration;
    using System.Threading;
    using System.ComponentModel;

    /// <devdoc>
    ///    <para>Captures and presents execution details about a Web request.</para>
    ///    <para>Use the TraceContext
    ///       class by appending trace messages to specific trace categories. For example, a
    ///       calendar class might append the message ?Calendar1-&gt;Starting
    ///       To Render? within the Render category, and append the message ?Calendar1-&gt;Firing OnChange Event? within
    ///       the Events category. Tracing is enabled by setting the <see topic='cpdirSystem.Web.UI.PageDirectives'/>
    ///       Trace attribute or the System.Web.UI.TraceContext.IsEnabled
    ///       property.</para>
    ///    <para>When tracing is enabled, In addition to showing
    ///       user-provided trace content, the <see cref='System.Web.UI.Page'/> class not only shows user-provided trace content, it automatically includes
    ///       performance data, tree-structure information, and state management content.</para>
    /// </devdoc>

    public sealed
        class TraceContext {

        private static DataSet  _masterRequest;
        private static bool     _writeToDiagnosticsTrace = false;
        private static readonly object EventTraceFinished = new object();
        private EventHandlerList _events = new EventHandlerList();

        private TraceMode       _traceMode;
        private TraceEnable     _isEnabled;
        private HttpContext     _context;
        private DataSet         _requestData;
        private long            _firstTime;
        private long            _lastTime;
        private int             _uniqueIdCounter = 0;
        private const string PAGEKEYNAME = "__PAGE";
        private const string NULLSTRING = "<null>"; // this will get HtmlEncoded later...
        private const string NULLIDPREFIX = "__UnassignedID";
        private ArrayList       _traceRecords;

        private bool            _endDataCollected;
        private bool            _writing = false;

        /// <devdoc>
        /// <para>Initializes a new instance of the <see cref='System.Web.TraceContext'/> class.</para>
        /// </devdoc>
        public TraceContext(HttpContext context) {
            _traceMode = TraceMode.Default;
            // Always disable trace in retail deployment mode (DevDiv 36396)
            _isEnabled = DeploymentSection.RetailInternal ? TraceEnable.Disable : TraceEnable.Default;
            _context = context;
            _firstTime = -1;
            _lastTime = -1;
            _endDataCollected = false;
            _traceRecords = new ArrayList();
        }

        /// <devdoc>
        ///    <para>Indicates the order in which trace messages should be
        ///       output to a requesting browser. Trace messages can be sorted in the order they
        ///       were processed, or alphabetically by user-defined category.</para>
        /// </devdoc>
        public TraceMode TraceMode {
            get {
                if (_traceMode == TraceMode.Default)
                    return HttpRuntime.Profile.OutputMode;

                return _traceMode;
            }
            set {
                if (value < TraceMode.SortByTime || value > TraceMode.Default) {
                    throw new ArgumentOutOfRangeException("value");
                }
                _traceMode = value;

                if (IsEnabled)
                    ApplyTraceMode();
            }
        }

        /// <devdoc>
        ///    <para>Indicates whether tracing is enabled for the current Web request.
        ///       Use this flag to check whether you should output tracing information before
        ///       writing anything to the trace log.</para>
        /// </devdoc>
        public bool IsEnabled {
            get {
                if (_isEnabled == TraceEnable.Default)
                    return HttpRuntime.Profile.IsEnabled;
                else {
                    return (_isEnabled == TraceEnable.Enable) ? true : false;
                }
            }
            set {
                // Always disable trace in retail deployment mode (DevDiv 36396)
                if (DeploymentSection.RetailInternal) {
                    System.Web.Util.Debug.Assert(_isEnabled == TraceEnable.Disable);
                    return;
                }

                if (value)
                    _isEnabled = TraceEnable.Enable;
                else
                    _isEnabled = TraceEnable.Disable;
            }
        }


        /// <devdoc>
        ///    <para>Indicates whether trace information should be output to a Web Forms
        ///       page. This property is used only in application-level tracing situations. You
        ///       can set this property in your application's config.web configuration file which
        ///       resides in the root directory of the application. </para>
        /// </devdoc>
        internal bool PageOutput {
            get {
                if (_isEnabled == TraceEnable.Default)
                    return HttpRuntime.Profile.PageOutput;
                else {
                    return (_isEnabled == TraceEnable.Enable) ? true : false;
                }

            }
        }

        // this is used only for error pages, called from Page.HandleError.
        internal int StatusCode {
            set {
                VerifyStart();
                DataRow row = _requestData.Tables[SR.Trace_Request].Rows[0];
                row[SR.Trace_Status_Code] = value;
            }
        }


        /// <devdoc>
        ///     Raised after the trace has been finished
        /// </devdoc>
        public event TraceContextEventHandler TraceFinished {
            add {
                _events.AddHandler(EventTraceFinished, value);
            }
            remove {
                _events.RemoveHandler(EventTraceFinished, value);
            }
        }

        private void ApplyTraceMode() {
            VerifyStart();
            if (TraceMode == TraceMode.SortByCategory)
                _requestData.Tables[SR.Trace_Trace_Information].DefaultView.Sort = SR.Trace_Category;
            else
                _requestData.Tables[SR.Trace_Trace_Information].DefaultView.Sort = SR.Trace_From_First;
        }


        internal void CopySettingsTo(TraceContext tc) {
            tc._traceMode = this._traceMode;
            tc._isEnabled = this._isEnabled;
        }

        internal void OnTraceFinished(TraceContextEventArgs e) {
            TraceContextEventHandler handler = (TraceContextEventHandler)_events[EventTraceFinished];
            if (handler != null) {
                handler(this, e);
            }
        }

        internal static void SetWriteToDiagnosticsTrace(bool value) {
            _writeToDiagnosticsTrace = value;
        }


        /// <devdoc>
        ///    <para>Writes trace information to the trace log including any
        ///       user defined categories and trace messages.</para>
        /// </devdoc>
        public void Write(string message) {
            Write(String.Empty, message, null, false, _writeToDiagnosticsTrace);
        }


        /// <devdoc>
        ///    <para>Writes trace information to the trace log including any
        ///       user defined categories and trace messages.</para>
        /// </devdoc>
        public void Write(string category, string message) {
            Write(category, message, null, false, _writeToDiagnosticsTrace);
        }


        /// <devdoc>
        ///    <para>Writes trace information to the trace log including any user defined
        ///       categories,trace messages and error information.</para>
        /// </devdoc>
        public void Write(string category, string message, Exception errorInfo) {
            Write(category, message, errorInfo, false, _writeToDiagnosticsTrace);
        }

        internal void WriteInternal(string message, bool writeToDiagnostics) {
            Write(String.Empty, message, null, false, writeToDiagnostics);
        }


        internal void WriteInternal(string category, string message, bool writeToDiagnostics) {
            Write(category, message, null, false, writeToDiagnostics);
        }


        /// <devdoc>
        ///    <para>Writes trace information to the trace log including any
        ///       user defined categories and trace messages. All warnings appear as red text.</para>
        /// </devdoc>
        public void Warn(string message) {
            Write(String.Empty, message, null, true, _writeToDiagnosticsTrace);
        }


        /// <devdoc>
        ///    <para>Writes trace information to the trace log including any
        ///       user defined categories and trace messages. All warnings appear as red text.</para>
        /// </devdoc>
        public void Warn(string category, string message) {
            Write(category, message, null, true, _writeToDiagnosticsTrace);
        }


        /// <devdoc>
        ///    <para>Writes trace information to the trace log including any user defined categories,trace messages and error information. All
        ///       warnings appear as red text. </para>
        /// </devdoc>
        public void Warn(string category, string message, Exception errorInfo) {
            Write(category, message, errorInfo, true, _writeToDiagnosticsTrace);
        }


        internal void WarnInternal(string category, string message, bool writeToDiagnostics) {
            Write(category, message, null, true, writeToDiagnostics);
        }

        void Write(string category, string message, Exception errorInfo, bool isWarning, bool writeToDiagnostics) {
            // Guard against
            lock(this) {
                // Bail if trace isn't enabled or this is from our call to System.Diagonostics.Trace below
                if (!IsEnabled || _writing || _endDataCollected)
                    return;

                VerifyStart();

                if (category == null)
                    category = String.Empty;

                if (message == null)
                    message = String.Empty;

                long messagetime = Counter.Value;

                DataRow row = NewRow(_requestData, SR.Trace_Trace_Information);
                row[SR.Trace_Category] = category;
                row[SR.Trace_Message] = message;
                row[SR.Trace_Warning] = isWarning ? "yes" : "no";
                if (errorInfo != null) {
                    row["ErrorInfoMessage"] = errorInfo.Message;
                    row["ErrorInfoStack"] = errorInfo.StackTrace;
                }

                if (_firstTime != -1) {
                    row[SR.Trace_From_First] = (((double)(messagetime - _firstTime)) / Counter.Frequency);
                }
                else
                    _firstTime = messagetime;

                if (_lastTime != -1) {
                    row[SR.Trace_From_Last] = (((double)(messagetime - _lastTime)) / Counter.Frequency);
                }
                _lastTime = messagetime;
                AddRow(_requestData, SR.Trace_Trace_Information, row);

                string msg = message;
                if (errorInfo != null) {
                    string eMsg = errorInfo.Message;
                    if (eMsg == null) eMsg = String.Empty;
                    string eTrace = errorInfo.StackTrace;
                    if (eTrace == null) eTrace = String.Empty;
                    StringBuilder str = new StringBuilder(message.Length + eMsg.Length + eTrace.Length);
                    str.Append(message);
                    str.Append(" -- ");
                    str.Append(eMsg);
                    str.Append(": ");
                    str.Append(eTrace);
                    msg = str.ToString();
                }

                if (writeToDiagnostics) {
                    _writing = true;
                    System.Diagnostics.Trace.WriteLine(msg, category);
                    _writing = false;
                }

                // Send to IIS tracing
                if (_context != null && _context.WorkerRequest != null) {
                    _context.WorkerRequest.RaiseTraceEvent(isWarning ? IntegratedTraceType.TraceWarn : IntegratedTraceType.TraceWrite, msg);
                }
                
            }

            // Add the trace record to our collection
            _traceRecords.Add(new TraceContextRecord(category, message, isWarning, errorInfo));
        }

        internal void AddNewControl(string id, string parentId, string type, int viewStateSize, int controlStateSize) {
            VerifyStart();

            DataRow row = NewRow(_requestData, SR.Trace_Control_Tree);

            if (id == null)
                id = NULLIDPREFIX+(_uniqueIdCounter++);
            row[SR.Trace_Control_Id] = id;

            if (parentId == null)
                parentId = PAGEKEYNAME;
            row[SR.Trace_Parent_Id] = parentId;

            row[SR.Trace_Type] = type;
            row[SR.Trace_Viewstate_Size] = viewStateSize;
            row[SR.Trace_Controlstate_Size] = controlStateSize;
            row[SR.Trace_Render_Size] = 0;
            try {
                AddRow(_requestData, SR.Trace_Control_Tree, row);
            }
            catch (ConstraintException) {
                throw new HttpException(SR.GetString(SR.Duplicate_id_used, id, "Trace"));
            }

        }

        /*
         *   Add the render size to the control
         */
        internal void AddControlSize(String controlId, int renderSize) {
            VerifyStart();

            DataTable dt = _requestData.Tables[SR.Trace_Control_Tree];

            // find the row for this control
            if (controlId == null)
                controlId = PAGEKEYNAME;
            DataRow row = dt.Rows.Find((object) controlId);
            // if the row is null, we couldn't find it, so we'll just skip this control
            if (row != null)
                row[SR.Trace_Render_Size] = renderSize;
        }

        internal void AddControlStateSize(String controlId, int viewstateSize, int controlstateSize) {
            VerifyStart();

            DataTable dt = _requestData.Tables[SR.Trace_Control_Tree];

            // find the row for this control
            if (controlId == null)
                controlId = PAGEKEYNAME;
            DataRow row = dt.Rows.Find((object) controlId);
            // if the row is null, we couldn't find it, so we'll just skip this control
            if (row != null) {
                row[SR.Trace_Viewstate_Size] = viewstateSize;
                row[SR.Trace_Controlstate_Size] = controlstateSize;
            }
        }


        internal void Render(HtmlTextWriter output) {
            if (PageOutput && _requestData != null) {

                TraceEnable oldEnabled = _isEnabled;

                _isEnabled = TraceEnable.Disable;

                Control table;

                output.Write("<div id=\"__asptrace\">\r\n");
                output.Write(TraceHandler.StyleSheet);
                output.Write("<span class=\"tracecontent\">\r\n");

                table = TraceHandler.CreateDetailsTable(_requestData.Tables[SR.Trace_Request]);
                if (table != null)
                    table.RenderControl(output);

                table = TraceHandler.CreateTraceTable(_requestData.Tables[SR.Trace_Trace_Information]);
                if (table != null)
                    table.RenderControl(output);

                table = TraceHandler.CreateControlTable(_requestData.Tables[SR.Trace_Control_Tree]);
                if (table != null)
                    table.RenderControl(output);

                table = TraceHandler.CreateTable(_requestData.Tables[SR.Trace_Session_State], true /*encodeSpaces*/);
                if (table != null)
                    table.RenderControl(output);

                table = TraceHandler.CreateTable(_requestData.Tables[SR.Trace_Application_State], true /*encodeSpaces*/);
                if (table != null)
                    table.RenderControl(output);

                table = TraceHandler.CreateTable(_requestData.Tables[SR.Trace_Request_Cookies_Collection], true /*encodeSpaces*/);
                if (table != null)
                    table.RenderControl(output);

                table = TraceHandler.CreateTable(_requestData.Tables[SR.Trace_Response_Cookies_Collection], true /*encodeSpaces*/);
                if (table != null)
                    table.RenderControl(output);

                table = TraceHandler.CreateTable(_requestData.Tables[SR.Trace_Headers_Collection], true /*encodeSpaces*/);
                if (table != null)
                    table.RenderControl(output);

                table = TraceHandler.CreateTable(_requestData.Tables[SR.Trace_Response_Headers_Collection], true /*encodeSpaces*/);
                if (table != null)
                    table.RenderControl(output);

                table = TraceHandler.CreateTable(_requestData.Tables[SR.Trace_Form_Collection]);
                if (table != null)
                    table.RenderControl(output);

                table = TraceHandler.CreateTable(_requestData.Tables[SR.Trace_Querystring_Collection]);
                if (table != null)
                    table.RenderControl(output);

                table = TraceHandler.CreateTable(_requestData.Tables[SR.Trace_Server_Variables], true /*encodeSpaces*/);
                if (table != null)
                    table.RenderControl(output);

                output.Write("<hr width=100% size=1 color=silver>\r\n\r\n");
                output.Write(SR.GetString(SR.Error_Formatter_CLR_Build) + VersionInfo.ClrVersion +
                             SR.GetString(SR.Error_Formatter_ASPNET_Build) + VersionInfo.EngineVersion + "\r\n\r\n");
                output.Write("</font>\r\n\r\n");

                output.Write("</span>\r\n</div>\r\n");

                _isEnabled = oldEnabled;
            }
        }

        internal DataSet GetData() {
            return _requestData;
        }

        internal void VerifyStart() {
            // if we have already started, we can skip the lock
            if (_masterRequest == null) {
                // otherwise we need to make sure two
                // requests don't try to call InitMaster at the same time
                lock(this) {
                    if (_masterRequest == null)
                        InitMaster();
                }
            }

            if (_requestData == null) {
                InitRequest();
            }
        }

        internal void StopTracing() {
            _endDataCollected = true;
        }

        /*
         *   Finalize the request
         */
        internal void EndRequest() {
            VerifyStart();

            if (_endDataCollected)
                return;

            // add some more information about the reponse
            DataRow row = _requestData.Tables[SR.Trace_Request].Rows[0];
            row[SR.Trace_Status_Code] = _context.Response.StatusCode;
            row[SR.Trace_Response_Encoding] = _context.Response.ContentEncoding.EncodingName;

            IEnumerator en;
            string temp;
            object obj;
            int i;


            // Application State info
            _context.Application.Lock();
            try {
                en = _context.Application.GetEnumerator();
                while (en.MoveNext()) {
                    row = NewRow(_requestData, SR.Trace_Application_State);
                    temp = (string) en.Current;

                    //the key might be null
                    row[SR.Trace_Application_Key] = (temp != null) ? temp : NULLSTRING;

                    obj = _context.Application[temp];

                    // the value could also be null
                    if (obj != null) {
                        row[SR.Trace_Type] = obj.GetType();
                        row[SR.Trace_Value] = obj.ToString();
                    }
                    else {
                        row[SR.Trace_Type] = NULLSTRING;
                        row[SR.Trace_Value] = NULLSTRING;
                    }

                    AddRow(_requestData, SR.Trace_Application_State, row);
                }
            }
            finally {
                _context.Application.UnLock();
            }

            // request cookie info
            HttpCookieCollection cookieCollection = new HttpCookieCollection();
            _context.Request.FillInCookiesCollection(cookieCollection, false /*includeResponse */);
            HttpCookie[] cookies = new HttpCookie[cookieCollection.Count];
            cookieCollection.CopyTo(cookies, 0);
            for (i = 0; i<cookies.Length; i++) {
                row = NewRow(_requestData, SR.Trace_Request_Cookies_Collection);
                row[SR.Trace_Name] = cookies[i].Name;
                if (cookies[i].Values.HasKeys()) {
                    NameValueCollection subvalues = cookies[i].Values;
                    StringBuilder sb = new StringBuilder();

                    en = subvalues.GetEnumerator();
                    while (en.MoveNext()) {
                        temp = (string) en.Current;
                        sb.Append("(");
                        sb.Append(temp + "=");

                        sb.Append(cookies[i][temp] + ")  ");
                    }
                    row[SR.Trace_Value] = sb.ToString();
                }
                else
                    row[SR.Trace_Value] = cookies[i].Value;

                int size =  (cookies[i].Name  == null) ? 0 : cookies[i].Name.Length;
                size += (cookies[i].Value == null) ? 0 : cookies[i].Value.Length;

                row[SR.Trace_Size] = size + 1; // plus 1 for =
                AddRow(_requestData, SR.Trace_Request_Cookies_Collection, row);
            }

            // response cookie info
            cookies = new HttpCookie[_context.Response.Cookies.Count];
            _context.Response.Cookies.CopyTo(cookies, 0);
            for (i = 0; i<cookies.Length; i++) {
                row = NewRow(_requestData, SR.Trace_Response_Cookies_Collection);
                row[SR.Trace_Name] = cookies[i].Name;
                if (cookies[i].Values.HasKeys()) {
                    NameValueCollection subvalues = cookies[i].Values;
                    StringBuilder sb = new StringBuilder();

                    en = subvalues.GetEnumerator();
                    while (en.MoveNext()) {
                        temp = (string) en.Current;
                        sb.Append("(");
                        sb.Append(temp + "=");

                        sb.Append(cookies[i][temp] + ")  ");
                    }
                    row[SR.Trace_Value] = sb.ToString();
                }
                else
                    row[SR.Trace_Value] = cookies[i].Value;

                int size =  (cookies[i].Name  == null) ? 0 : cookies[i].Name.Length;
                size += (cookies[i].Value == null) ? 0 : cookies[i].Value.Length;

                row[SR.Trace_Size] = size + 1; // plus 1 for =
                AddRow(_requestData, SR.Trace_Response_Cookies_Collection, row);
            }

            HttpSessionState session = _context.Session;
            // session state info
            if (session != null) {
                row = _requestData.Tables[SR.Trace_Request].Rows[0];
                try {
                    row[SR.Trace_Session_Id] = HttpUtility.UrlEncode(session.SessionID);
                }
                catch {
                    // VSWhidbey 527536
                    // Accessing SessionID can cause creation of the session id, this will throw in the
                    // cross page post scenario, as the response has already been flushed when we try
                    // to add the session cookie, since this is just trace output, we can just not set a session ID.
                    // 
                }

                en = session.GetEnumerator();
                while (en.MoveNext()) {
                    row = NewRow(_requestData, SR.Trace_Session_State);

                    temp = (string) en.Current;

                    // the key could be null
                    row[SR.Trace_Session_Key] = (temp != null) ? temp : NULLSTRING;

                    obj = session[temp];

                    // the value could also be null
                    if (obj != null) {
                        row[SR.Trace_Type] = obj.GetType();
                        row[SR.Trace_Value] = obj.ToString();
                    }
                    else {
                        row[SR.Trace_Type] = NULLSTRING;
                        row[SR.Trace_Value] = NULLSTRING;
                    }

                    AddRow(_requestData, SR.Trace_Session_State, row);
                }
            }

            ApplyTraceMode();
            OnTraceFinished(new TraceContextEventArgs(_traceRecords));
        }

        /*  InitMaster
         *  Initialize the _masterRequest dataset with the schema we use
         *  to store profiling information
         */
        private void InitMaster() {
            DataSet tempset = new DataSet();
            tempset.Locale = CultureInfo.InvariantCulture;

            // populate the _masterRequest's schema
            DataTable tab;
            Type strtype = typeof(string);
            Type inttype = typeof(int);
            Type doubletype = typeof(double);

            // request table
            tab = tempset.Tables.Add(SR.Trace_Request);
            tab.Columns.Add(SR.Trace_No, inttype);
            tab.Columns.Add(SR.Trace_Time_of_Request, strtype);
            tab.Columns.Add(SR.Trace_Url, strtype);
            tab.Columns.Add(SR.Trace_Request_Type, strtype);
            tab.Columns.Add(SR.Trace_Status_Code, inttype);
            tab.Columns.Add(SR.Trace_Session_Id, strtype);
            tab.Columns.Add(SR.Trace_Request_Encoding, strtype);
            tab.Columns.Add(SR.Trace_Response_Encoding, strtype);

            // control heirarchy table
            tab = tempset.Tables.Add(SR.Trace_Control_Tree);
            tab.Columns.Add(SR.Trace_Parent_Id, strtype);

            DataColumn[] col = new DataColumn[1];
            col[0] = new DataColumn(SR.Trace_Control_Id, strtype);
            tab.Columns.Add(col[0]);
            tab.PrimaryKey = col;   // set the control id to be the primary key

            tab.Columns.Add(SR.Trace_Type, strtype);
            tab.Columns.Add(SR.Trace_Render_Size, inttype);
            tab.Columns.Add(SR.Trace_Viewstate_Size, inttype);
            tab.Columns.Add(SR.Trace_Controlstate_Size, inttype);

            // session state table
            tab = tempset.Tables.Add(SR.Trace_Session_State);
            tab.Columns.Add(SR.Trace_Session_Key, strtype);
            tab.Columns.Add(SR.Trace_Type, strtype);
            tab.Columns.Add(SR.Trace_Value, strtype);

            // application state table
            tab = tempset.Tables.Add(SR.Trace_Application_State);
            tab.Columns.Add(SR.Trace_Application_Key, strtype);
            tab.Columns.Add(SR.Trace_Type, strtype);
            tab.Columns.Add(SR.Trace_Value, strtype);

            // request cookies table
            tab = tempset.Tables.Add(SR.Trace_Request_Cookies_Collection);
            tab.Columns.Add(SR.Trace_Name, strtype);
            tab.Columns.Add(SR.Trace_Value, strtype);
            tab.Columns.Add(SR.Trace_Size, inttype);

            // resposne cookies table
            tab = tempset.Tables.Add(SR.Trace_Response_Cookies_Collection);
            tab.Columns.Add(SR.Trace_Name, strtype);
            tab.Columns.Add(SR.Trace_Value, strtype);
            tab.Columns.Add(SR.Trace_Size, inttype);

            // header table
            tab = tempset.Tables.Add(SR.Trace_Headers_Collection);
            tab.Columns.Add(SR.Trace_Name, strtype);
            tab.Columns.Add(SR.Trace_Value, strtype);

            // response header table
            tab = tempset.Tables.Add(SR.Trace_Response_Headers_Collection);
            tab.Columns.Add(SR.Trace_Name, strtype);
            tab.Columns.Add(SR.Trace_Value, strtype);

            // form variables table
            tab = tempset.Tables.Add(SR.Trace_Form_Collection);
            tab.Columns.Add(SR.Trace_Name, strtype);
            tab.Columns.Add(SR.Trace_Value, strtype);

            // querystring table
            tab = tempset.Tables.Add(SR.Trace_Querystring_Collection);
            tab.Columns.Add(SR.Trace_Name, strtype);
            tab.Columns.Add(SR.Trace_Value, strtype);

            // trace info
            tab = tempset.Tables.Add(SR.Trace_Trace_Information);
            tab.Columns.Add(SR.Trace_Category, strtype);
            tab.Columns.Add(SR.Trace_Warning, strtype);
            tab.Columns.Add(SR.Trace_Message, strtype);
            tab.Columns.Add(SR.Trace_From_First, doubletype);
            tab.Columns.Add(SR.Trace_From_Last, doubletype);
            tab.Columns.Add("ErrorInfoMessage", strtype);
            tab.Columns.Add("ErrorInfoStack", strtype);

            // server variables
            tab = tempset.Tables.Add(SR.Trace_Server_Variables);
            tab.Columns.Add(SR.Trace_Name, strtype);
            tab.Columns.Add(SR.Trace_Value, strtype);

            _masterRequest = tempset;
        }

        private DataRow NewRow(DataSet ds, string table) {
            return ds.Tables[table].NewRow();
        }

        private void AddRow(DataSet ds, string table, DataRow row) {
            ds.Tables[table].Rows.Add(row);
        }

        /*  InitRequest
         *  Initialize the given dataset with basic
         *  request information
         */
        private void InitRequest() {
            // Master request is assumed to be initialized first
            System.Web.Util.Debug.Assert(_masterRequest != null);

            DataSet requestData = _masterRequest.Clone();

            // request info
            DataRow row = NewRow(requestData, SR.Trace_Request);
            row[SR.Trace_Time_of_Request] = _context.Timestamp.ToString("G");

            string url = _context.Request.RawUrl;
            int loc = url.IndexOf("?", StringComparison.Ordinal);
            if (loc != -1)
                url = url.Substring(0, loc);
            row[SR.Trace_Url] = url;

            row[SR.Trace_Request_Type] = _context.Request.HttpMethod;
            try {
                row[SR.Trace_Request_Encoding] = _context.Request.ContentEncoding.EncodingName;
            }
            catch {
                // if we get an exception getting the ContentEncoding, most likely
                // there's an error in the config file.  Just ignore it so we can finish InitRequest.
            }

            if (TraceMode == TraceMode.SortByCategory)
                requestData.Tables[SR.Trace_Trace_Information].DefaultView.Sort = SR.Trace_Category;
            AddRow(requestData, SR.Trace_Request, row);

            // header info
            try {
                // Bug 867196: Use Request.Unvalidated to ensure request validation will not
                // be triggered when the entries of the collection are accessed.
                AddCollectionToRequestData(requestData, SR.Trace_Headers_Collection, _context.Request.Unvalidated.Headers);
            }
            catch {
                // ---- exceptions when we fail to get the unvalidated collection
            }

            // response header info
            ArrayList headers = _context.Response.GenerateResponseHeaders(false);
            int n = (headers != null) ? headers.Count : 0;
            for (int i = 0; i < n; i++) {
                HttpResponseHeader h = (HttpResponseHeader)headers[i];
                row = NewRow(requestData, SR.Trace_Response_Headers_Collection);
                row[SR.Trace_Name] = h.Name;
                row[SR.Trace_Value] = h.Value;
                AddRow(requestData, SR.Trace_Response_Headers_Collection, row);
            }

            //form info
            try {
                AddCollectionToRequestData(requestData, SR.Trace_Form_Collection, _context.Request.Unvalidated.Form);
            }
            catch {
                // ---- exceptions when we fail to get the unvalidated collection
            }

            //QueryString info
            try {
                AddCollectionToRequestData(requestData, SR.Trace_Querystring_Collection, _context.Request.Unvalidated.QueryString);
            }
            catch {
                // ---- exceptions when we fail to get the unvalidated collection
            }

            //Server Variable info
            if (HttpRuntime.HasAppPathDiscoveryPermission()) {
                AddCollectionToRequestData(requestData, SR.Trace_Server_Variables, _context.Request.ServerVariables);
            }

            _requestData = requestData;

            if (HttpRuntime.UseIntegratedPipeline) {
                // Dev10 914119: When trace is enabled, the request entity is read and no longer
                // available to IIS.  In integrated mode, we have an API that allows us to reinsert
                // the entity.  Although it is expensive, performance is not a concern when
                // trace is enalbed, so we will reinsert just in case a native handler needs
                // to access the entity.  I decided not to check the current handler, since
                // that can be changed if someone sets the IIS script map.
                _context.Request.InsertEntityBody();
            }
        }

        private void AddCollectionToRequestData(DataSet requestData, string traceCollectionTitle, NameValueCollection collection) {
            if (null != collection) {
                var keys = collection.AllKeys;
                for (int i = 0; i < keys.Length; i++) {
                    var row = NewRow(requestData, traceCollectionTitle);
                    row[SR.Trace_Name] = keys[i];
                    row[SR.Trace_Value] = collection[keys[i]];
                    AddRow(requestData, traceCollectionTitle, row);
                }
            }
        }
    }
}