Study.cs

using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;

public partial class Study : MonoBehaviour
{
    private delegate string LogColumnValueProvider ();

    public float MeasureLogInterval;
    public string[] LogHeaderColumns;
    public string[] LogColumns;
    public string LogDateFormat = "yyyy-MM-dd";
    public string LogTimeFormat = "HH:mm:ss";
    public string LogTimeFileNameFormat = "HH-mm-ss";

    static Study _instance;
    static ClientStudyConfig _studyConfig;
    static Dictionary<Enum, string> _logEventFormats = new Dictionary<Enum, string>();
    static List<StreamWriter> _logWriters = new List<StreamWriter>();
    static List<LogColumnValueProvider> _logHeaderColumnValueProviders = new List<LogColumnValueProvider>();
    static List<LogColumnValueProvider> _logColumnValueProviders = new List<LogColumnValueProvider>();
    static int _logTypeColumnIndex = -1;
    static int _logEventColumnIndex = -1;

    public static void LogEvent (Enum eventType, params object[] args)
    {
        if (!_studyConfig.LoggingEnabled)
            return;

        string[] columnValues = GetLogColumnValues();

        if (_logTypeColumnIndex > -1 && _logTypeColumnIndex < columnValues.Length)
            columnValues[_logTypeColumnIndex] = "E";

        if (_logEventColumnIndex > -1 && _logEventColumnIndex < columnValues.Length)
            columnValues[_logEventColumnIndex] = string.Format(_logEventFormats[eventType], args);

        string line = string.Join("\t", columnValues);
        WriteLogLine(line);
    }

    void Awake ()
    {
        _instance = this;

        var assembly = Assembly.GetExecutingAssembly();
        
        foreach (var type in assembly.GetTypes())
        {
            if (!type.IsEnum)
                continue;

            if (!type.Name.EndsWith("LogEvent"))
                continue;

            foreach (MemberInfo enumMember in type.GetMembers())
            {
                var eventParamsAttrs = enumMember.GetCustomAttributes(typeof(LogEventAttribute), false);

                if (eventParamsAttrs.Length == 0)
                    continue;

                var eventType = (Enum)Enum.Parse(enumMember.DeclaringType, enumMember.Name);
                var eventParamsAttr = (LogEventAttribute)eventParamsAttrs[0];
                RegisterLogEventType(eventType, eventParamsAttr.ParamNames);
            }
        }

        var thisType = this.GetType();

        foreach (string columnHeading in LogHeaderColumns)
        {
            MethodInfo columnValueMethod = thisType.GetMethod(
                "Get" + columnHeading.Replace(" ", "") + "HeaderColumnValue",
                BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

            LogColumnValueProvider columnValueProvider = null;

            if (columnValueMethod != null)
            {
                try
                {
                    columnValueProvider = Delegate.CreateDelegate(
                        typeof(LogColumnValueProvider), columnValueMethod) as LogColumnValueProvider;

                    _logHeaderColumnValueProviders.Add(columnValueProvider);
                }
                catch { }
            }
            else _logHeaderColumnValueProviders.Add(null);
        }

        foreach (string columnHeading in LogColumns)
        {
            MethodInfo columnValueMethod = thisType.GetMethod(
                "Get" + columnHeading.Replace(" ", "") + "ColumnValue",
                BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

            LogColumnValueProvider columnValueProvider = null;

            if (columnValueMethod != null)
            {
                try
                {
                    columnValueProvider = Delegate.CreateDelegate(
                        typeof(LogColumnValueProvider), columnValueMethod) as LogColumnValueProvider;

                    _logColumnValueProviders.Add(columnValueProvider);
                }
                catch { }
            }
            else _logColumnValueProviders.Add(null);
        }

        _logTypeColumnIndex = Array.IndexOf(LogColumns, "Type");
        _logEventColumnIndex = Array.IndexOf(LogColumns, "Event");

        _studyConfig = GameClient.Instance.Config.Study;
    }

    void Start ()
    {
        GameClient.Instance.ConnectedToWorldServer += OnConnectedToWorldServer;
    }

    void OnConnectedToWorldServer ()
    {
        if (_studyConfig.LoggingEnabled)
        {
            OpenLogs();
            StartCoroutine(LogMeasures());
        }
    }

    void OnDestroy ()
    {
        StopAllCoroutines();
        CloseLogs();
    }

    private static void RegisterLogEventType (Enum eventType, params string[] paramNames)
    {
        for (int i = 0; i < paramNames.Length; i++)
        {
            var paramName = paramNames[i];

            if (paramName.Contains(":"))
            {
                int colonPos = paramName.IndexOf(":");
                string actualParamName = paramName.Substring(0, colonPos);
                string paramFormat = paramName.Substring(colonPos);
                paramName = actualParamName + "={" + i + paramFormat + "}";
            }
            else paramName += "={" + i + "}";

            paramNames[i] = paramName;
        }

        string eventTypeTypeName = eventType.GetType().Name;
        eventTypeTypeName = eventTypeTypeName.Remove(eventTypeTypeName.IndexOf("LogEvent"));
        string eventTypeFullName = eventTypeTypeName + "." + eventType.ToString();
        _logEventFormats[eventType] = eventTypeFullName + ": {{ " + string.Join(", ", paramNames) + " }}";
    }

    private static void OpenLogs ()
    {
        foreach (var logPathPattern in _studyConfig.LogPaths)
        {
            string logPath = logPathPattern;

            logPath = logPath
                .Replace("<p>", Game.LocalPlayerID)
                .Replace("<n>", Game.LocalPlayerProfile.Basic.Nickname)
                .Replace("<d>", DateTime.Now.ToString(_instance.LogDateFormat))
                .Replace("<t>", DateTime.Now.ToString(_instance.LogTimeFileNameFormat));

            Directory.CreateDirectory(GameClient.Instance.StudyLogsBase);

            try { _logWriters.Add(new StreamWriter(logPath)); }
            catch { }
        }

        WriteLogHeader();
    }

    private static void CloseLogs ()
    {
        foreach (var logWriter in _logWriters)
        {
            if (logWriter != null)
                logWriter.Dispose();
        }

        _logWriters.Clear();
    }

    private static void WriteLogHeader ()
    {
        WriteLogLine(string.Join("\t", _instance.LogHeaderColumns));
        WriteLogLine(string.Join("\t", GetLogHeaderColumnValues()));
        WriteLogLine(string.Join("\t", _instance.LogColumns));
    }

    private static void WriteLogLine (string line)
    {
        foreach (var logWriter in _logWriters)
        {
            if (logWriter != null)
            {
                logWriter.WriteLine(line);
                logWriter.Flush();
            }
        }
    }

    IEnumerator LogMeasures ()
    {
        while (true)
        {
            yield return new WaitForSeconds(MeasureLogInterval);

            string[] columnValues = GetLogColumnValues();

            if (_logTypeColumnIndex > -1 && _logTypeColumnIndex < columnValues.Length)
                columnValues[_logTypeColumnIndex] = "M";

            string line = string.Join("\t", columnValues);
            WriteLogLine(line);
        }
    }

    private static string[] GetLogHeaderColumnValues ()
    {
        return _logHeaderColumnValueProviders.Select(p => p != null ? p.Invoke() : "").ToArray();
    }

    private static string[] GetLogColumnValues ()
    {
        return _logColumnValueProviders.Select(p => p != null ? p.Invoke() : "").ToArray();
    }
}