How to make a Rust admin command logger plugin (Oxide)

using UnityEngine;
using System.Linq;
using System;
using System.Collections.Generic;
using System.Text;
using Newtonsoft.Json;
using Oxide.Core;

namespace Oxide.Plugins
{
    [Info("Admin Command Logger", "RustPluginGenerator", "1.0.0")]
    [Description("Logs console commands run by admin players to a data file with name, SteamID, command and time.")]
    public class AdminCommandLogger : RustPlugin
    {
        private const string PermView = "admincommandlogger.view";
        private const string PermClear = "admincommandlogger.clear";
        private const string DataFileName = "AdminCommandLogger";

        private PluginConfig config;
        private List<LogEntry> entries = new List<LogEntry>();
        private Timer saveTimer;
        private bool dirty;

        private class PluginConfig
        {
            [JsonProperty("Max entries kept")]
            public int MaxEntries = 500;

            [JsonProperty("Save interval seconds")]
            public int SaveIntervalSeconds = 60;

            [JsonProperty("Echo to console")]
            public bool EchoToConsole = true;

            [JsonProperty("Default lines shown by /adminlog")]
            public int DefaultShowLines = 10;

            [JsonProperty("Maximum lines shown by /adminlog")]
            public int MaxShowLines = 25;

            [JsonProperty("Ignored commands")]
            public List<string> IgnoredCommands = new List<string>
            {
                "global.kill",
                "global.respawn"
            };
        }

        private class LogEntry
        {
            [JsonProperty("PlayerName")]
            public string PlayerName;

            [JsonProperty("SteamId")]
            public string SteamId;

            [JsonProperty("Command")]
            public string Command;

            [JsonProperty("Time")]
            public string Time;

            public LogEntry()
            {
                PlayerName = string.Empty;
                SteamId = string.Empty;
                Command = string.Empty;
                Time = string.Empty;
            }
        }

        protected override void LoadDefaultConfig() => config = new PluginConfig();

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<PluginConfig>();
                if (config == null) throw new Exception();
            }
            catch
            {
                PrintWarning("Configuration file is invalid, using defaults");
                LoadDefaultConfig();
            }
            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["NoEntries"] = "The admin command log is empty.",
                ["Header"] = "Last {0} admin command(s):",
                ["Line"] = "{0} | {1} ({2}) | {3}",
                ["InvalidCount"] = "Usage: /adminlog [count]",
                ["Cleared"] = "Admin command log cleared.",
                ["NoPermission"] = "You do not have permission to use this command."
            }, this);
        }

        private string Msg(string key, string userId = null, params object[] args) =>
            string.Format(lang.GetMessage(key, this, userId), args);

        private void Init()
        {
            permission.RegisterPermission(PermView, this);
            permission.RegisterPermission(PermClear, this);
        }

        private void OnServerInitialized()
        {
            entries = Interface.Oxide.DataFileSystem.ReadObject<List<LogEntry>>(DataFileName) ?? new List<LogEntry>();
            saveTimer = timer.Every(Math.Max(10, config.SaveIntervalSeconds), SaveData);
        }

        private void Unload()
        {
            if (saveTimer != null)
            {
                saveTimer.Destroy();
                saveTimer = null;
            }
            SaveData();
        }

        private object OnServerCommand(ConsoleSystem.Arg arg)
        {
            if (arg == null || arg.cmd == null || arg.Connection == null) return null;

            var player = arg.Player();
            if (player == null || !player.IsAdmin || player.IsNpc) return null;

            string command = arg.cmd.FullName;
            if (string.IsNullOrEmpty(command)) return null;
            if (config.IgnoredCommands != null && config.IgnoredCommands.Contains(command)) return null;

            var builder = new StringBuilder(command);
            if (arg.Args != null)
            {
                for (int i = 0; i < arg.Args.Length; i++)
                {
                    builder.Append(' ').Append(arg.Args[i].ToString());
                }
            }

            var entry = new LogEntry
            {
                PlayerName = player.displayName,
                SteamId = player.UserIDString,
                Command = builder.ToString(),
                Time = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss")
            };

            entries.Add(entry);
            Trim();
            dirty = true;

            if (config.EchoToConsole)
            {
                Puts($"{entry.Time} | {entry.PlayerName} ({entry.SteamId}) | {entry.Command}");
            }

            return null;
        }

        private void Trim()
        {
            int max = Math.Max(1, config.MaxEntries);
            while (entries.Count > max)
            {
                entries.RemoveAt(0);
            }
        }

        private void SaveData()
        {
            if (!dirty) return;
            Interface.Oxide.DataFileSystem.WriteObject(DataFileName, entries);
            dirty = false;
        }

        [ChatCommand("adminlog")]
        private void CmdAdminLog(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermView))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            if (entries.Count == 0)
            {
                SendReply(player, Msg("NoEntries", player.UserIDString));
                return;
            }

            int count = config.DefaultShowLines;
            if (args != null && args.Length > 0)
            {
                if (!int.TryParse(args[0], out count) || count <= 0)
                {
                    SendReply(player, Msg("InvalidCount", player.UserIDString));
                    return;
                }
            }

            count = Math.Min(count, Math.Max(1, config.MaxShowLines));
            count = Math.Min(count, entries.Count);

            SendReply(player, Msg("Header", player.UserIDString, count));
            for (int i = entries.Count - 1; i >= entries.Count - count; i--)
            {
                var e = entries[i];
                SendReply(player, Msg("Line", player.UserIDString, e.Time, e.PlayerName, e.SteamId, e.Command));
            }
        }

        [ChatCommand("adminlog.clear")]
        private void CmdAdminLogClear(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermClear))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            entries.Clear();
            dirty = true;
            SaveData();
            SendReply(player, Msg("Cleared", player.UserIDString));
        }
    }
}