Merge of ubitworkvarnew with opensim/master as of 20150905.

This integrates the OpenSim refactoring to make physics, etc into modules.
AVN physics hasn't been moved to new location.
Does not compile yet.

Merge branch 'osmaster' into mbworknew1

11 files changed, 3292 insertions, 0 deletions

diff --git a/OpenSim/Region/OptionalModules/UserStatistics/ActiveConnectionsAJAX.cs b/OpenSim/Region/OptionalModules/UserStatistics/ActiveConnectionsAJAX.cs
new file mode 100644
index 0000000..6a1112c
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/ActiveConnectionsAJAX.cs
@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+using Mono.Data.SqliteClient;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Monitoring;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class ActiveConnectionsAJAX : IStatsController
+    {
+        private Vector3 DefaultNeighborPosition = new Vector3(((int)Constants.RegionSize * 0.5f), ((int)Constants.RegionSize * 0.5f), 70);
+
+        #region IStatsController Members
+
+        public string ReportName
+        {
+            get { return ""; }
+        }
+
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            List<Scene> m_scene = (List<Scene>)pParams["Scenes"];
+
+            Hashtable nh = new Hashtable();
+            nh.Add("hdata", m_scene);
+
+            return nh;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            List<Scene> all_scenes = (List<Scene>) pModelResult["hdata"];
+
+            StringBuilder output = new StringBuilder();
+            HTMLUtil.OL_O(ref output, "");
+            foreach (Scene scene in all_scenes)
+            {
+                HTMLUtil.LI_O(ref output, String.Empty);
+                output.Append(scene.RegionInfo.RegionName);
+                HTMLUtil.OL_O(ref output, String.Empty);
+                scene.ForEachScenePresence(delegate(ScenePresence av)
+                {
+                    Dictionary<string, string> queues = new Dictionary<string, string>();
+                    if (av.ControllingClient is IStatsCollector)
+                    {
+                        IStatsCollector isClient = (IStatsCollector)av.ControllingClient;
+                        queues = decodeQueueReport(isClient.Report());
+                    }
+                    HTMLUtil.LI_O(ref output, String.Empty);
+                    output.Append(av.Name);
+                    output.Append("&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
+                    output.Append((av.IsChildAgent ? "Child" : "Root"));
+                    if (av.AbsolutePosition == DefaultNeighborPosition)
+                    {
+                        output.Append("<br />Position: ?");
+                    }
+                    else
+                    {
+                        output.Append(string.Format("<br /><NOBR>Position: <{0},{1},{2}></NOBR>", (int)av.AbsolutePosition.X,
+                                                    (int)av.AbsolutePosition.Y,
+                                                    (int)av.AbsolutePosition.Z));
+                    }
+                    Dictionary<string, int> throttles = DecodeClientThrottles(av.ControllingClient.GetThrottlesPacked(1));
+
+                    HTMLUtil.UL_O(ref output, String.Empty);
+
+                    foreach (string throttlename in throttles.Keys)
+                    {
+                        HTMLUtil.LI_O(ref output, String.Empty);
+                        output.Append(throttlename);
+                        output.Append(":");
+                        output.Append(throttles[throttlename].ToString());
+                        if (queues.ContainsKey(throttlename))
+                        {
+                            output.Append("/");
+                            output.Append(queues[throttlename]);
+                        }
+                        HTMLUtil.LI_C(ref output);
+                    }
+                    if (queues.ContainsKey("Incoming") && queues.ContainsKey("Outgoing"))
+                    {
+                        HTMLUtil.LI_O(ref output, "red");
+                        output.Append("SEND:");
+                        output.Append(queues["Outgoing"]);
+                        output.Append("/");
+                        output.Append(queues["Incoming"]);
+                        HTMLUtil.LI_C(ref output);
+                    }
+
+                    HTMLUtil.UL_C(ref output);
+                    HTMLUtil.LI_C(ref output);
+                });
+                HTMLUtil.OL_C(ref output);
+            }
+            HTMLUtil.OL_C(ref output);
+            return output.ToString();
+        }
+
+        /// <summary>
+        /// Convert active connections information to JSON string. Returns a structure:
+        /// <pre>
+        /// {"regionName": {
+        ///     "presenceName": {
+        ///         "name": "presenceName",
+        ///         "position": "<x,y,z>",
+        ///         "isRoot": "false",
+        ///         "throttle": {
+        ///         },
+        ///         "queue": {
+        ///         }
+        ///     },
+        ///     ... // multiple presences in the scene
+        ///   },
+        ///   ...   // multiple regions in the sim
+        /// }
+        ///
+        /// </pre>
+        /// </summary>
+        /// <param name="pModelResult"></param>
+        /// <returns></returns>
+        public string RenderJson(Hashtable pModelResult)
+        {
+            List<Scene> all_scenes = (List<Scene>) pModelResult["hdata"];
+
+            OSDMap regionInfo = new OSDMap();
+            foreach (Scene scene in all_scenes)
+            {
+                OSDMap sceneInfo = new OpenMetaverse.StructuredData.OSDMap();
+                List<ScenePresence> avatarInScene = scene.GetScenePresences();
+                foreach (ScenePresence av in avatarInScene)
+                {
+                    OSDMap presenceInfo = new OSDMap();
+                    presenceInfo.Add("Name", new OSDString(av.Name));
+
+                    Dictionary<string,string> queues = new Dictionary<string, string>();
+                    if (av.ControllingClient is IStatsCollector)
+                    {
+                        IStatsCollector isClient = (IStatsCollector) av.ControllingClient;
+                        queues = decodeQueueReport(isClient.Report());
+                    }
+                    OSDMap queueInfo = new OpenMetaverse.StructuredData.OSDMap();
+                    foreach (KeyValuePair<string, string> kvp in queues) {
+                        queueInfo.Add(kvp.Key, new OSDString(kvp.Value));
+                    }
+                    sceneInfo.Add("queues", queueInfo);
+
+                    if (av.IsChildAgent)
+                        presenceInfo.Add("isRoot", new OSDString("false"));
+                    else
+                        presenceInfo.Add("isRoot", new OSDString("true"));
+
+                    if (av.AbsolutePosition == DefaultNeighborPosition)
+                    {
+                        presenceInfo.Add("position", new OSDString("<0, 0, 0>"));
+                    }
+                    else
+                    {
+                        presenceInfo.Add("position", new OSDString(string.Format("<{0},{1},{2}>",
+                                                    (int)av.AbsolutePosition.X,
+                                                    (int) av.AbsolutePosition.Y,
+                                                    (int) av.AbsolutePosition.Z)) );
+                    }
+
+                    Dictionary<string, int> throttles = DecodeClientThrottles(av.ControllingClient.GetThrottlesPacked(1));
+                    OSDMap throttleInfo = new OpenMetaverse.StructuredData.OSDMap();
+                    foreach (string throttlename in throttles.Keys)
+                    {
+                        throttleInfo.Add(throttlename, new OSDString(throttles[throttlename].ToString()));
+                    }
+                    presenceInfo.Add("throttle", throttleInfo);
+
+                    sceneInfo.Add(av.Name, presenceInfo);
+                }
+                regionInfo.Add(scene.RegionInfo.RegionName, sceneInfo);
+            }
+            return regionInfo.ToString();
+        }
+
+        public Dictionary<string, int> DecodeClientThrottles(byte[] throttle)
+        {
+            Dictionary<string, int> returndict = new Dictionary<string, int>();
+            // From mantis http://opensimulator.org/mantis/view.php?id=1374
+            // it appears that sometimes we are receiving empty throttle byte arrays.
+            // TODO: Investigate this behaviour
+            if (throttle.Length == 0)
+            {
+                return new Dictionary<string, int>();
+            }
+
+            int tResend = -1;
+            int tLand = -1;
+            int tWind = -1;
+            int tCloud = -1;
+            int tTask = -1;
+            int tTexture = -1;
+            int tAsset = -1;
+            int tall = -1;
+            const int singlefloat = 4;
+
+            //Agent Throttle Block contains 7 single floatingpoint values.
+            int j = 0;
+
+            // Some Systems may be big endian...
+            // it might be smart to do this check more often...
+            if (!BitConverter.IsLittleEndian)
+                for (int i = 0; i < 7; i++)
+                    Array.Reverse(throttle, j + i * singlefloat, singlefloat);
+
+            // values gotten from OpenMetaverse.org/wiki/Throttle.  Thanks MW_
+            // bytes
+            // Convert to integer, since..   the full fp space isn't used.
+            tResend = (int)BitConverter.ToSingle(throttle, j);
+            returndict.Add("Resend", tResend);
+            j += singlefloat;
+            tLand = (int)BitConverter.ToSingle(throttle, j);
+            returndict.Add("Land", tLand);
+            j += singlefloat;
+            tWind = (int)BitConverter.ToSingle(throttle, j);
+            returndict.Add("Wind", tWind);
+            j += singlefloat;
+            tCloud = (int)BitConverter.ToSingle(throttle, j);
+            returndict.Add("Cloud", tCloud);
+            j += singlefloat;
+            tTask = (int)BitConverter.ToSingle(throttle, j);
+            returndict.Add("Task", tTask);
+            j += singlefloat;
+            tTexture = (int)BitConverter.ToSingle(throttle, j);
+            returndict.Add("Texture", tTexture);
+            j += singlefloat;
+            tAsset = (int)BitConverter.ToSingle(throttle, j);
+            returndict.Add("Asset", tAsset);
+
+            tall = tResend + tLand + tWind + tCloud + tTask + tTexture + tAsset;
+            returndict.Add("All", tall);
+
+            return returndict;
+        }
+        public Dictionary<string,string> decodeQueueReport(string rep)
+        {
+            Dictionary<string, string> returndic = new Dictionary<string, string>();
+            if (rep.Length == 79)
+            {
+                int pos = 1;
+                returndic.Add("All", rep.Substring((6 * pos), 8)); pos++;
+                returndic.Add("Incoming", rep.Substring((7 * pos), 8)); pos++;
+                returndic.Add("Outgoing", rep.Substring((7 * pos) , 8)); pos++;
+                returndic.Add("Resend", rep.Substring((7 * pos) , 8)); pos++;
+                returndic.Add("Land", rep.Substring((7 * pos) , 8)); pos++;
+                returndic.Add("Wind", rep.Substring((7 * pos) , 8)); pos++;
+                returndic.Add("Cloud", rep.Substring((7 * pos) , 8)); pos++;
+                returndic.Add("Task", rep.Substring((7 * pos) , 8)); pos++;
+                returndic.Add("Texture", rep.Substring((7 * pos), 8)); pos++;
+                returndic.Add("Asset", rep.Substring((7 * pos), 8));
+                /*
+                 * return string.Format("{0,7} {1,7} {2,7} {3,7} {4,7} {5,7} {6,7} {7,7} {8,7} {9,7}",
+                                 SendQueue.Count(),
+                                 IncomingPacketQueue.Count,
+                                 OutgoingPacketQueue.Count,
+                                 ResendOutgoingPacketQueue.Count,
+                                 LandOutgoingPacketQueue.Count,
+                                 WindOutgoingPacketQueue.Count,
+                                 CloudOutgoingPacketQueue.Count,
+                                 TaskOutgoingPacketQueue.Count,
+                                 TextureOutgoingPacketQueue.Count,
+                                 AssetOutgoingPacketQueue.Count);
+                 */
+            }
+
+
+
+            return returndic;
+        }
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/Clients_report.cs b/OpenSim/Region/OptionalModules/UserStatistics/Clients_report.cs
new file mode 100644
index 0000000..4a6f7be
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/Clients_report.cs
@@ -0,0 +1,329 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using Mono.Data.SqliteClient;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class Clients_report : IStatsController
+    {
+        #region IStatsController Members
+
+        public string ReportName
+        {
+            get { return "Client"; }
+        }
+
+        /// <summary>
+        /// Return summar information in the form:
+        /// <pre>
+        /// {"totalUsers": "34",
+        ///  "totalSessions": "233",
+        ///  ...
+        /// }
+        /// </pre>
+        /// </summary>
+        /// <param name="pModelResult"></param>
+        /// <returns></returns>
+        public string RenderJson(Hashtable pModelResult) {
+            stats_default_page_values values = (stats_default_page_values) pModelResult["hdata"];
+
+            OSDMap summaryInfo = new OpenMetaverse.StructuredData.OSDMap();
+            summaryInfo.Add("totalUsers", new OSDString(values.total_num_users.ToString()));
+            summaryInfo.Add("totalSessions", new OSDString(values.total_num_sessions.ToString()));
+            summaryInfo.Add("averageClientFPS", new OSDString(values.avg_client_fps.ToString()));
+            summaryInfo.Add("averageClientMem", new OSDString(values.avg_client_mem_use.ToString()));
+            summaryInfo.Add("averageSimFPS", new OSDString(values.avg_sim_fps.ToString()));
+            summaryInfo.Add("averagePingTime", new OSDString(values.avg_ping.ToString()));
+            summaryInfo.Add("totalKBOut", new OSDString(values.total_kb_out.ToString()));
+            summaryInfo.Add("totalKBIn", new OSDString(values.total_kb_in.ToString()));
+            return summaryInfo.ToString();
+        }
+
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            SqliteConnection dbConn = (SqliteConnection)pParams["DatabaseConnection"];
+
+
+            List<ClientVersionData> clidata = new List<ClientVersionData>();
+            List<ClientVersionData> cliRegData = new List<ClientVersionData>();
+            Hashtable regionTotals = new Hashtable();
+
+            Hashtable modeldata = new Hashtable();
+            modeldata.Add("Scenes", pParams["Scenes"]);
+            modeldata.Add("Reports", pParams["Reports"]);
+            int totalclients = 0;
+            int totalregions = 0;
+
+            lock (dbConn)
+            {
+                string sql = "select count(distinct region_id) as regcnt from stats_session_data";
+
+                SqliteCommand cmd = new SqliteCommand(sql, dbConn);
+                SqliteDataReader sdr = cmd.ExecuteReader();
+                if (sdr.HasRows)
+                {
+                    sdr.Read();
+                    totalregions = Convert.ToInt32(sdr["regcnt"]);
+                }
+
+                sdr.Close();
+                sdr.Dispose();
+
+                sql =
+                    "select client_version, count(*) as cnt, avg(avg_sim_fps) as simfps from stats_session_data group by client_version order by count(*) desc LIMIT 10;";
+
+                cmd = new SqliteCommand(sql, dbConn);
+                sdr = cmd.ExecuteReader();
+                if (sdr.HasRows)
+                {
+                    while (sdr.Read())
+                    {
+                        ClientVersionData udata = new ClientVersionData();
+                        udata.version = sdr["client_version"].ToString();
+                        udata.count = Convert.ToInt32(sdr["cnt"]);
+                        udata.fps = Convert.ToSingle(sdr["simfps"]);
+                        clidata.Add(udata);
+                        totalclients += udata.count;
+                        
+                    }
+                }
+                sdr.Close();
+                sdr.Dispose();
+
+                if (totalregions > 1)
+                {
+                    sql =
+                        "select region_id, client_version, count(*) as cnt, avg(avg_sim_fps) as simfps from stats_session_data group by region_id, client_version order by region_id, count(*) desc;";
+                    cmd = new SqliteCommand(sql, dbConn);
+                    
+                    sdr = cmd.ExecuteReader();
+                    
+                    if (sdr.HasRows)
+                    {
+                        while (sdr.Read())
+                        {
+                            ClientVersionData udata = new ClientVersionData();
+                            udata.version = sdr["client_version"].ToString();
+                            udata.count = Convert.ToInt32(sdr["cnt"]);
+                            udata.fps = Convert.ToSingle(sdr["simfps"]);
+                            udata.region_id = UUID.Parse(sdr["region_id"].ToString());
+                            cliRegData.Add(udata);
+                        }
+                    }
+                    sdr.Close();
+                    sdr.Dispose();
+
+
+                }
+
+            }
+            
+            foreach (ClientVersionData cvd in cliRegData)
+            {
+                
+                if (regionTotals.ContainsKey(cvd.region_id))
+                {
+                    int regiontotal = (int)regionTotals[cvd.region_id];
+                    regiontotal += cvd.count;
+                    regionTotals[cvd.region_id] = regiontotal;
+                }
+                else
+                {
+                    regionTotals.Add(cvd.region_id, cvd.count);
+                }
+                
+                
+
+            }
+
+            modeldata["ClientData"] = clidata;
+            modeldata["ClientRegionData"] = cliRegData;
+            modeldata["RegionTotals"] = regionTotals;
+            modeldata["Total"] = totalclients;
+
+            return modeldata;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            List<ClientVersionData> clidata = (List<ClientVersionData>) pModelResult["ClientData"];
+            int totalclients = (int)pModelResult["Total"];
+            Hashtable regionTotals = (Hashtable) pModelResult["RegionTotals"];
+            List<ClientVersionData> cliRegData = (List<ClientVersionData>) pModelResult["ClientRegionData"];
+            List<Scene> m_scenes = (List<Scene>)pModelResult["Scenes"];
+            Dictionary<string, IStatsController> reports = (Dictionary<string, IStatsController>)pModelResult["Reports"];
+
+            const string STYLESHEET =
+    @"
+<STYLE>
+body
+{
+    font-size:15px; font-family:Helvetica, Verdana; color:Black;
+}
+TABLE.defaultr { }
+TR.defaultr { padding: 5px; }
+TD.header { font-weight:bold; padding:5px; }
+TD.content {}
+TD.contentright { text-align: right; }
+TD.contentcenter { text-align: center; }
+TD.align_top { vertical-align: top; }
+</STYLE>
+";
+
+            StringBuilder output = new StringBuilder();
+            HTMLUtil.HtmlHeaders_O(ref output);
+            output.Append(STYLESHEET);
+            HTMLUtil.HtmlHeaders_C(ref output);
+
+            HTMLUtil.AddReportLinks(ref output, reports, "");
+
+            HTMLUtil.TABLE_O(ref output, "defaultr");
+            HTMLUtil.TR_O(ref output, "");
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("ClientVersion");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("Count/%");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("SimFPS");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TR_C(ref output);
+
+            foreach (ClientVersionData cvd in clidata)
+            {
+                HTMLUtil.TR_O(ref output, "");
+                HTMLUtil.TD_O(ref output, "content");
+                string linkhref = "sessions.report?VersionString=" + cvd.version;
+                HTMLUtil.A(ref output, cvd.version, linkhref, "");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, "content");
+                output.Append(cvd.count);
+                output.Append("/");
+                if (totalclients > 0)
+                    output.Append((((float)cvd.count / (float)totalclients)*100).ToString());
+                else
+                    output.Append(0);
+
+                output.Append("%");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, "content");
+                output.Append(cvd.fps);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+            }
+            HTMLUtil.TABLE_C(ref output);
+
+            if (cliRegData.Count > 0)
+            {
+                HTMLUtil.TABLE_O(ref output, "defaultr");
+                HTMLUtil.TR_O(ref output, "");
+                HTMLUtil.TD_O(ref output, "header");
+                output.Append("Region");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, "header");
+                output.Append("ClientVersion");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, "header");
+                output.Append("Count/%");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, "header");
+                output.Append("SimFPS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+
+                foreach (ClientVersionData cvd in cliRegData)
+                {
+                    HTMLUtil.TR_O(ref output, "");
+                    HTMLUtil.TD_O(ref output, "content");
+                    output.Append(regionNamefromUUID(m_scenes, cvd.region_id));
+                    HTMLUtil.TD_C(ref output);
+                    HTMLUtil.TD_O(ref output, "content");
+                    output.Append(cvd.version);
+                    HTMLUtil.TD_C(ref output);
+                    HTMLUtil.TD_O(ref output, "content");
+                    output.Append(cvd.count);
+                    output.Append("/");
+                    if ((int)regionTotals[cvd.region_id] > 0)
+                        output.Append((((float)cvd.count / (float)((int)regionTotals[cvd.region_id])) * 100).ToString());
+                    else
+                        output.Append(0);
+
+                    output.Append("%");
+                    HTMLUtil.TD_C(ref output);
+                    HTMLUtil.TD_O(ref output, "content");
+                    output.Append(cvd.fps);
+                    HTMLUtil.TD_C(ref output);
+                    HTMLUtil.TR_C(ref output);
+                }
+                HTMLUtil.TABLE_C(ref output);
+
+            }
+
+            output.Append("</BODY>");
+            output.Append("</HTML>");
+            return output.ToString();
+        }
+        public string regionNamefromUUID(List<Scene> scenes, UUID region_id)
+        {
+            string returnstring = string.Empty;
+            foreach (Scene sn in scenes)
+            {
+                if (region_id == sn.RegionInfo.originRegionID)
+                {
+                    returnstring = sn.RegionInfo.RegionName;
+                    break;
+                }
+            }
+
+            if (returnstring.Length == 0)
+            {
+                returnstring = region_id.ToString();
+            }
+
+            return returnstring;
+        }
+
+        #endregion
+    }
+
+    public struct ClientVersionData
+    {
+        public UUID region_id;
+        public string version;
+        public int count;
+        public float fps;
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/Default_Report.cs b/OpenSim/Region/OptionalModules/UserStatistics/Default_Report.cs
new file mode 100644
index 0000000..fabe3d4
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/Default_Report.cs
@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+using Mono.Data.SqliteClient;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Monitoring;
+
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class Default_Report : IStatsController
+    {
+
+        public string ReportName
+        {
+            get { return "Home"; }
+        }
+
+        #region IStatsController Members
+
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            SqliteConnection conn = (SqliteConnection)pParams["DatabaseConnection"];
+            List<Scene> m_scene = (List<Scene>)pParams["Scenes"];
+
+            stats_default_page_values mData = rep_DefaultReport_data(conn, m_scene);
+            mData.sim_stat_data = (Dictionary<UUID,USimStatsData>)pParams["SimStats"];
+            mData.stats_reports = (Dictionary<string, IStatsController>) pParams["Reports"];
+
+            Hashtable nh = new Hashtable();
+            nh.Add("hdata", mData);
+            nh.Add("Reports", pParams["Reports"]);
+            
+            return nh;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            stats_default_page_values mData = (stats_default_page_values) pModelResult["hdata"];
+            return rep_Default_report_view(mData);
+        }
+
+        #endregion
+
+        public string rep_Default_report_view(stats_default_page_values values)
+        {
+
+            
+            StringBuilder output = new StringBuilder();
+
+
+
+            const string TableClass = "defaultr";
+            const string TRClass = "defaultr";
+            const string TDHeaderClass = "header";
+            const string TDDataClass = "content";
+            //const string TDDataClassRight = "contentright";
+            const string TDDataClassCenter = "contentcenter";
+
+            const string STYLESHEET =
+                @"
+<STYLE>
+body
+{
+    font-size:15px; font-family:Helvetica, Verdana; color:Black;
+}
+TABLE.defaultr { }
+TR.defaultr { padding: 5px; }
+TD.header { font-weight:bold; padding:5px; }
+TD.content {}
+TD.contentright { text-align: right; }
+TD.contentcenter { text-align: center; }
+TD.align_top { vertical-align: top; }
+</STYLE>
+";
+            HTMLUtil.HtmlHeaders_O(ref output);
+            
+            HTMLUtil.InsertProtoTypeAJAX(ref output);
+            string[] ajaxUpdaterDivs = new string[3];
+            int[] ajaxUpdaterSeconds = new int[3];
+            string[] ajaxUpdaterReportFragments = new string[3];
+
+            ajaxUpdaterDivs[0] = "activeconnections";
+            ajaxUpdaterSeconds[0] = 10;
+            ajaxUpdaterReportFragments[0] = "activeconnectionsajax.html";
+
+            ajaxUpdaterDivs[1] = "activesimstats";
+            ajaxUpdaterSeconds[1] = 20;
+            ajaxUpdaterReportFragments[1] = "simstatsajax.html";
+
+            ajaxUpdaterDivs[2] = "activelog";
+            ajaxUpdaterSeconds[2] = 5;
+            ajaxUpdaterReportFragments[2] = "activelogajax.html";
+
+            HTMLUtil.InsertPeriodicUpdaters(ref output, ajaxUpdaterDivs, ajaxUpdaterSeconds, ajaxUpdaterReportFragments);
+            
+            output.Append(STYLESHEET);
+            HTMLUtil.HtmlHeaders_C(ref output);
+            HTMLUtil.AddReportLinks(ref output, values.stats_reports, "");
+            HTMLUtil.TABLE_O(ref output, TableClass);
+            HTMLUtil.TR_O(ref output, TRClass);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("# Users Total");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("# Sessions Total");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("Avg Client FPS");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("Avg Client Mem Use");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("Avg Sim FPS");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("Avg Ping");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("KB Out Total");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDHeaderClass);
+            output.Append("KB In Total");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TR_C(ref output);
+            HTMLUtil.TR_O(ref output, TRClass);
+            HTMLUtil.TD_O(ref output, TDDataClass);
+            output.Append(values.total_num_users);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDDataClass);
+            output.Append(values.total_num_sessions);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDDataClassCenter);
+            output.Append(values.avg_client_fps);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDDataClassCenter);
+            output.Append(values.avg_client_mem_use);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDDataClassCenter);
+            output.Append(values.avg_sim_fps);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDDataClassCenter);
+            output.Append(values.avg_ping);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDDataClassCenter);
+            output.Append(values.total_kb_out);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, TDDataClassCenter);
+            output.Append(values.total_kb_in);
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TR_C(ref output);
+            HTMLUtil.TABLE_C(ref output);
+
+            HTMLUtil.HR(ref output, "");
+            HTMLUtil.TABLE_O(ref output, "");
+            HTMLUtil.TR_O(ref output, "");
+            HTMLUtil.TD_O(ref output, "align_top");
+            output.Append("<DIV id=\"activeconnections\">Active Connections loading...</DIV>");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, "align_top");
+            output.Append("<DIV id=\"activesimstats\">SimStats loading...</DIV>");
+            output.Append("<DIV id=\"activelog\">ActiveLog loading...</DIV>");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TR_C(ref output);
+            HTMLUtil.TABLE_C(ref output);
+            output.Append("</BODY></HTML>");
+            // TODO: FIXME: template
+            return output.ToString();
+        }
+
+       
+
+        public stats_default_page_values rep_DefaultReport_data(SqliteConnection db, List<Scene> m_scene)
+        {
+            stats_default_page_values returnstruct = new stats_default_page_values();
+            returnstruct.all_scenes = m_scene.ToArray();
+            lock (db)
+            {
+                string SQL = @"SELECT COUNT(DISTINCT agent_id) as agents, COUNT(*) as sessions, AVG(avg_fps) as client_fps, 
+                                AVG(avg_sim_fps) as savg_sim_fps, AVG(avg_ping) as sav_ping, SUM(n_out_kb) as num_in_kb, 
+                                SUM(n_out_pk) as num_in_packets, SUM(n_in_kb) as num_out_kb, SUM(n_in_pk) as num_out_packets, AVG(mem_use) as sav_mem_use
+                                FROM stats_session_data;";
+                SqliteCommand cmd = new SqliteCommand(SQL, db);
+                SqliteDataReader sdr = cmd.ExecuteReader();
+                if (sdr.HasRows)
+                {
+                    sdr.Read();
+                    returnstruct.total_num_users = Convert.ToInt32(sdr["agents"]);
+                    returnstruct.total_num_sessions = Convert.ToInt32(sdr["sessions"]);
+                    returnstruct.avg_client_fps = Convert.ToSingle(sdr["client_fps"]);
+                    returnstruct.avg_sim_fps = Convert.ToSingle(sdr["savg_sim_fps"]);
+                    returnstruct.avg_ping = Convert.ToSingle(sdr["sav_ping"]);
+                    returnstruct.total_kb_out = Convert.ToSingle(sdr["num_out_kb"]);
+                    returnstruct.total_kb_in = Convert.ToSingle(sdr["num_in_kb"]);
+                    returnstruct.avg_client_mem_use = Convert.ToSingle(sdr["sav_mem_use"]);
+
+                }
+            }
+            return returnstruct;
+        }
+
+        /// <summary>
+        /// Return summar information in the form:
+        /// <pre>
+        /// {"totalUsers": "34",
+        ///  "totalSessions": "233",
+        ///  ...
+        /// }
+        /// </pre>
+        /// </summary>
+        /// <param name="pModelResult"></param>
+        /// <returns></returns>
+        public string RenderJson(Hashtable pModelResult) {
+            stats_default_page_values values = (stats_default_page_values) pModelResult["hdata"];
+
+            OSDMap summaryInfo = new OSDMap();
+            summaryInfo.Add("totalUsers", new OSDString(values.total_num_users.ToString()));
+            summaryInfo.Add("totalSessions", new OSDString(values.total_num_sessions.ToString()));
+            summaryInfo.Add("averageClientFPS", new OSDString(values.avg_client_fps.ToString()));
+            summaryInfo.Add("averageClientMem", new OSDString(values.avg_client_mem_use.ToString()));
+            summaryInfo.Add("averageSimFPS", new OSDString(values.avg_sim_fps.ToString()));
+            summaryInfo.Add("averagePingTime", new OSDString(values.avg_ping.ToString()));
+            summaryInfo.Add("totalKBOut", new OSDString(values.total_kb_out.ToString()));
+            summaryInfo.Add("totalKBIn", new OSDString(values.total_kb_in.ToString()));
+            return summaryInfo.ToString();
+        }
+    }
+
+    public struct stats_default_page_values
+    {
+        public int total_num_users;
+        public int total_num_sessions;
+        public float avg_client_fps;
+        public float avg_client_mem_use;
+        public float avg_sim_fps;
+        public float avg_ping;
+        public float total_kb_out;
+        public float total_kb_in;
+        public float avg_client_resends;
+        public Scene[] all_scenes;
+        public Dictionary<UUID, USimStatsData> sim_stat_data;
+        public Dictionary<string, IStatsController> stats_reports;
+    }
+ 
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/HTMLUtil.cs b/OpenSim/Region/OptionalModules/UserStatistics/HTMLUtil.cs
new file mode 100644
index 0000000..c07619f
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/HTMLUtil.cs
@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public static class HTMLUtil
+    {
+
+        public static void TR_O(ref StringBuilder o, string pclass)
+        {
+            o.Append("<tr");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            o.Append(">\n\t");
+        }
+
+        public static void TR_C(ref StringBuilder o)
+        {
+            o.Append("</tr>\n");
+        }
+
+        public static void TD_O(ref StringBuilder o, string pclass)
+        {
+            TD_O(ref o, pclass, 0, 0);
+        }
+
+        public static void TD_O(ref StringBuilder o, string pclass, int rowspan, int colspan)
+        {
+            o.Append("<td");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            if (rowspan > 1)
+            {
+                o.Append(" rowspan=\"");
+                o.Append(rowspan);
+                o.Append("\"");
+            }
+            if (colspan > 1)
+            {
+                o.Append(" colspan=\"");
+                o.Append(colspan);
+                o.Append("\"");
+            }
+            o.Append(">");
+        }
+
+        public static void TD_C(ref StringBuilder o)
+        {
+            o.Append("</td>");
+        }
+
+        public static void TABLE_O(ref StringBuilder o, string pclass)
+        {
+            o.Append("<table");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            o.Append(">\n\t");
+        }
+
+        public static void TABLE_C(ref StringBuilder o)
+        {
+            o.Append("</table>\n");
+        }
+        
+        public static void BLOCKQUOTE_O(ref StringBuilder o, string pclass)
+        {
+            o.Append("<blockquote");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            o.Append(" />\n");
+        }
+
+        public static void BLOCKQUOTE_C(ref StringBuilder o)
+        {
+            o.Append("</blockquote>\n");
+        }
+
+        public static void BR(ref StringBuilder o)
+        {
+            o.Append("<br />\n");
+        }
+
+        public static void HR(ref StringBuilder o, string pclass)
+        {
+            o.Append("<hr");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            o.Append(" />\n");
+        }
+
+        public static void UL_O(ref StringBuilder o, string pclass)
+        {
+            o.Append("<ul");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            o.Append(" />\n");
+        }
+
+        public static void UL_C(ref StringBuilder o)
+        {
+            o.Append("</ul>\n");
+        }
+
+        public static void OL_O(ref StringBuilder o, string pclass)
+        {
+            o.Append("<ol");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            o.Append(" />\n");
+        }
+
+        public static void OL_C(ref StringBuilder o)
+        {
+            o.Append("</ol>\n");
+        }
+
+        public static void LI_O(ref StringBuilder o, string pclass)
+        {
+            o.Append("<li");
+            if (pclass.Length > 0)
+            {
+                GenericClass(ref o, pclass);
+            }
+            o.Append(" />\n");
+        }
+
+        public static void LI_C(ref StringBuilder o)
+        {
+            o.Append("</li>\n");
+        }
+
+        public static void GenericClass(ref StringBuilder o, string pclass)
+        {
+            o.Append(" class=\"");
+            o.Append(pclass);
+            o.Append("\"");
+        }
+
+        public static void InsertProtoTypeAJAX(ref StringBuilder o)
+        {
+            o.Append("<script type=\"text/javascript\" src=\"prototype.js\"></script>\n");
+            o.Append("<script type=\"text/javascript\" src=\"updater.js\"></script>\n");
+        }
+
+        public static void InsertPeriodicUpdaters(ref StringBuilder o, string[] divID, int[] seconds, string[] reportfrag)
+        {
+            o.Append("<script type=\"text/javascript\">\n");
+            o.Append(
+                @"
+                // <![CDATA[
+                document.observe('dom:loaded', function() {
+                    /*
+                    first arg    : div to update
+                    second arg    : interval to poll in seconds
+                    third arg    : file to get data
+                    */
+");
+            for (int i = 0; i < divID.Length; i++)
+            {
+            
+                o.Append("new updater('");
+                o.Append(divID[i]);
+                o.Append("', ");
+                o.Append(seconds[i]);
+                o.Append(", '");
+                o.Append(reportfrag[i]);
+                o.Append("');\n");
+            }
+
+            o.Append(@"
+                });
+                // ]]>
+                </script>");
+        }
+
+        public static void HtmlHeaders_O(ref StringBuilder o)
+        {
+            o.Append("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n");
+            o.Append("<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"nl\">");
+            o.Append("<head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=iso-8859-1\" />");
+        }
+
+        public static void HtmlHeaders_C(ref StringBuilder o)
+        {
+            o.Append("</HEAD>");
+            o.Append("<BODY>");
+        }
+
+        public static void AddReportLinks(ref StringBuilder o, Dictionary<string, IStatsController> reports, string pClass)
+        {
+            int repcount = 0;
+            foreach (string str in reports.Keys)
+            {
+                if (reports[str].ReportName.Length > 0)
+                {
+                    if (repcount > 0)
+                    {
+                        o.Append("|&nbsp;&nbsp;");
+                    }
+                    A(ref o, reports[str].ReportName, str, pClass);
+                    o.Append("&nbsp;&nbsp;");
+                    repcount++;
+                }
+            }
+        }
+
+        public static void A(ref StringBuilder o, string linktext, string linkhref, string pClass)
+        {
+            o.Append("<A");
+            if (pClass.Length > 0)
+            {
+                GenericClass(ref o, pClass);
+            }
+            o.Append(" href=\"");
+            o.Append(linkhref);
+            o.Append("\">");
+            o.Append(linktext);
+            o.Append("</A>");
+        }
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/IStatsReport.cs b/OpenSim/Region/OptionalModules/UserStatistics/IStatsReport.cs
new file mode 100644
index 0000000..80c4487
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/IStatsReport.cs
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Collections;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public interface IStatsController
+    {
+        string ReportName { get; }
+        Hashtable ProcessModel(Hashtable pParams);
+        string RenderView(Hashtable pModelResult);
+        string RenderJson(Hashtable pModelResult);
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/LogLinesAJAX.cs b/OpenSim/Region/OptionalModules/UserStatistics/LogLinesAJAX.cs
new file mode 100644
index 0000000..4d45b80
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/LogLinesAJAX.cs
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
+using Mono.Data.SqliteClient;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Monitoring;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class LogLinesAJAX : IStatsController
+    {
+        private Regex normalizeEndLines = new Regex(@"\r\n", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.Multiline);
+
+        private Regex webFormat = new Regex(@"[^\s]*\s([^,]*),[^\s]*\s([A-Z]*)[^\s-][^\[]*\[([^\]]*)\]([^\n]*)",
+                                            RegexOptions.Singleline | RegexOptions.Compiled);
+        private Regex TitleColor = new Regex(@"[^\s]*\s(?:[^,]*),[^\s]*\s(?:[A-Z]*)[^\s-][^\[]*\[([^\]]*)\](?:[^\n]*)",
+                                    RegexOptions.Singleline | RegexOptions.Compiled);
+
+
+        #region IStatsController Members
+
+        public string ReportName
+        {
+            get { return ""; }
+        }
+
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            Hashtable nh = new Hashtable();
+            nh.Add("loglines", pParams["LogLines"]);
+            return nh;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            StringBuilder output = new StringBuilder();
+            
+            HTMLUtil.HR(ref output, "");
+            output.Append("<H3>ActiveLog</H3>\n");
+
+            string tmp = normalizeEndLines.Replace(pModelResult["loglines"].ToString(), "\n");
+
+            string[] result = Regex.Split(tmp, "\n");
+
+            string formatopen = "";
+            string formatclose = "";
+
+            for (int i = 0; i < result.Length; i++)
+            {
+                if (result[i].Length >= 30)
+                {
+                    string logtype = result[i].Substring(24, 6);
+                    switch (logtype)
+                    {
+                        case "WARN  ":
+                            formatopen = "<font color=\"#7D7C00\">";
+                            formatclose = "</font>";
+                            break;
+
+                        case "ERROR ":
+                            formatopen = "<font color=\"#FF0000\">";
+                            formatclose = "</font>";
+                            break;
+
+                        default:
+                            formatopen = "";
+                            formatclose = "";
+                            break;
+
+                    }
+                }
+                StringBuilder replaceStr = new StringBuilder();
+                //string titlecolorresults = 
+                
+                string formatresult = Regex.Replace(TitleColor.Replace(result[i], "$1"), "[^ABCDEFabcdef0-9]", "");
+                if (formatresult.Length > 6)
+                {
+                    formatresult = formatresult.Substring(0, 6);
+                   
+                }
+                for (int j = formatresult.Length; j <= 5; j++)
+                    formatresult += "0";
+                replaceStr.Append("$1 - [<font color=\"#");
+                replaceStr.Append(formatresult);
+                replaceStr.Append("\">$3</font>] $4<br />");
+                string repstr = replaceStr.ToString();
+                
+                output.Append(formatopen);
+                output.Append(webFormat.Replace(result[i], repstr));
+                output.Append(formatclose);
+            }
+                
+
+            return output.ToString();
+        }
+
+        /// <summary>
+        /// Return the last log lines. Output in the format:
+        /// <pre>
+        /// {"logLines": [
+        /// "line1",
+        /// "line2",
+        /// ...
+        /// ]
+        /// }
+        /// </pre>
+        /// </summary>
+        /// <param name="pModelResult"></param>
+        /// <returns></returns>
+        public string RenderJson(Hashtable pModelResult)
+        {
+            OSDMap logInfo = new OpenMetaverse.StructuredData.OSDMap();
+
+            OSDArray logLines = new OpenMetaverse.StructuredData.OSDArray();
+            string tmp = normalizeEndLines.Replace(pModelResult["loglines"].ToString(), "\n");
+            string[] result = Regex.Split(tmp, "\n");
+            for (int i = 0; i < result.Length; i++)
+            {
+                logLines.Add(new OSDString(result[i]));
+            }
+            logInfo.Add("logLines", logLines);
+            return logInfo.ToString();
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/Prototype_distributor.cs b/OpenSim/Region/OptionalModules/UserStatistics/Prototype_distributor.cs
new file mode 100644
index 0000000..6f8b2aa
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/Prototype_distributor.cs
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using OpenSim.Framework;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class Prototype_distributor : IStatsController
+    {
+        private string jsFileName = "prototype.js";
+        private string prototypejs = string.Empty;
+
+        public Prototype_distributor()
+        {
+            jsFileName = "prototype.js";
+        }
+
+        public Prototype_distributor(string jsName) 
+        {
+            jsFileName = jsName;
+        }
+
+        public string ReportName
+        {
+            get { return ""; }
+        }
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            Hashtable pResult = new Hashtable();
+            pResult["js"] = jsFileName;
+            return pResult;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            string fileName = (string)pModelResult["js"];
+            using (StreamReader fs = new StreamReader(new FileStream(Util.dataDir() + "/data/" + fileName, FileMode.Open)))
+            {
+                prototypejs = fs.ReadToEnd();
+                fs.Close();
+            }
+            return prototypejs;
+        }
+
+        public string RenderJson(Hashtable pModelResult)
+        {
+            return "{}";
+        }
+
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/Sessions_Report.cs b/OpenSim/Region/OptionalModules/UserStatistics/Sessions_Report.cs
new file mode 100644
index 0000000..0e94912
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/Sessions_Report.cs
@@ -0,0 +1,288 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using Mono.Data.SqliteClient;
+using OpenMetaverse;
+using OpenSim.Framework;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class Sessions_Report : IStatsController
+    {
+        #region IStatsController Members
+
+        public string ReportName
+        {
+            get { return "Sessions"; }
+        }
+
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            Hashtable modeldata = new Hashtable();
+            modeldata.Add("Scenes", pParams["Scenes"]);
+            modeldata.Add("Reports", pParams["Reports"]);
+            SqliteConnection dbConn = (SqliteConnection)pParams["DatabaseConnection"];
+            List<SessionList> lstSessions = new List<SessionList>();
+            Hashtable requestvars = (Hashtable) pParams["RequestVars"];
+            
+
+            string puserUUID = string.Empty;
+            string clientVersionString = string.Empty;
+            int queryparams = 0;
+
+            if (requestvars != null)
+            {
+                if (requestvars.ContainsKey("UserID"))
+                {
+                    UUID testUUID = UUID.Zero;
+                    if (UUID.TryParse(requestvars["UserID"].ToString(), out testUUID))
+                    {
+                        puserUUID = requestvars["UserID"].ToString();
+
+                    }
+                }
+
+                if (requestvars.ContainsKey("VersionString"))
+                {
+                    clientVersionString = requestvars["VersionString"].ToString();
+                }
+            }
+
+            lock (dbConn)
+            {
+                string sql =
+                    "SELECT distinct a.name_f, a.name_l, a.Agent_ID, b.Session_ID, b.client_version, b.last_updated, b.start_time FROM stats_session_data a LEFT OUTER JOIN stats_session_data b ON a.Agent_ID = b.Agent_ID";
+
+                if (puserUUID.Length > 0)
+                {
+                    if (queryparams == 0)
+                        sql += " WHERE";
+                    else
+                        sql += " AND";
+
+                    sql += " b.agent_id=:agent_id";
+                    queryparams++;
+                }
+
+                if (clientVersionString.Length > 0)
+                {
+                    if (queryparams == 0)
+                        sql += " WHERE";
+                    else
+                        sql += " AND";
+
+                    sql += " b.client_version=:client_version";
+                    queryparams++;
+                }
+
+                sql += " ORDER BY a.name_f, a.name_l, b.last_updated;";
+
+                SqliteCommand cmd = new SqliteCommand(sql, dbConn);
+
+                if (puserUUID.Length > 0)
+                    cmd.Parameters.Add(new SqliteParameter(":agent_id", puserUUID));
+                if (clientVersionString.Length > 0)
+                    cmd.Parameters.Add(new SqliteParameter(":client_version", clientVersionString));
+
+                SqliteDataReader sdr = cmd.ExecuteReader();
+                
+                if (sdr.HasRows)
+                {
+                    UUID userUUID = UUID.Zero;
+
+                    SessionList activeSessionList = new SessionList();
+                    activeSessionList.user_id=UUID.Random();
+                    while (sdr.Read())
+                    {
+                        UUID readUUID = UUID.Parse(sdr["agent_id"].ToString());
+                        if (readUUID != userUUID)
+                        {
+                            activeSessionList = new SessionList();
+                            activeSessionList.user_id = readUUID;
+                            activeSessionList.firstname = sdr["name_f"].ToString();
+                            activeSessionList.lastname = sdr["name_l"].ToString();
+                            activeSessionList.sessions = new List<ShortSessionData>();
+                            lstSessions.Add(activeSessionList);
+                        }
+
+                        ShortSessionData ssd = new ShortSessionData();
+                        
+                        ssd.last_update = Utils.UnixTimeToDateTime((uint)Convert.ToInt32(sdr["last_updated"]));
+                        ssd.start_time = Utils.UnixTimeToDateTime((uint)Convert.ToInt32(sdr["start_time"]));
+                        ssd.session_id = UUID.Parse(sdr["session_id"].ToString());
+                        ssd.client_version = sdr["client_version"].ToString();
+                        activeSessionList.sessions.Add(ssd);
+
+                        userUUID = activeSessionList.user_id;
+                    }
+                }
+                sdr.Close();
+                sdr.Dispose();
+                
+            }
+            modeldata["SessionData"] = lstSessions;
+            return modeldata;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            List<SessionList> lstSession = (List<SessionList>) pModelResult["SessionData"];
+            Dictionary<string, IStatsController> reports = (Dictionary<string, IStatsController>)pModelResult["Reports"];
+
+            const string STYLESHEET =
+    @"
+<STYLE>
+body
+{
+    font-size:15px; font-family:Helvetica, Verdana; color:Black;
+}
+TABLE.defaultr { }
+TR.defaultr { padding: 5px; }
+TD.header { font-weight:bold; padding:5px; }
+TD.content {}
+TD.contentright { text-align: right; }
+TD.contentcenter { text-align: center; }
+TD.align_top { vertical-align: top; }
+</STYLE>
+";
+
+            StringBuilder output = new StringBuilder();
+            HTMLUtil.HtmlHeaders_O(ref output);
+            output.Append(STYLESHEET);
+            HTMLUtil.HtmlHeaders_C(ref output);
+
+            HTMLUtil.AddReportLinks(ref output, reports, "");
+
+            HTMLUtil.TABLE_O(ref output, "defaultr");
+            HTMLUtil.TR_O(ref output, "defaultr");
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("FirstName");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("LastName");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("SessionEnd");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("SessionLength");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TD_O(ref output, "header");
+            output.Append("Client");
+            HTMLUtil.TD_C(ref output);
+            HTMLUtil.TR_C(ref output);
+            if (lstSession.Count == 0)
+            {
+                HTMLUtil.TR_O(ref output, "");
+                HTMLUtil.TD_O(ref output, "align_top", 1, 5);
+                output.Append("No results for that query");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+            }
+            foreach (SessionList ssnlst in lstSession)
+            {
+                int cnt = 0;
+                foreach (ShortSessionData sesdata in ssnlst.sessions)
+                {
+                    HTMLUtil.TR_O(ref output, "");
+                    if (cnt++ == 0)
+                    {
+                        HTMLUtil.TD_O(ref output, "align_top", ssnlst.sessions.Count, 1);
+                        output.Append(ssnlst.firstname);
+                        HTMLUtil.TD_C(ref output);
+                        HTMLUtil.TD_O(ref output, "align_top", ssnlst.sessions.Count, 1);
+                        output.Append(ssnlst.lastname);
+                        HTMLUtil.TD_C(ref output);
+                    }
+                    HTMLUtil.TD_O(ref output, "content");
+                    output.Append(sesdata.last_update.ToShortDateString());
+                    output.Append(" - ");
+                    output.Append(sesdata.last_update.ToShortTimeString());
+                    HTMLUtil.TD_C(ref output);
+                    HTMLUtil.TD_O(ref output, "content");
+                    TimeSpan dtlength = sesdata.last_update.Subtract(sesdata.start_time);
+                    if (dtlength.Days > 0)
+                    {
+                        output.Append(dtlength.Days);
+                        output.Append(" Days ");
+                    }
+                    if (dtlength.Hours > 0)
+                    {
+                        output.Append(dtlength.Hours);
+                        output.Append(" Hours ");
+                    }
+                    if (dtlength.Minutes > 0)
+                    {
+                        output.Append(dtlength.Minutes);
+                        output.Append(" Minutes");
+                    }
+                    HTMLUtil.TD_C(ref output);
+                    HTMLUtil.TD_O(ref output, "content");
+                    output.Append(sesdata.client_version);
+                    HTMLUtil.TD_C(ref output);
+                    HTMLUtil.TR_C(ref output);
+                    
+                }
+                HTMLUtil.TR_O(ref output, "");
+                HTMLUtil.TD_O(ref output, "align_top", 1, 5);
+                HTMLUtil.HR(ref output, "");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+            }
+            HTMLUtil.TABLE_C(ref output);
+            output.Append("</BODY>\n</HTML>");
+            return output.ToString();
+        }
+
+        public class SessionList
+        {
+            public string firstname;
+            public string lastname;
+            public UUID user_id;
+            public List<ShortSessionData> sessions;
+        }
+
+        public struct ShortSessionData
+        {
+            public UUID session_id;
+            public string client_version;
+            public DateTime last_update;
+            public DateTime start_time;
+        }
+
+        public string RenderJson(Hashtable pModelResult)
+        {
+            return "{}";
+        }
+        #endregion
+    }
+
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/SimStatsAJAX.cs b/OpenSim/Region/OptionalModules/UserStatistics/SimStatsAJAX.cs
new file mode 100644
index 0000000..06d9e91
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/SimStatsAJAX.cs
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+using Mono.Data.SqliteClient;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Monitoring;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class SimStatsAJAX : IStatsController
+    {
+        #region IStatsController Members
+
+        public string ReportName
+        {
+            get { return ""; }
+        }
+
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            List<Scene> m_scene = (List<Scene>)pParams["Scenes"];
+            
+            Hashtable nh = new Hashtable();
+            nh.Add("hdata", m_scene);
+            nh.Add("simstats", pParams["SimStats"]);
+            return nh;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            StringBuilder output = new StringBuilder();
+            List<Scene> all_scenes = (List<Scene>) pModelResult["hdata"];
+            Dictionary<UUID, USimStatsData> sdatadic = (Dictionary<UUID,USimStatsData>)pModelResult["simstats"];
+
+            const string TableClass = "defaultr";
+            const string TRClass = "defaultr";
+            const string TDHeaderClass = "header";
+            const string TDDataClass = "content";
+            //const string TDDataClassRight = "contentright";
+            const string TDDataClassCenter = "contentcenter";
+
+            foreach (USimStatsData sdata in sdatadic.Values)
+            {
+
+
+                foreach (Scene sn in all_scenes)
+                {
+                    if (sn.RegionInfo.RegionID == sdata.RegionId)
+                    {
+                        output.Append("<H2>");
+                        output.Append(sn.RegionInfo.RegionName);
+                        output.Append("</H2>");
+                    }
+                }
+                HTMLUtil.TABLE_O(ref output, TableClass);
+                HTMLUtil.TR_O(ref output, TRClass);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("Dilatn");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("SimFPS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("PhysFPS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("AgntUp");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("RootAg");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("ChldAg");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("Prims");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("ATvPrm");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("AtvScr");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("ScrLPS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+                HTMLUtil.TR_O(ref output, TRClass);
+                HTMLUtil.TD_O(ref output, TDDataClass);
+                output.Append(sdata.TimeDilation);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClass);
+                output.Append(sdata.SimFps);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.PhysicsFps);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.AgentUpdates);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.RootAgents);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.ChildAgents);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.TotalPrims);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.ActivePrims);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.ActiveScripts);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.ScriptLinesPerSecond);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+                HTMLUtil.TR_O(ref output, TRClass);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("FrmMS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("AgtMS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("PhysMS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("OthrMS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("OutPPS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("InPPS");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("NoAckKB");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("PndDWN");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDHeaderClass);
+                output.Append("PndUP");
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+                HTMLUtil.TR_O(ref output, TRClass);
+                HTMLUtil.TD_O(ref output, TDDataClass);
+                output.Append(sdata.TotalFrameTime);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClass);
+                output.Append(sdata.AgentFrameTime);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.PhysicsFrameTime);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.OtherFrameTime);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.OutPacketsPerSecond);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.InPacketsPerSecond);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.UnackedBytes);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.PendingDownloads);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TD_O(ref output, TDDataClassCenter);
+                output.Append(sdata.PendingUploads);
+                HTMLUtil.TD_C(ref output);
+                HTMLUtil.TR_C(ref output);
+                HTMLUtil.TABLE_C(ref output);
+                
+            }
+            
+            return output.ToString();
+        }
+
+        /// <summary>
+        /// Return stat information for all regions in the sim. Returns data of the form:
+        /// <pre>
+        /// {"REGIONNAME": {
+        ///     "region": "REGIONNAME",
+        ///     "timeDilation": "101", 
+        ///     ...     // the rest of the stat info
+        ///     },
+        ///  ...    // entries for each region
+        ///  }
+        /// </pre>
+        /// </summary>
+        /// <param name="pModelResult"></param>
+        /// <returns></returns>
+        public string RenderJson(Hashtable pModelResult)
+        {
+            List<Scene> all_scenes = (List<Scene>) pModelResult["hdata"];
+            Dictionary<UUID, USimStatsData> sdatadic = (Dictionary<UUID,USimStatsData>)pModelResult["simstats"];
+
+            OSDMap allStatsInfo = new OpenMetaverse.StructuredData.OSDMap();
+            foreach (USimStatsData sdata in sdatadic.Values)
+            {
+                OSDMap statsInfo = new OpenMetaverse.StructuredData.OSDMap();
+                string regionName = "unknown";
+                foreach (Scene sn in all_scenes)
+                {
+                    if (sn.RegionInfo.RegionID == sdata.RegionId)
+                    {
+                        regionName = sn.RegionInfo.RegionName;
+                        break;
+                    }
+                }
+                statsInfo.Add("region", new OSDString(regionName));
+                statsInfo.Add("timeDilation", new OSDString(sdata.TimeDilation.ToString()));
+                statsInfo.Add("simFPS", new OSDString(sdata.SimFps.ToString()));
+                statsInfo.Add("physicsFPS", new OSDString(sdata.PhysicsFps.ToString()));
+                statsInfo.Add("agentUpdates", new OSDString(sdata.AgentUpdates.ToString()));
+                statsInfo.Add("rootAgents", new OSDString(sdata.RootAgents.ToString()));
+                statsInfo.Add("childAgents", new OSDString(sdata.ChildAgents.ToString()));
+                statsInfo.Add("totalPrims", new OSDString(sdata.TotalPrims.ToString()));
+                statsInfo.Add("activePrims", new OSDString(sdata.ActivePrims.ToString()));
+                statsInfo.Add("activeScripts", new OSDString(sdata.ActiveScripts.ToString()));
+                statsInfo.Add("scriptLinesPerSec", new OSDString(sdata.ScriptLinesPerSecond.ToString()));
+                statsInfo.Add("totalFrameTime", new OSDString(sdata.TotalFrameTime.ToString()));
+                statsInfo.Add("agentFrameTime", new OSDString(sdata.AgentFrameTime.ToString()));
+                statsInfo.Add("physicsFrameTime", new OSDString(sdata.PhysicsFrameTime.ToString()));
+                statsInfo.Add("otherFrameTime", new OSDString(sdata.OtherFrameTime.ToString()));
+                statsInfo.Add("outPacketsPerSec", new OSDString(sdata.OutPacketsPerSecond.ToString()));
+                statsInfo.Add("inPacketsPerSec", new OSDString(sdata.InPacketsPerSecond.ToString()));
+                statsInfo.Add("unackedByptes", new OSDString(sdata.UnackedBytes.ToString()));
+                statsInfo.Add("pendingDownloads", new OSDString(sdata.PendingDownloads.ToString()));
+                statsInfo.Add("pendingUploads", new OSDString(sdata.PendingUploads.ToString()));
+
+                allStatsInfo.Add(regionName, statsInfo);
+            }
+            return allStatsInfo.ToString();
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/Updater_distributor.cs b/OpenSim/Region/OptionalModules/UserStatistics/Updater_distributor.cs
new file mode 100644
index 0000000..601e06b
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/Updater_distributor.cs
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using OpenSim.Framework;
+
+namespace OpenSim.Region.UserStatistics
+{
+    public class Updater_distributor : IStatsController
+    {
+        private string updaterjs = string.Empty;
+
+        public string ReportName
+        {
+            get { return ""; }
+        }
+
+        public Hashtable ProcessModel(Hashtable pParams)
+        {
+            Hashtable pResult = new Hashtable();
+            if (updaterjs.Length == 0)
+            {
+                StreamReader fs = new StreamReader(new FileStream(Util.dataDir() + "/data/updater.js", FileMode.Open));
+                updaterjs = fs.ReadToEnd();
+                fs.Close();
+                fs.Dispose();
+            }
+            pResult["js"] = updaterjs;
+            return pResult;
+        }
+
+        public string RenderView(Hashtable pModelResult)
+        {
+            return pModelResult["js"].ToString();
+        }
+
+        public string RenderJson(Hashtable pModelResult) {
+            return "{}";
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/OptionalModules/UserStatistics/WebStatsModule.cs b/OpenSim/Region/OptionalModules/UserStatistics/WebStatsModule.cs
new file mode 100644
index 0000000..bd5289f
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/UserStatistics/WebStatsModule.cs
@@ -0,0 +1,1203 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Net; // to be used for REST-->Grid shortly
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using Mono.Data.SqliteClient;
+using Mono.Addins;
+
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+using OSD = OpenMetaverse.StructuredData.OSD;
+using OSDMap = OpenMetaverse.StructuredData.OSDMap;
+
+namespace OpenSim.Region.UserStatistics
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "WebStatsModule")]
+    public class WebStatsModule : ISharedRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        private static SqliteConnection dbConn;
+
+        /// <summary>
+        /// User statistics sessions keyed by agent ID
+        /// </summary>
+        private Dictionary<UUID, UserSession> m_sessions = new Dictionary<UUID, UserSession>();
+
+        private List<Scene> m_scenes = new List<Scene>();
+        private Dictionary<string, IStatsController> reports = new Dictionary<string, IStatsController>();
+        private Dictionary<UUID, USimStatsData> m_simstatsCounters = new Dictionary<UUID, USimStatsData>(); 
+        private const int updateStatsMod = 6;
+        private int updateLogMod = 1;
+        private volatile int updateLogCounter = 0;
+        private volatile int concurrencyCounter = 0;
+        private bool enabled = false;
+        private string m_loglines = String.Empty;
+        private volatile int lastHit = 12000;
+
+        #region ISharedRegionModule
+
+        public virtual void Initialise(IConfigSource config)
+        {
+            IConfig cnfg = config.Configs["WebStats"];
+
+            if (cnfg != null)
+                enabled = cnfg.GetBoolean("enabled", false);
+        }
+
+        public virtual void PostInitialise()
+        {
+            if (!enabled)
+                return;
+
+            if (Util.IsWindows())
+                Util.LoadArchSpecificWindowsDll("sqlite3.dll");
+
+            //IConfig startupConfig = config.Configs["Startup"];
+
+            dbConn = new SqliteConnection("URI=file:LocalUserStatistics.db,version=3");
+            dbConn.Open();
+            CreateTables(dbConn);
+
+            Prototype_distributor protodep = new Prototype_distributor();
+            Updater_distributor updatedep = new Updater_distributor();
+            ActiveConnectionsAJAX ajConnections = new ActiveConnectionsAJAX();
+            SimStatsAJAX ajSimStats = new SimStatsAJAX();
+            LogLinesAJAX ajLogLines = new LogLinesAJAX();
+            Default_Report defaultReport = new Default_Report();
+            Clients_report clientReport = new Clients_report();
+            Sessions_Report sessionsReport = new Sessions_Report();
+
+            reports.Add("prototype.js", protodep);
+            reports.Add("updater.js", updatedep);
+            reports.Add("activeconnectionsajax.html", ajConnections);
+            reports.Add("simstatsajax.html", ajSimStats);
+            reports.Add("activelogajax.html", ajLogLines);
+            reports.Add("default.report", defaultReport);
+            reports.Add("clients.report", clientReport);
+            reports.Add("sessions.report", sessionsReport);
+
+            reports.Add("sim.css", new Prototype_distributor("sim.css"));
+            reports.Add("sim.html", new Prototype_distributor("sim.html"));
+            reports.Add("jquery.js", new Prototype_distributor("jquery.js"));
+
+            ////
+            // Add Your own Reports here (Do Not Modify Lines here Devs!)
+            ////
+
+            ////
+            // End Own reports section
+            ////
+
+            MainServer.Instance.AddHTTPHandler("/SStats/", HandleStatsRequest);
+            MainServer.Instance.AddHTTPHandler("/CAPS/VS/", HandleUnknownCAPSRequest);
+        }
+
+        public virtual void AddRegion(Scene scene)
+        {
+            if (!enabled)
+                return;
+
+            lock (m_scenes)
+            {
+                m_scenes.Add(scene);
+                updateLogMod = m_scenes.Count * 2;
+
+                m_simstatsCounters.Add(scene.RegionInfo.RegionID, new USimStatsData(scene.RegionInfo.RegionID));
+
+                scene.EventManager.OnRegisterCaps += OnRegisterCaps;
+                scene.EventManager.OnDeregisterCaps += OnDeRegisterCaps;
+                scene.EventManager.OnClientClosed += OnClientClosed;
+                scene.EventManager.OnMakeRootAgent += OnMakeRootAgent;
+                scene.StatsReporter.OnSendStatsResult += ReceiveClassicSimStatsPacket;
+            }
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!enabled)
+                return;
+
+            lock (m_scenes)
+            {
+                m_scenes.Remove(scene);
+                updateLogMod = m_scenes.Count * 2;
+                m_simstatsCounters.Remove(scene.RegionInfo.RegionID);
+            }
+        }
+
+        public virtual void Close()
+        {
+            if (!enabled)
+                return;
+
+            dbConn.Close();
+            dbConn.Dispose();
+            m_sessions.Clear();
+            m_scenes.Clear();
+            reports.Clear();
+            m_simstatsCounters.Clear();
+        }
+
+        public virtual string Name
+        {
+            get { return "ViewerStatsModule"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        private void ReceiveClassicSimStatsPacket(SimStats stats)
+        {
+            if (!enabled)
+                return;
+
+            try
+            {
+                // Ignore the update if there's a report running right now
+                // ignore the update if there hasn't been a hit in 30 seconds.
+                if (concurrencyCounter > 0 || System.Environment.TickCount - lastHit > 30000)
+                    return;
+
+                // We will conduct this under lock so that fields such as updateLogCounter do not potentially get
+                // confused if a scene is removed.
+                // XXX: Possibly the scope of this lock could be reduced though it's not critical.
+                lock (m_scenes)
+                {
+                    if (updateLogMod != 0 && updateLogCounter++ % updateLogMod == 0)
+                    {
+                        m_loglines = readLogLines(10);
+
+                        if (updateLogCounter > 10000) 
+                            updateLogCounter = 1;
+                    }
+
+                    USimStatsData ss = m_simstatsCounters[stats.RegionUUID];
+
+                    if ((++ss.StatsCounter % updateStatsMod) == 0)
+                    {
+                        ss.ConsumeSimStats(stats);
+                    }
+                }
+            } 
+            catch (KeyNotFoundException)
+            {
+            }
+        }
+        
+        private Hashtable HandleUnknownCAPSRequest(Hashtable request)
+        {
+            //string regpath = request["uri"].ToString();
+            int response_code = 200;
+            string contenttype = "text/html";
+            UpdateUserStats(ParseViewerStats(request["body"].ToString(), UUID.Zero), dbConn);
+            Hashtable responsedata = new Hashtable();
+
+            responsedata["int_response_code"] = response_code;
+            responsedata["content_type"] = contenttype;
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = string.Empty;
+            return responsedata;
+        }
+
+        private Hashtable HandleStatsRequest(Hashtable request)
+        {
+            lastHit = System.Environment.TickCount;
+            Hashtable responsedata = new Hashtable();
+            string regpath = request["uri"].ToString();
+            int response_code = 404;
+            string contenttype = "text/html";
+            bool jsonFormatOutput = false;
+            
+            string strOut = string.Empty;
+
+            // The request patch should be "/SStats/reportName" where 'reportName'
+            // is one of the names added to the 'reports' hashmap.
+            regpath = regpath.Remove(0, 8);
+            if (regpath.Length == 0) regpath = "default.report";
+            if (reports.ContainsKey(regpath))
+            {
+                IStatsController rep = reports[regpath];
+                Hashtable repParams = new Hashtable();
+
+                if (request.ContainsKey("json"))
+                    jsonFormatOutput = true;
+
+                if (request.ContainsKey("requestvars"))
+                    repParams["RequestVars"] = request["requestvars"];
+                else
+                    repParams["RequestVars"] = new Hashtable();
+
+                if (request.ContainsKey("querystringkeys"))
+                    repParams["QueryStringKeys"] = request["querystringkeys"];
+                else
+                    repParams["QueryStringKeys"] = new string[0];
+
+
+                repParams["DatabaseConnection"] = dbConn;
+                repParams["Scenes"] = m_scenes;
+                repParams["SimStats"] = m_simstatsCounters;
+                repParams["LogLines"] = m_loglines;
+                repParams["Reports"] = reports;
+                
+                concurrencyCounter++;
+
+                if (jsonFormatOutput) 
+                {
+                    strOut = rep.RenderJson(rep.ProcessModel(repParams));
+                    contenttype = "text/json";
+                }
+                else 
+                {
+                    strOut = rep.RenderView(rep.ProcessModel(repParams));
+                }
+
+                if (regpath.EndsWith("js"))
+                {
+                    contenttype = "text/javascript";
+                }
+
+                if (regpath.EndsWith("css"))
+                {
+                    contenttype = "text/css";
+                }
+
+                concurrencyCounter--;
+                
+                response_code = 200;
+            }
+            else
+            {
+                strOut = MainServer.Instance.GetHTTP404("");
+            }
+
+            responsedata["int_response_code"] = response_code;
+            responsedata["content_type"] = contenttype;
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = strOut;
+
+            return responsedata;
+        }
+
+        private void CreateTables(SqliteConnection db)
+        {
+            using (SqliteCommand createcmd = new SqliteCommand(SQL_STATS_TABLE_CREATE, db))
+            {
+                createcmd.ExecuteNonQuery();
+            }
+        }
+
+        private void OnRegisterCaps(UUID agentID, Caps caps)
+        {
+//            m_log.DebugFormat("[WEB STATS MODULE]: OnRegisterCaps: agentID {0} caps {1}", agentID, caps);
+
+            string capsPath = "/CAPS/VS/" + UUID.Random();
+            caps.RegisterHandler(
+                "ViewerStats",
+                new RestStreamHandler(
+                    "POST",
+                    capsPath,
+                    (request, path, param, httpRequest, httpResponse)
+                        => ViewerStatsReport(request, path, param, agentID, caps),
+                    "ViewerStats",
+                    agentID.ToString()));
+        }
+
+        private void OnDeRegisterCaps(UUID agentID, Caps caps)
+        {
+        }
+
+        protected virtual void AddEventHandlers()
+        {
+            lock (m_scenes)
+            {
+                updateLogMod = m_scenes.Count * 2;
+                foreach (Scene scene in m_scenes)
+                {
+                    scene.EventManager.OnRegisterCaps += OnRegisterCaps;
+                    scene.EventManager.OnDeregisterCaps += OnDeRegisterCaps;
+                    scene.EventManager.OnClientClosed += OnClientClosed;
+                    scene.EventManager.OnMakeRootAgent += OnMakeRootAgent;
+                }
+            }
+        }
+
+        private void OnMakeRootAgent(ScenePresence agent)
+        {
+//            m_log.DebugFormat(
+//                "[WEB STATS MODULE]: Looking for session {0} for {1} in {2}",
+//                agent.ControllingClient.SessionId, agent.Name, agent.Scene.Name);
+
+            lock (m_sessions)
+            {
+                UserSession uid;
+
+                if (!m_sessions.ContainsKey(agent.UUID))
+                {
+                    UserSessionData usd = UserSessionUtil.newUserSessionData();
+                    uid = new UserSession();
+                    uid.name_f = agent.Firstname;
+                    uid.name_l = agent.Lastname;
+                    uid.session_data = usd;
+
+                    m_sessions.Add(agent.UUID, uid);
+                }
+                else
+                {
+                    uid = m_sessions[agent.UUID];
+                }
+
+                uid.region_id = agent.Scene.RegionInfo.RegionID;
+                uid.session_id = agent.ControllingClient.SessionId;
+            }
+        }
+
+        private void OnClientClosed(UUID agentID, Scene scene)
+        {
+            lock (m_sessions)
+            {
+                if (m_sessions.ContainsKey(agentID) && m_sessions[agentID].region_id == scene.RegionInfo.RegionID)
+                {
+                    m_sessions.Remove(agentID);
+                }
+            }
+        }
+
+        private string readLogLines(int amount)
+        {
+            Encoding encoding = Encoding.ASCII;
+            int sizeOfChar = encoding.GetByteCount("\n");
+            byte[] buffer = encoding.GetBytes("\n");
+            string logfile = Util.logFile();
+            FileStream fs = new FileStream(logfile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            Int64 tokenCount = 0;
+            Int64 endPosition = fs.Length / sizeOfChar;
+
+            for (Int64 position = sizeOfChar; position < endPosition; position += sizeOfChar)
+            {
+                fs.Seek(-position, SeekOrigin.End);
+                fs.Read(buffer, 0, buffer.Length);
+
+                if (encoding.GetString(buffer) == "\n")
+                {
+                    tokenCount++;
+                    if (tokenCount == amount)
+                    {
+                        byte[] returnBuffer = new byte[fs.Length - fs.Position];
+                        fs.Read(returnBuffer, 0, returnBuffer.Length);
+                        fs.Close();
+                        fs.Dispose();
+                        return encoding.GetString(returnBuffer);
+                    }
+                }
+            }
+
+            // handle case where number of tokens in file is less than numberOfTokens
+            fs.Seek(0, SeekOrigin.Begin);
+            buffer = new byte[fs.Length];
+            fs.Read(buffer, 0, buffer.Length);
+            fs.Close();
+            fs.Dispose();
+            return encoding.GetString(buffer);
+        }
+
+        /// <summary>
+        /// Callback for a viewerstats cap
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="agentID"></param>
+        /// <param name="caps"></param>
+        /// <returns></returns>
+        private string ViewerStatsReport(string request, string path, string param,
+                                      UUID agentID, Caps caps)
+        {
+//            m_log.DebugFormat("[WEB STATS MODULE]: Received viewer starts report from {0}", agentID);
+ 
+            UpdateUserStats(ParseViewerStats(request, agentID), dbConn);
+
+            return String.Empty;
+        }
+
+        private UserSession ParseViewerStats(string request, UUID agentID)
+        {
+            UserSession uid = new UserSession();
+            UserSessionData usd;
+            OSD message = OSDParser.DeserializeLLSDXml(request);
+            OSDMap mmap;
+
+            lock (m_sessions)
+            {
+                if (agentID != UUID.Zero)
+                {
+                    if (!m_sessions.ContainsKey(agentID))
+                    {
+                        m_log.WarnFormat("[WEB STATS MODULE]: no session for stat disclosure for agent {0}", agentID);
+                        return new UserSession();
+                    }
+
+                    uid = m_sessions[agentID];
+
+//                    m_log.DebugFormat("[WEB STATS MODULE]: Got session {0} for {1}", uid.session_id, agentID);
+                }
+                else
+                {
+                    // parse through the beginning to locate the session
+                    if (message.Type != OSDType.Map)
+                        return new UserSession();
+
+                    mmap = (OSDMap)message;
+                    {
+                        UUID sessionID = mmap["session_id"].AsUUID();
+
+                        if (sessionID == UUID.Zero)
+                            return new UserSession();
+
+
+                        // search through each session looking for the owner
+                        foreach (UUID usersessionid in m_sessions.Keys)
+                        {
+                            // got it!
+                            if (m_sessions[usersessionid].session_id == sessionID)
+                            {
+                                agentID = usersessionid;
+                                uid = m_sessions[usersessionid];
+                                break;
+                            }
+
+                        }
+
+                        // can't find a session
+                        if (agentID == UUID.Zero)
+                        {
+                            return new UserSession();
+                        }
+                    }
+                }
+            }
+           
+            usd = uid.session_data;
+
+            if (message.Type != OSDType.Map)
+                return new UserSession();
+
+            mmap = (OSDMap)message;
+            {
+                if (mmap["agent"].Type != OSDType.Map)
+                    return new UserSession();
+                OSDMap agent_map = (OSDMap)mmap["agent"];
+                usd.agent_id = agentID;
+                usd.name_f = uid.name_f;
+                usd.name_l = uid.name_l;
+                usd.region_id = uid.region_id;
+                usd.a_language = agent_map["language"].AsString();
+                usd.mem_use = (float)agent_map["mem_use"].AsReal();
+                usd.meters_traveled = (float)agent_map["meters_traveled"].AsReal();
+                usd.regions_visited = agent_map["regions_visited"].AsInteger();
+                usd.run_time = (float)agent_map["run_time"].AsReal();
+                usd.start_time = (float)agent_map["start_time"].AsReal();
+                usd.client_version = agent_map["version"].AsString();
+
+                UserSessionUtil.UpdateMultiItems(ref usd, agent_map["agents_in_view"].AsInteger(),
+                                                 (float)agent_map["ping"].AsReal(),
+                                                 (float)agent_map["sim_fps"].AsReal(),
+                                                 (float)agent_map["fps"].AsReal());
+
+                if (mmap["downloads"].Type != OSDType.Map)
+                    return new UserSession();
+                OSDMap downloads_map = (OSDMap)mmap["downloads"];
+                usd.d_object_kb = (float)downloads_map["object_kbytes"].AsReal();
+                usd.d_texture_kb = (float)downloads_map["texture_kbytes"].AsReal();
+                usd.d_world_kb = (float)downloads_map["workd_kbytes"].AsReal();
+
+//                m_log.DebugFormat("[WEB STATS MODULE]: mmap[\"session_id\"] = [{0}]", mmap["session_id"].AsUUID());
+
+                usd.session_id = mmap["session_id"].AsUUID();
+
+                if (mmap["system"].Type != OSDType.Map)
+                    return new UserSession();
+                OSDMap system_map = (OSDMap)mmap["system"];
+
+                usd.s_cpu = system_map["cpu"].AsString();
+                usd.s_gpu = system_map["gpu"].AsString();
+                usd.s_os = system_map["os"].AsString();
+                usd.s_ram = system_map["ram"].AsInteger();
+
+                if (mmap["stats"].Type != OSDType.Map)
+                    return new UserSession();
+
+                OSDMap stats_map = (OSDMap)mmap["stats"];
+                {
+
+                    if (stats_map["failures"].Type != OSDType.Map)
+                        return new UserSession();
+                    OSDMap stats_failures = (OSDMap)stats_map["failures"];
+                    usd.f_dropped = stats_failures["dropped"].AsInteger();
+                    usd.f_failed_resends = stats_failures["failed_resends"].AsInteger();
+                    usd.f_invalid = stats_failures["invalid"].AsInteger();
+                    usd.f_resent = stats_failures["resent"].AsInteger();
+                    usd.f_send_packet = stats_failures["send_packet"].AsInteger();
+
+                    if (stats_map["net"].Type != OSDType.Map)
+                        return new UserSession();
+                    OSDMap stats_net = (OSDMap)stats_map["net"];
+                    {
+                        if (stats_net["in"].Type != OSDType.Map)
+                            return new UserSession();
+
+                        OSDMap net_in = (OSDMap)stats_net["in"];
+                        usd.n_in_kb = (float)net_in["kbytes"].AsReal();
+                        usd.n_in_pk = net_in["packets"].AsInteger();
+
+                        if (stats_net["out"].Type != OSDType.Map)
+                            return new UserSession();
+                        OSDMap net_out = (OSDMap)stats_net["out"];
+
+                        usd.n_out_kb = (float)net_out["kbytes"].AsReal();
+                        usd.n_out_pk = net_out["packets"].AsInteger();
+                    }
+                }
+            }
+
+            uid.session_data = usd;
+            m_sessions[agentID] = uid;
+
+//            m_log.DebugFormat(
+//                "[WEB STATS MODULE]: Parse data for {0} {1}, session {2}", uid.name_f, uid.name_l, uid.session_id);
+
+            return uid;
+        }
+
+        private void UpdateUserStats(UserSession uid, SqliteConnection db)
+        {
+//            m_log.DebugFormat(
+//                "[WEB STATS MODULE]: Updating user stats for {0} {1}, session {2}", uid.name_f, uid.name_l, uid.session_id);
+
+            if (uid.session_id == UUID.Zero)
+                return;
+
+            lock (db)
+            {
+                using (SqliteCommand updatecmd = new SqliteCommand(SQL_STATS_TABLE_INSERT, db))
+                {
+                    updatecmd.Parameters.Add(new SqliteParameter(":session_id", uid.session_data.session_id.ToString()));
+                    updatecmd.Parameters.Add(new SqliteParameter(":agent_id", uid.session_data.agent_id.ToString()));
+                    updatecmd.Parameters.Add(new SqliteParameter(":region_id", uid.session_data.region_id.ToString()));
+                    updatecmd.Parameters.Add(new SqliteParameter(":last_updated", (int) uid.session_data.last_updated));
+                    updatecmd.Parameters.Add(new SqliteParameter(":remote_ip", uid.session_data.remote_ip));
+                    updatecmd.Parameters.Add(new SqliteParameter(":name_f", uid.session_data.name_f));
+                    updatecmd.Parameters.Add(new SqliteParameter(":name_l", uid.session_data.name_l));
+                    updatecmd.Parameters.Add(new SqliteParameter(":avg_agents_in_view", uid.session_data.avg_agents_in_view));
+                    updatecmd.Parameters.Add(new SqliteParameter(":min_agents_in_view",
+                                                                 (int) uid.session_data.min_agents_in_view));
+                    updatecmd.Parameters.Add(new SqliteParameter(":max_agents_in_view",
+                                                                 (int) uid.session_data.max_agents_in_view));
+                    updatecmd.Parameters.Add(new SqliteParameter(":mode_agents_in_view",
+                                                                 (int) uid.session_data.mode_agents_in_view));
+                    updatecmd.Parameters.Add(new SqliteParameter(":avg_fps", uid.session_data.avg_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":min_fps", uid.session_data.min_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":max_fps", uid.session_data.max_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":mode_fps", uid.session_data.mode_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":a_language", uid.session_data.a_language));
+                    updatecmd.Parameters.Add(new SqliteParameter(":mem_use", uid.session_data.mem_use));
+                    updatecmd.Parameters.Add(new SqliteParameter(":meters_traveled", uid.session_data.meters_traveled));
+                    updatecmd.Parameters.Add(new SqliteParameter(":avg_ping", uid.session_data.avg_ping));
+                    updatecmd.Parameters.Add(new SqliteParameter(":min_ping", uid.session_data.min_ping));
+                    updatecmd.Parameters.Add(new SqliteParameter(":max_ping", uid.session_data.max_ping));
+                    updatecmd.Parameters.Add(new SqliteParameter(":mode_ping", uid.session_data.mode_ping));
+                    updatecmd.Parameters.Add(new SqliteParameter(":regions_visited", uid.session_data.regions_visited));
+                    updatecmd.Parameters.Add(new SqliteParameter(":run_time", uid.session_data.run_time));
+                    updatecmd.Parameters.Add(new SqliteParameter(":avg_sim_fps", uid.session_data.avg_sim_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":min_sim_fps", uid.session_data.min_sim_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":max_sim_fps", uid.session_data.max_sim_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":mode_sim_fps", uid.session_data.mode_sim_fps));
+                    updatecmd.Parameters.Add(new SqliteParameter(":start_time", uid.session_data.start_time));
+                    updatecmd.Parameters.Add(new SqliteParameter(":client_version", uid.session_data.client_version));
+                    updatecmd.Parameters.Add(new SqliteParameter(":s_cpu", uid.session_data.s_cpu));
+                    updatecmd.Parameters.Add(new SqliteParameter(":s_gpu", uid.session_data.s_gpu));
+                    updatecmd.Parameters.Add(new SqliteParameter(":s_os", uid.session_data.s_os));
+                    updatecmd.Parameters.Add(new SqliteParameter(":s_ram", uid.session_data.s_ram));
+                    updatecmd.Parameters.Add(new SqliteParameter(":d_object_kb", uid.session_data.d_object_kb));
+                    updatecmd.Parameters.Add(new SqliteParameter(":d_texture_kb", uid.session_data.d_texture_kb));
+                    updatecmd.Parameters.Add(new SqliteParameter(":d_world_kb", uid.session_data.d_world_kb));
+                    updatecmd.Parameters.Add(new SqliteParameter(":n_in_kb", uid.session_data.n_in_kb));
+                    updatecmd.Parameters.Add(new SqliteParameter(":n_in_pk", uid.session_data.n_in_pk));
+                    updatecmd.Parameters.Add(new SqliteParameter(":n_out_kb", uid.session_data.n_out_kb));
+                    updatecmd.Parameters.Add(new SqliteParameter(":n_out_pk", uid.session_data.n_out_pk));
+                    updatecmd.Parameters.Add(new SqliteParameter(":f_dropped", uid.session_data.f_dropped));
+                    updatecmd.Parameters.Add(new SqliteParameter(":f_failed_resends", uid.session_data.f_failed_resends));
+                    updatecmd.Parameters.Add(new SqliteParameter(":f_invalid", uid.session_data.f_invalid));
+                    updatecmd.Parameters.Add(new SqliteParameter(":f_off_circuit", uid.session_data.f_off_circuit));
+                    updatecmd.Parameters.Add(new SqliteParameter(":f_resent", uid.session_data.f_resent));
+                    updatecmd.Parameters.Add(new SqliteParameter(":f_send_packet", uid.session_data.f_send_packet));
+
+//                        StringBuilder parameters = new StringBuilder();
+//                        SqliteParameterCollection spc = updatecmd.Parameters;
+//                        foreach (SqliteParameter sp in spc)
+//                            parameters.AppendFormat("{0}={1},", sp.ParameterName, sp.Value);
+//
+//                        m_log.DebugFormat("[WEB STATS MODULE]: Parameters {0}", parameters);
+
+//                    m_log.DebugFormat("[WEB STATS MODULE]: Database stats update for {0}", uid.session_data.agent_id);
+
+                    updatecmd.ExecuteNonQuery();
+                }
+            }
+        }
+
+        #region SQL
+        private const string SQL_STATS_TABLE_CREATE = @"CREATE TABLE IF NOT EXISTS stats_session_data (
+               session_id VARCHAR(36) NOT NULL PRIMARY KEY,
+               agent_id VARCHAR(36) NOT NULL DEFAULT '',
+               region_id VARCHAR(36) NOT NULL DEFAULT '',
+               last_updated INT NOT NULL DEFAULT '0',
+               remote_ip VARCHAR(16) NOT NULL DEFAULT '',
+               name_f VARCHAR(50) NOT NULL DEFAULT '',
+               name_l VARCHAR(50) NOT NULL DEFAULT '',
+               avg_agents_in_view FLOAT NOT NULL DEFAULT '0',
+               min_agents_in_view INT NOT NULL DEFAULT '0',
+               max_agents_in_view INT NOT NULL DEFAULT '0',
+               mode_agents_in_view INT NOT NULL DEFAULT '0',
+               avg_fps FLOAT NOT NULL DEFAULT '0',
+               min_fps FLOAT NOT NULL DEFAULT '0',
+               max_fps FLOAT NOT NULL DEFAULT '0',
+               mode_fps FLOAT NOT NULL DEFAULT '0',
+               a_language VARCHAR(25) NOT NULL DEFAULT '',
+               mem_use FLOAT NOT NULL DEFAULT '0',
+               meters_traveled FLOAT NOT NULL DEFAULT '0',
+               avg_ping FLOAT NOT NULL DEFAULT '0',
+               min_ping FLOAT NOT NULL DEFAULT '0',
+               max_ping FLOAT NOT NULL DEFAULT '0',
+               mode_ping FLOAT NOT NULL DEFAULT '0',
+               regions_visited INT NOT NULL DEFAULT '0',
+               run_time FLOAT NOT NULL DEFAULT '0',
+               avg_sim_fps FLOAT NOT NULL DEFAULT '0',
+               min_sim_fps FLOAT NOT NULL DEFAULT '0',
+               max_sim_fps FLOAT NOT NULL DEFAULT '0',
+               mode_sim_fps FLOAT NOT NULL DEFAULT '0',
+               start_time FLOAT NOT NULL DEFAULT '0',
+               client_version VARCHAR(255) NOT NULL DEFAULT '',
+               s_cpu VARCHAR(255) NOT NULL DEFAULT '',
+               s_gpu VARCHAR(255) NOT NULL DEFAULT '',
+               s_os VARCHAR(2255) NOT NULL DEFAULT '',
+               s_ram INT NOT NULL DEFAULT '0',
+               d_object_kb FLOAT NOT NULL DEFAULT '0',
+               d_texture_kb FLOAT NOT NULL DEFAULT '0',
+               d_world_kb FLOAT NOT NULL DEFAULT '0',
+               n_in_kb FLOAT NOT NULL DEFAULT '0',
+               n_in_pk INT NOT NULL DEFAULT '0',
+               n_out_kb FLOAT NOT NULL DEFAULT '0',
+               n_out_pk INT NOT NULL DEFAULT '0',
+               f_dropped INT NOT NULL DEFAULT '0',
+               f_failed_resends INT NOT NULL DEFAULT '0',
+               f_invalid INT NOT NULL DEFAULT '0',
+               f_off_circuit INT NOT NULL DEFAULT '0',
+               f_resent INT NOT NULL DEFAULT '0',
+               f_send_packet INT NOT NULL DEFAULT '0'
+            );";
+
+        private const string SQL_STATS_TABLE_INSERT = @"INSERT OR REPLACE INTO stats_session_data (
+session_id, agent_id, region_id, last_updated, remote_ip, name_f, name_l, avg_agents_in_view, min_agents_in_view, max_agents_in_view, 
+mode_agents_in_view, avg_fps, min_fps, max_fps, mode_fps, a_language, mem_use, meters_traveled, avg_ping, min_ping, max_ping, mode_ping, 
+regions_visited, run_time, avg_sim_fps, min_sim_fps, max_sim_fps, mode_sim_fps, start_time, client_version, s_cpu, s_gpu, s_os, s_ram,
+d_object_kb, d_texture_kb, d_world_kb, n_in_kb, n_in_pk, n_out_kb, n_out_pk, f_dropped, f_failed_resends, f_invalid, f_off_circuit,
+f_resent, f_send_packet
+)
+VALUES
+(
+:session_id, :agent_id, :region_id, :last_updated, :remote_ip, :name_f, :name_l, :avg_agents_in_view, :min_agents_in_view, :max_agents_in_view, 
+:mode_agents_in_view, :avg_fps, :min_fps, :max_fps, :mode_fps, :a_language, :mem_use, :meters_traveled, :avg_ping, :min_ping, :max_ping, :mode_ping, 
+:regions_visited, :run_time, :avg_sim_fps, :min_sim_fps, :max_sim_fps, :mode_sim_fps, :start_time, :client_version, :s_cpu, :s_gpu, :s_os, :s_ram,
+:d_object_kb, :d_texture_kb, :d_world_kb, :n_in_kb, :n_in_pk, :n_out_kb, :n_out_pk, :f_dropped, :f_failed_resends, :f_invalid, :f_off_circuit,
+:f_resent, :f_send_packet
+)
+";
+
+    #endregion
+
+    }
+
+    public static class UserSessionUtil
+    {
+        public static UserSessionData newUserSessionData()
+        {
+            UserSessionData obj = ZeroSession(new UserSessionData());
+            return obj;
+        }
+
+        public static void UpdateMultiItems(ref UserSessionData s, int agents_in_view, float ping, float sim_fps, float fps)
+        {
+            // don't insert zero values here or it'll skew the statistics.
+            if (agents_in_view == 0 && fps == 0 && sim_fps == 0 && ping == 0)
+                return;
+            s._agents_in_view.Add(agents_in_view);
+            s._fps.Add(fps);
+            s._sim_fps.Add(sim_fps);
+            s._ping.Add(ping);
+
+            int[] __agents_in_view = s._agents_in_view.ToArray();
+
+            s.avg_agents_in_view = ArrayAvg_i(__agents_in_view);
+            s.min_agents_in_view = ArrayMin_i(__agents_in_view);
+            s.max_agents_in_view = ArrayMax_i(__agents_in_view);
+            s.mode_agents_in_view = ArrayMode_i(__agents_in_view);
+
+            float[] __fps = s._fps.ToArray();
+            s.avg_fps = ArrayAvg_f(__fps);
+            s.min_fps = ArrayMin_f(__fps);
+            s.max_fps = ArrayMax_f(__fps);
+            s.mode_fps = ArrayMode_f(__fps);
+
+            float[] __sim_fps = s._sim_fps.ToArray();
+            s.avg_sim_fps = ArrayAvg_f(__sim_fps);
+            s.min_sim_fps = ArrayMin_f(__sim_fps);
+            s.max_sim_fps = ArrayMax_f(__sim_fps);
+            s.mode_sim_fps = ArrayMode_f(__sim_fps);
+
+            float[] __ping = s._ping.ToArray();
+            s.avg_ping = ArrayAvg_f(__ping);
+            s.min_ping = ArrayMin_f(__ping);
+            s.max_ping = ArrayMax_f(__ping);
+            s.mode_ping = ArrayMode_f(__ping);
+        }
+
+        #region Statistics
+
+        public static int ArrayMin_i(int[] arr)
+        {
+            int cnt = arr.Length;
+            if (cnt == 0)
+                return 0;
+
+            Array.Sort(arr);
+            return arr[0];
+        }
+
+        public static int ArrayMax_i(int[] arr)
+        {
+            int cnt = arr.Length;
+            if (cnt == 0)
+                return 0;
+
+            Array.Sort(arr);
+            return arr[cnt-1];
+        }
+
+        public static float ArrayMin_f(float[] arr)
+        {
+            int cnt = arr.Length;
+            if (cnt == 0)
+                return 0;
+
+            Array.Sort(arr);
+            return arr[0];
+        }
+
+        public static float ArrayMax_f(float[] arr)
+        {
+            int cnt = arr.Length;
+            if (cnt == 0)
+                return 0;
+
+            Array.Sort(arr);
+            return arr[cnt - 1];
+        }
+
+        public static float ArrayAvg_i(int[] arr)
+        {
+            int cnt = arr.Length;
+
+            if (cnt == 0)
+                return 0;
+
+            float result = arr[0];
+
+            for (int i = 1; i < cnt; i++)
+                result += arr[i];
+
+            return result / cnt;
+        }
+
+        public static float ArrayAvg_f(float[] arr)
+        {
+            int cnt = arr.Length;
+
+            if (cnt == 0)
+                return 0;
+
+            float result = arr[0];
+
+            for (int i = 1; i < cnt; i++)
+                result += arr[i];
+
+            return result / cnt;
+        }
+
+        public static float ArrayMode_f(float[] arr)
+        {
+            List<float> mode = new List<float>();
+
+            float[] srtArr = new float[arr.Length];
+            float[,] freq = new float[arr.Length, 2];
+            Array.Copy(arr, srtArr, arr.Length);
+            Array.Sort(srtArr);
+
+            float tmp = srtArr[0];
+            int index = 0;
+            int i = 0;
+            while (i < srtArr.Length)
+            {
+                freq[index, 0] = tmp;
+
+                while (tmp == srtArr[i])
+                {
+                    freq[index, 1]++;
+                    i++;
+
+                    if (i > srtArr.Length - 1)
+                        break;
+                }
+
+                if (i < srtArr.Length)
+                {
+                    tmp = srtArr[i];
+                    index++;
+                }
+
+            }
+
+            Array.Clear(srtArr, 0, srtArr.Length);
+
+            for (i = 0; i < srtArr.Length; i++)
+                srtArr[i] = freq[i, 1];
+
+            Array.Sort(srtArr);
+
+            if ((srtArr[srtArr.Length - 1]) == 0 || (srtArr[srtArr.Length - 1]) == 1)
+                return 0;
+
+            float freqtest = (float)freq.Length / freq.Rank;
+
+            for (i = 0; i < freqtest; i++)
+            {
+                if (freq[i, 1] == srtArr[index])
+                    mode.Add(freq[i, 0]);
+
+            }
+
+            return mode.ToArray()[0];
+        }
+
+        public static int ArrayMode_i(int[] arr)
+        {
+            List<int> mode = new List<int>();
+
+            int[] srtArr = new int[arr.Length];
+            int[,] freq = new int[arr.Length, 2];
+            Array.Copy(arr, srtArr, arr.Length);
+            Array.Sort(srtArr);
+
+            int tmp = srtArr[0];
+            int index = 0;
+            int i = 0;
+            while (i < srtArr.Length)
+            {
+                freq[index, 0] = tmp;
+
+                while (tmp == srtArr[i])
+                {
+                    freq[index, 1]++;
+                    i++;
+
+                    if (i > srtArr.Length - 1)
+                        break;
+                }
+
+                if (i < srtArr.Length)
+                {
+                    tmp = srtArr[i];
+                    index++;
+                }
+
+            }
+
+            Array.Clear(srtArr, 0, srtArr.Length);
+
+            for (i = 0; i < srtArr.Length; i++)
+                srtArr[i] = freq[i, 1];
+
+            Array.Sort(srtArr);
+
+            if ((srtArr[srtArr.Length - 1]) == 0 || (srtArr[srtArr.Length - 1]) == 1)
+                return 0;
+           
+            float freqtest = (float)freq.Length / freq.Rank;
+
+            for (i = 0; i < freqtest; i++)
+            {
+                if (freq[i, 1] == srtArr[index])
+                    mode.Add(freq[i, 0]);
+
+            }
+
+            return mode.ToArray()[0];
+        }
+
+        #endregion
+
+        private static UserSessionData ZeroSession(UserSessionData s)
+        {
+            s.session_id = UUID.Zero;
+            s.agent_id = UUID.Zero;
+            s.region_id = UUID.Zero;
+            s.last_updated = Util.UnixTimeSinceEpoch();
+            s.remote_ip = "";
+            s.name_f = "";
+            s.name_l = "";
+            s.avg_agents_in_view = 0;
+            s.min_agents_in_view = 0;
+            s.max_agents_in_view = 0;
+            s.mode_agents_in_view = 0;
+            s.avg_fps = 0;
+            s.min_fps = 0;
+            s.max_fps = 0;
+            s.mode_fps = 0;
+            s.a_language = "";
+            s.mem_use = 0;
+            s.meters_traveled = 0;
+            s.avg_ping = 0;
+            s.min_ping = 0;
+            s.max_ping = 0;
+            s.mode_ping = 0;
+            s.regions_visited = 0;
+            s.run_time = 0;
+            s.avg_sim_fps = 0;
+            s.min_sim_fps = 0;
+            s.max_sim_fps = 0;
+            s.mode_sim_fps = 0;
+            s.start_time = 0;
+            s.client_version = "";
+            s.s_cpu = "";
+            s.s_gpu = "";
+            s.s_os = "";
+            s.s_ram = 0;
+            s.d_object_kb = 0;
+            s.d_texture_kb = 0;
+            s.d_world_kb = 0;
+            s.n_in_kb = 0;
+            s.n_in_pk = 0;
+            s.n_out_kb = 0;
+            s.n_out_pk = 0;
+            s.f_dropped = 0;
+            s.f_failed_resends = 0;
+            s.f_invalid = 0;
+            s.f_off_circuit = 0;
+            s.f_resent = 0;
+            s.f_send_packet = 0;
+            s._ping = new List<float>();
+            s._fps = new List<float>();
+            s._sim_fps = new List<float>();
+            s._agents_in_view = new List<int>();
+            return s;
+        }
+    }
+    #region structs
+
+    public class UserSession
+    {
+        public UUID session_id;
+        public UUID region_id;
+        public string name_f;
+        public string name_l;
+        public UserSessionData session_data;
+    }
+
+    public struct UserSessionData
+    {
+        public UUID session_id;
+        public UUID agent_id;
+        public UUID region_id;
+        public float last_updated;
+        public string remote_ip;
+        public string name_f;
+        public string name_l;
+        public float avg_agents_in_view;
+        public float min_agents_in_view;
+        public float max_agents_in_view;
+        public float mode_agents_in_view;
+        public float avg_fps;
+        public float min_fps;
+        public float max_fps;
+        public float mode_fps;
+        public string a_language;
+        public float mem_use;
+        public float meters_traveled;
+        public float avg_ping;
+        public float min_ping;
+        public float max_ping;
+        public float mode_ping;
+        public int regions_visited;
+        public float run_time;
+        public float avg_sim_fps;
+        public float min_sim_fps;
+        public float max_sim_fps;
+        public float mode_sim_fps;
+        public float start_time;
+        public string client_version;
+        public string s_cpu;
+        public string s_gpu;
+        public string s_os;
+        public int s_ram;
+        public float d_object_kb;
+        public float d_texture_kb;
+        public float d_world_kb;
+        public float n_in_kb;
+        public int n_in_pk;
+        public float n_out_kb;
+        public int n_out_pk;
+        public int f_dropped;
+        public int f_failed_resends;
+        public int f_invalid;
+        public int f_off_circuit;
+        public int f_resent;
+        public int f_send_packet;
+        public List<float> _ping;
+        public List<float> _fps;
+        public List<float> _sim_fps;
+        public List<int> _agents_in_view;
+    }
+  
+    #endregion
+
+    public class USimStatsData
+    {
+        private UUID m_regionID = UUID.Zero;
+        private volatile int m_statcounter = 0;
+        private volatile float m_timeDilation;
+        private volatile float m_simFps;
+        private volatile float m_physicsFps;
+        private volatile float m_agentUpdates;
+        private volatile float m_rootAgents;
+        private volatile float m_childAgents;
+        private volatile float m_totalPrims;
+        private volatile float m_activePrims;
+        private volatile float m_totalFrameTime;
+        private volatile float m_netFrameTime;
+        private volatile float m_physicsFrameTime;
+        private volatile float m_otherFrameTime;
+        private volatile float m_imageFrameTime;
+        private volatile float m_inPacketsPerSecond;
+        private volatile float m_outPacketsPerSecond;
+        private volatile float m_unackedBytes;
+        private volatile float m_agentFrameTime;
+        private volatile float m_pendingDownloads;
+        private volatile float m_pendingUploads;
+        private volatile float m_activeScripts;
+        private volatile float m_scriptLinesPerSecond;
+
+        public UUID RegionId { get { return m_regionID; } }
+        public int StatsCounter { get { return m_statcounter; } set { m_statcounter = value;}}
+        public float TimeDilation { get { return m_timeDilation; } }
+        public float SimFps { get { return m_simFps; } }
+        public float PhysicsFps { get { return m_physicsFps; } }
+        public float AgentUpdates { get { return m_agentUpdates; } }
+        public float RootAgents { get { return m_rootAgents; } }
+        public float ChildAgents { get { return m_childAgents; } }
+        public float TotalPrims { get { return m_totalPrims; } }
+        public float ActivePrims { get { return m_activePrims; } }
+        public float TotalFrameTime { get { return m_totalFrameTime; } }
+        public float NetFrameTime { get { return m_netFrameTime; } }
+        public float PhysicsFrameTime { get { return m_physicsFrameTime; } }
+        public float OtherFrameTime { get { return m_otherFrameTime; } }
+        public float ImageFrameTime { get { return m_imageFrameTime; } }
+        public float InPacketsPerSecond { get { return m_inPacketsPerSecond; } }
+        public float OutPacketsPerSecond { get { return m_outPacketsPerSecond; } }
+        public float UnackedBytes { get { return m_unackedBytes; } }
+        public float AgentFrameTime { get { return m_agentFrameTime; } }
+        public float PendingDownloads { get { return m_pendingDownloads; } }
+        public float PendingUploads { get { return m_pendingUploads; } }
+        public float ActiveScripts { get { return m_activeScripts; } }
+        public float ScriptLinesPerSecond { get { return m_scriptLinesPerSecond; } }
+
+        public USimStatsData(UUID pRegionID)
+        {
+            m_regionID = pRegionID;
+        }
+
+        public void ConsumeSimStats(SimStats stats)
+        {
+            m_regionID = stats.RegionUUID;
+            m_timeDilation = stats.StatsBlock[0].StatValue;
+            m_simFps = stats.StatsBlock[1].StatValue;
+            m_physicsFps = stats.StatsBlock[2].StatValue;
+            m_agentUpdates = stats.StatsBlock[3].StatValue;
+            m_rootAgents = stats.StatsBlock[4].StatValue;
+            m_childAgents = stats.StatsBlock[5].StatValue;
+            m_totalPrims = stats.StatsBlock[6].StatValue;
+            m_activePrims = stats.StatsBlock[7].StatValue;
+            m_totalFrameTime = stats.StatsBlock[8].StatValue;
+            m_netFrameTime = stats.StatsBlock[9].StatValue;
+            m_physicsFrameTime = stats.StatsBlock[10].StatValue;
+            m_otherFrameTime = stats.StatsBlock[11].StatValue;
+            m_imageFrameTime = stats.StatsBlock[12].StatValue;
+            m_inPacketsPerSecond = stats.StatsBlock[13].StatValue;
+            m_outPacketsPerSecond = stats.StatsBlock[14].StatValue;
+            m_unackedBytes = stats.StatsBlock[15].StatValue;
+            m_agentFrameTime = stats.StatsBlock[16].StatValue;
+            m_pendingDownloads = stats.StatsBlock[17].StatValue;
+            m_pendingUploads = stats.StatsBlock[18].StatValue;
+            m_activeScripts = stats.StatsBlock[19].StatValue;
+            m_scriptLinesPerSecond = stats.ExtraStatsBlock[0].StatValue;
+        }
+    }
+}
\ No newline at end of file