Ejemplo n.º 1
0
        public void Parse(LogChannel channel, string line)
        {
            if (isValidMessage(line))
            {
                int startDate = line.IndexOf("[ ", 0);
                int endDate = line.IndexOf(" ]", startDate + 2);
                int endName = line.IndexOf(" > ", endDate + 3);

                this.channel = channel;
                string timePart = line.Substring(startDate + 2, endDate - 2).Trim();
                bool valid = DateTime.TryParse(timePart, out this.timestamp);
                this.name = line.Substring(endDate + 2, endName - endDate - 2).Trim();
                this.message = line.Substring(endName + 2).TrimStart();
            }
        }
 /// <summary>
 /// Get the given cached channel string name.
 /// </summary>
 /// <param name="channel"></param>
 /// <returns></returns>
 public static string GetChannelName(LogChannel channel)
 {
     return(LogChannels.Channels[(int)channel]);
 }
Ejemplo n.º 3
0
 public async Task sendToChannel(LogChannel ch, string Message)
 {
     await sendToChannel(ch, null, Message);
 }
Ejemplo n.º 4
0
 public static void Log(LogChannel Level, string message)
 {
     Level.Log("[Essentials] " + message);
 }
Ejemplo n.º 5
0
        public void StartListening(MethodInfo method, Type channel, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            HttpListener httpChannel = new HttpListener();

            ChannelConfigurationInfo channelConfig = _configuration.Configure(httpChannel, channel, method, _baseURL);

            //Keep the ChannelMethod open for new requests
            while (true)
            {
                try
                {
                    httpChannel.Start();
                }
                catch (HttpListenerException hle)
                {
                    Console.WriteLine($"System.Net.HttpListenerException encountered on {channelConfig.MethodUrl} with reason :{hle.Message}");
                    return;
                }

                Console.WriteLine($"Listening on {channelConfig.MethodUrl}");
                HttpListenerContext      context       = httpChannel.GetContext();
                HttpListenerRequest      request       = context.Request;
                HttpListenerResponse     response      = context.Response;
                IChannelHeuristicContext heuristicsCtx = _services.Get <IChannelHeuristicContext>();

                bool executedIfCached = ExecuteIfCached(channel, method, request, response, heuristicsCtx);
                if (executedIfCached)
                {
                    heuristicsCtx.Clear();
                    goto EndRequest;
                }

                LogChannel.Write(LogSeverity.Info, $"Request coming to {channelConfig.Endpoint.Name}");
                LogChannel.Write(LogSeverity.Info, $"HttpMethod:{request.HttpMethod}");

                bool authFailed = AuthenticationFailedIfRequired(context, request, response, channelConfig, out bool authenticated);
                if (authFailed)
                {
                    goto EndRequest;
                }

                //Check if the Http Method is correct
                if (channelConfig.HttpMethod.ToString() != request.HttpMethod && channelConfig.HttpMethod != ChannelHttpMethod.Unknown)
                {
                    _msgService.WrongHttpMethod(response, channelConfig.HttpMethod);
                    LogChannel.Write(LogSeverity.Error, "Wrong HttpMethod... Closing request");
                    goto EndRequest;
                }


                ChannelMethodInfo methodDescription         = _channelMethodDescriptor.GetMethodDescription(method);
                List <object>     channelRequestBody        = null;
                ChannelMethodDeserializerFactory dsrFactory = null;

                if (request.HttpMethod == "GET")
                {
                    bool invoked = TryInvokeGetRequest(channel, method, request, response, dsrFactory, methodDescription, channelConfig, channelRequestBody, authenticated);
                    goto EndRequest;
                }

                //Enter only if Request Body is supplied with POST Method
                if (request.HasEntityBody == true && request.HttpMethod == "POST")
                {
                    StreamWriter writer = new StreamWriter(response.OutputStream);
                    try
                    {
                        dsrFactory         = new ChannelMethodDeserializerFactory(request.InputStream);
                        channelRequestBody = dsrFactory.DeserializeFromBody(methodDescription, request.ContentType);
                        InitChannelMethodContext(channelConfig.Endpoint, request, response, authenticated, channelConfig.HttpMethod, channelRequestBody);
                        _requestActivator.PostActivate(channel, method, channelRequestBody, response);
                    }
                    catch (ChannelMethodContentTypeException cEx)
                    {
                        response.StatusCode = 400;
                        _msgService.ExceptionHandler(writer, cEx, response);
                        LogChannel.Write(LogSeverity.Error, cEx.Message);
                    }
                    catch (ChannelMethodParameterException pEx)
                    {
                        response.StatusCode = 400;
                        _msgService.ExceptionHandler(writer, pEx, response);
                        LogChannel.Write(LogSeverity.Error, pEx.Message);
                    }
                    catch (TargetParameterCountException tEx)
                    {
                        response.StatusCode = 400;
                        _msgService.ExceptionHandler(writer, tEx, response);
                        LogChannel.Write(LogSeverity.Error, tEx.Message);
                    }
                    catch (Exception ex)
                    {
                        response.StatusCode = 500;
                        _msgService.ExceptionHandler(writer, ex, response);
                        LogChannel.Write(LogSeverity.Fatal, ex.Message);
                    }
                    finally
                    {
                        _contextProvider.DestroyChannelMethodContext(channelConfig.Endpoint);
                        writer.Flush();
                        writer.Close();
                    }
                }

EndRequest:
                LogChannel.Write(LogSeverity.Debug, "Request finished...");
                LogChannel.Write(LogSeverity.Debug, "Closing the response");
                response.Close();
            }
        }
        internal void TryInvokePostRequest(Type channel,
                                           MethodInfo method,
                                           HttpListenerRequest request,
                                           HttpListenerResponse response,
                                           List <object> channelRequestBody,
                                           ChannelMethodInfo methodDescription,
                                           ChannelConfigurationInfo channelConfig,
                                           bool authenticated,
                                           CacheExecutionResult cacheExecutionResult)
        {
            StreamWriter writer = new StreamWriter(response.OutputStream);

            try
            {
                //Since request body will be processed in Heuristics if cache is enabled
                //InputStream is flushed and data is already stored in Data.Parameters
                //property of CacheExecutionResult
                if (!cacheExecutionResult.DataProcessed)
                {
                    _dsrFactory        = new ChannelMethodDeserializerFactory(request.InputStream);
                    channelRequestBody = _dsrFactory.DeserializeFromBody(methodDescription, request.ContentType);
                }
                else
                {
                    channelRequestBody = cacheExecutionResult.Data.Parameters;
                }

                InitChannelMethodContext(channelConfig.Endpoint, request, response, authenticated, channelConfig.HttpMethod, channelRequestBody);
                _requestActivator.PostActivate(channel, method, channelRequestBody, response);
            }
            catch (ChannelMethodContentTypeException cEx)
            {
                response.StatusCode = 400;
                _msgService.ExceptionHandler(writer, cEx, response);
                LogChannel.Write(LogSeverity.Error, cEx.Message);
            }
            catch (ChannelMethodParameterException pEx)
            {
                response.StatusCode = 400;
                _msgService.ExceptionHandler(writer, pEx, response);
                LogChannel.Write(LogSeverity.Error, pEx.Message);
            }
            catch (TargetParameterCountException tEx)
            {
                response.StatusCode = 400;
                _msgService.ExceptionHandler(writer, tEx, response);
                LogChannel.Write(LogSeverity.Error, tEx.Message);
            }
            catch (Exception ex)
            {
                response.StatusCode = 500;
                _msgService.ExceptionHandler(writer, ex, response);
                LogChannel.Write(LogSeverity.Fatal, ex.Message);
            }
            finally
            {
                _contextProvider.DestroyChannelMethodContext(channelConfig.Endpoint);
                writer.Flush();
                writer.Close();
            }
        }
 public static void Log(LogChannel channel, string text)
 {
     Write (new LogEntry (text, null) { channel = channel });
 }
 public static void BareLog(LogChannel channel, string text)
 {
     Write (new LogEntry { message = text, thread = Thread.CurrentThread, channel = channel });
 }
Ejemplo n.º 9
0
        protected static string FormatMessage(string format, LogLevel level, LogChannel channel, params object[] args)
        {
            var message = string.Format(format, args);

            return(FormatMessage(message, level, channel));
        }
Ejemplo n.º 10
0
        public static void LogFormat(string format, LogLevel level = LogLevel.Verbose, LogChannel channel = LogChannel.Debug, params object[] args)
        {
            if (levelList.ContainsKey(level) && !levelList[level])
            {
                return;
            }
            if ((channels & channel) == LogChannel.None)
            {
                return;
            }

            var msg = FormatMessage(format, level, channel, args);

            switch (level)
            {
            case LogLevel.Error: Debug.LogError(msg); break;

            case LogLevel.Warning: Debug.LogWarning(msg); break;

            case LogLevel.Verbose:
            case LogLevel.Info:
            case LogLevel.Dev:
            default: Debug.Log(msg); break;
            }

            LogToolNetwork.Log(msg);
        }
Ejemplo n.º 11
0
 public static void LogAssertIsFalse(bool predict, string message, LogLevel level = LogLevel.Error, LogChannel channel = LogChannel.Debug)
 {
     if (predict)
     {
         Log(message, level, channel);
     }
 }
Ejemplo n.º 12
0
 public static void AssertNotNull(object obj, LogLevel level = LogLevel.Error, LogChannel channel = LogChannel.Debug)
 {
     LogAssertIsTrue(obj != null, System.Environment.StackTrace, level, channel);
 }
Ejemplo n.º 13
0
 public static void AssertIsFalse(bool predict, LogLevel level = LogLevel.Error, LogChannel channel = LogChannel.Debug)
 {
     LogAssertIsFalse(predict, System.Environment.StackTrace, level, channel);
 }
Ejemplo n.º 14
0
 public static void Enable(LogChannel channel)
 {
     channels = channel;
 }
Ejemplo n.º 15
0
 public static void Enable(LogChannel channel, bool enabled)
 {
     channels = enabled ? (channels | channel) : (~channel & channel);
 }
 public static void SetChannelEnabledState(LogChannel channel, bool on)
 {
     ChannelsActiveState[(int)channel] = on;
 }
 public static void Log(LogChannel channel, string format, SendingLogger logger, params object[] args)
 {
     Write(new LogEntry(format, args) { channel = channel, logger = logger });
 }
Ejemplo n.º 18
0
        private void SetLogChannel(LogChannel channel)
        {
            if (channel.ChannelName != null)
            {
                labelChannel.Text = channel.ChannelName;
            }
            else
            {
                labelChannel.Text = "Unknown";
            }

            if (channel.Listener != null)
            {
                labelListener.Text = channel.Listener;
            }
            else
            {
                labelListener.Text = "Unknown";
            }
        }
Ejemplo n.º 19
0
        /// <summary>
        /// Gets all channels, members in them and set's up event handlers
        /// </summary>
        /// <param name="guild"></param>
        /// <returns></returns>
        internal async Task Initialize(DiscordGuild guild)
        {
            //DebugLogWriteLine($"Initiating {guild} GuildTask... ");
            //Init guild
            Guild   = guild;
            GuildId = guild.Id;
            SecretRoomOverwriteBuilder = new DiscordOverwriteBuilder();
            SecretRoomOverwriteBuilder.For(Guild.EveryoneRole);
            SecretRoomOverwriteBuilder.Deny(Permissions.AccessChannels);
            //PersonalChannelOverwriteBuilder = new DiscordOverwriteBuilder();
            //PersonalChannelOverwriteBuilder.Allow(Permissions.AccessChannels);

            LogChannel = guild.GetChannel(LogChannelId);
            if (LogChannel != null)
            {
                LogMessage = await LogChannel.SendMessageAsync($"Begin of log {DateTime.Now.ToString()}\n");
            }

            //Init RootCategory
            Guild.Channels.TryGetValue(DateCategoryId, out DiscordChannel cat);
            if (cat == null)
            {
                string m = $"Initialize failed. No Category found on + {DateCategoryId}";
                //DebugLogWriteLine(m);
                throw new Exception(m);
            }
            DateRootCategory = cat;
            Guild.Channels.TryGetValue(DateSecretCategoryId, out DiscordChannel secCat);
            DateSecretCategory = secCat;

            //DebugLogWrite("Initiating voice channels... ");
            //VoiceChannels
            DateVoiceLobbies.Clear();
            SecretRooms.Clear();
            DateVoiceLobbies.AddRange(GetVoiceLobbies());
            SecretRooms.AddRange(GetSecretRooms());
            await VoiceChannelsInitAsync().ConfigureAwait(false);

            if (DateVoiceLobbies.Count == 0 || DateVoiceLobbies.All(c => c.Users.Count() > 0))
            {
                await AddLastEmptyVoiceLobby().ConfigureAwait(false);
            }

            //DebugLogWrite("Initiating Emojis... ");
            //GetEmojis
            MaleEmoji   = DiscordEmoji.FromUnicode(DateBot.Instance.Client, MaleEmojiId);
            FemaleEmoji = DiscordEmoji.FromUnicode(DateBot.Instance.Client, FemaleEmojiId);
            OptionEmojis.Clear();
            OptionEmojis.AddRange(OptionEmojiIds.Select(id => DiscordEmoji.FromUnicode(DateBot.Instance.Client, id)));
            LikeEmoji       = DiscordEmoji.FromUnicode(DateBot.Instance.Client, LikeEmojiId);
            DisLikeEmoji    = DiscordEmoji.FromUnicode(DateBot.Instance.Client, DisLikeEmojiId);
            TimeEmoji       = DiscordEmoji.FromUnicode(DateBot.Instance.Client, TimeEmojiId);
            CancelLikeEmoji = DiscordEmoji.FromUnicode(DateBot.Instance.Client, CancelLikeEmojiId);

            //DebugLogWrite("Initiating Users in lobbies... ");
            //Check and add users in lobbies
            foreach (var u in UsersInLobbies.ToArray())
            {
                AddOrGetUserState(u).LastEnteredLobbyTime = DateTime.Now;
            }

            //DebugLogWrite("Initiating Welcome message... ");
            //Check for welcome message TODO add option emojis
            DateTextChannel = Guild.GetChannel(DateTextChannelId);
            await WelcomeMessageInit().ConfigureAwait(false);

            _ = PrivateControlsMessageInit().ConfigureAwait(false);

            //UpdateTimer = new Timer(TimeSpan.FromSeconds(30).TotalMilliseconds) { AutoReset = true };
            //UpdateTimer.Elapsed += UpdateTimer_Elapsed;
            //UpdateTimer.Start();

            //DebugLogWrite("finished");
            InitTask    = null;
            Initialized = true;

            if (UsersInLobbies.Count > 0)
            {
                TryStartMatchingTask();
            }
        }
Ejemplo n.º 20
0
 public void FilterChannel(LogChannel channel)
 {
     m_ExtensionChannelFilter.FilterChannel = channel;
     m_ExtensionContainer.PushLogOverwrite(m_ExtensionChannelFilter);
     RequireFlush();
 }
Ejemplo n.º 21
0
 public LogMessage(LogChannel channel, string line)
 {
     this.Parse(channel, line);
 }
Ejemplo n.º 22
0
 private void CommandFilterChannel(string channel)
 {
     FilterChannel(LogChannel.Get(channel));
 }
 public static void LogAssertionFormat(string format, LogChannel channel, params object[] args)
 {
     LogFormat(format, channel, LogLvl.Assertion, args);
 }
 public void SetChannel(LogChannel logChannel)
 {
     Channel    = logChannel;
     _text.text = logChannel.Name;
 }
Ejemplo n.º 25
0
        private bool AuthenticationFailedIfRequired(HttpListenerContext context, HttpListenerRequest request, HttpListenerResponse response, ChannelConfigurationInfo channelConfig, out bool authenticated)
        {
            bool failed      = false;
            bool validCookie = false;

            authenticated = false;
            bool authorized = false;

            if (channelConfig.ChannelAttribute.EnableSessions)
            {
                validCookie = ValidSession(request);
            }
            if (channelConfig.AuthenticationRequired && !validCookie)
            {
                try
                {
                    ChannelAuthenticationContext authContext = new ChannelAuthenticationContext
                    {
                        Context = context,
                        Scheme  = channelConfig.AuthScheme,
                        BasicAuthenticationDelegate = _basicAuthenticationMethod,
                        TokenAuthenticationDelegate = _tokenAuthenticationMethod,
                        AuthenticationSettings      = _settings
                    };

                    KeyValuePair <bool, object> authenticationResult = _authenticationService.CheckAuthenticationAndGetResponseObject(authContext);
                    if (authenticationResult.Key == true)
                    {
                        authenticated = true;
                    }
                    else
                    {
                        _msgService.FailedAuthenticationResponse(channelConfig.AuthScheme, response);
                        failed = true;
                    }
                    LogChannel.Write(LogSeverity.Info, "User Authenticated");
                    string claimName  = channelConfig.AuthorizeAttribute.ClaimName;
                    string claimValue = channelConfig.AuthorizeAttribute.ClaimValue;
                    if (!String.IsNullOrEmpty(claimName) && !String.IsNullOrEmpty(claimValue))
                    {
                        if (authenticationResult.Value.GetType() == typeof(ClaimsPrincipal))
                        {
                            authorized = _authenticationService.Authorized(claimName, claimValue, (ClaimsPrincipal)authenticationResult.Value);
                        }
                        else
                        {
                            authorized = _authenticationService.Authorized(claimName, claimValue, (Claim[])authenticationResult.Value);
                        }

                        if (!authorized)
                        {
                            _msgService.FailedAuthorizationResponse(response);
                            LogChannel.Write(LogSeverity.Error, "Failed authorization");
                            failed = true;
                        }
                        else
                        {
                            LogChannel.Write(LogSeverity.Info, "User Authorized");
                        }
                    }
                }
                catch (Exception ex)
                {
                    using (StreamWriter writer = new StreamWriter(response.OutputStream))
                    {
                        _msgService.ExceptionHandler(writer, ex, response);
                        LogChannel.Write(LogSeverity.Error, "Authentication Failed");
                        failed = true;
                    }
                }
                if (!authenticated)
                {
                    failed = true;
                }
                else
                {
                    if (channelConfig.ChannelAttribute.EnableSessions)
                    {
                        string sessionKey    = Guid.NewGuid().ToString();
                        Cookie sessionCookie = new Cookie()
                        {
                            Expires = DateTime.Now.AddMinutes(30),
                            Name    = "channelAuthCookie",
                            Secure  = true,
                            Value   = sessionKey
                        };
                        response.SetCookie(sessionCookie);
                        _sessionKeys.Add(sessionCookie);
                    }
                }
            }

            return(failed);
        }
Ejemplo n.º 26
0
        /// <summary>
        /// Appends log messages to file with timestamp, level and message
        /// </summary>
        public void Emit(LogChannel source, LogLevels level, string tag, string message, object[] args)
        {
            lock (mutex)
            {
                if (paused)
                    return;

                beginStream();

                var msg = string.Format(message, args);
                stream.WriteLine("{0:g} | [{1}] {2}", DateTime.Now, tag.PadLeft(16, ' '), msg);
            }
        }
Ejemplo n.º 27
0
        private void AdvanceCommand(LogS98 Log, SongData sd, TrackData td, CommandData cmd, LogChannel lc)
        {
            td.AddWaitTrackTick(cmd.Tick);

            if (cmd.IsNote)
            {
                td.AddStaccato(cmd.Tick);
            }

            switch (cmd.Type)
            {
            case CommandType.Slur:
                td.Slur = cmd.Value != 0;
                break;

            case CommandType.Octave:
                td.Octave = cmd.Value;
                break;

            case CommandType.OctaveGt:
                if (!sd.OctaveReverse)
                {
                    td.Octave++;
                }
                else
                {
                    td.Octave--;
                }
                break;

            case CommandType.OctaveLt:
                if (!sd.OctaveReverse)
                {
                    td.Octave--;
                }
                else
                {
                    td.Octave++;
                }
                break;

            case CommandType.Tempo:
                sd.SetTempo(cmd.Value);
                break;

            case CommandType.Tone:
                SetTone(sd, td, cmd, lc);
                break;

            case CommandType.Note:
                NoteOn(td, lc, cmd.Value + (12 * td.Octave));
                break;

            case CommandType.DirectNote:
                NoteOn(td, lc, cmd.Value);
                break;

            case CommandType.Rest:
                NoteOff(lc);
                break;

            case CommandType.Volume:
                lc.SetVolume(cmd.Value);
                break;

            case CommandType.RepeatStart:
                td.RepeatStart(cmd.Value);
                break;

            case CommandType.RepeatEnd:
                td.RepeatEnd(cmd.Value);
                break;

            case CommandType.Loop:
                td.SetLoopTick();
                Log.SetLoopPoint();
                break;

            case CommandType.Staccato:
                td.Staccato = (cmd.Value >= 8 ? 0 : cmd.Value);
                break;

            default:
                VerboseWriteLine($"未実装: {cmd}");
                break;
            }
        }
Ejemplo n.º 28
0
        public static void Log(LogMode mode, string message, Exception ex, string process = "", object data = null)
        {
            // Check for an active log channel
            if (LogChannel == null)
            {
                throw new ArgumentNullException("No active log channel! Please enter a valid channel name in to the system configuration table!");
            }

            // Check the log level
            if (mode < Mode)
            {
                return;
            }

            // Create the log entry
            LogRecord logRecord = new LogRecord
            {
                LogID           = GetNextId().ToString(),
                Process         = process,
                Host            = Environment.MachineName,
                Level           = mode.ToString(),
                Message         = message,
                Exception       = ex,
                ExceptionString = ex == null ? string.Empty : ex.ToString(),
                Data            = data,
                DataString      = data == null ? string.Empty : JsonConvert.SerializeObject(data),
                Created         = DateTime.UtcNow,
                TimeStamp       = DateTime.UtcNow
            };

#if NET452
            // Set the app key and environment
            logRecord.AppKey      = ConfigurationManager.AppSettings["AppKey"];
            logRecord.Environment = ConfigurationManager.AppSettings["Environment"];

            // Try to get the host ip
            try
            {
                if (HttpContext.Current != null && HttpContext.Current.Request != null && !string.IsNullOrEmpty(HttpContext.Current.Request.UserHostAddress))
                {
                    // Set the host ip
                    logRecord.HostIP = HttpContext.Current.Request.ServerVariables["LOCAL_ADDR"];
                }
            }
            catch { }
#elif NETCOREAPP2_2
            // Set the app key and environment
            logRecord.AppKey      = _configuration.GetValue <string>("AppKey");
            logRecord.Environment = _configuration.GetValue <string>("Environment");

            // Try to get the host ip
            try
            {
                if (_httpContextAccessor.HttpContext != null && _httpContextAccessor.HttpContext.Request != null && !string.IsNullOrEmpty(_httpContextAccessor.HttpContext.Connection.RemoteIpAddress.ToString()))
                {
                    // Set the host ip
                    logRecord.HostIP = _httpContextAccessor.HttpContext.Connection.LocalIpAddress.ToString();
                }
            }
            catch { }
#endif
            // Log with the default channel
            LogChannel.Log(logRecord);
        }
Ejemplo n.º 29
0
 public async Task sendToChannel(LogChannel ch, Embed embed)
 {
     await sendToChannel(ch, embed, "");
 }
Ejemplo n.º 30
0
        public static void Log(LogRecord record)
        {
            // Check for an active channel
            if (LogChannel == null)
            {
                throw new ArgumentNullException("No log channel! Please enter a valid channel name in to the system configuration table!");
            }

#if NET452
            // Set the app key and environment
            record.AppKey      = ConfigurationManager.AppSettings["AppKey"];
            record.Environment = ConfigurationManager.AppSettings["Environment"];

            // Try to get the host ip
            try
            {
                if (HttpContext.Current != null && HttpContext.Current.Request != null && !string.IsNullOrEmpty(HttpContext.Current.Request.UserHostAddress))
                {
                    // Set the host ip
                    record.HostIP = HttpContext.Current.Request.ServerVariables["LOCAL_ADDR"];
                }
            }
            catch { }
#elif NETCOREAPP2_2
            // Set the app key and environment
            record.AppKey      = _configuration.GetValue <string>("AppKey");
            record.Environment = _configuration.GetValue <string>("Environment");

            // Try to get the host ip
            try
            {
                if (_httpContextAccessor.HttpContext != null && _httpContextAccessor.HttpContext.Request != null && !string.IsNullOrEmpty(_httpContextAccessor.HttpContext.Connection.RemoteIpAddress.ToString()))
                {
                    // Set the host ip
                    record.HostIP = _httpContextAccessor.HttpContext.Connection.LocalIpAddress.ToString();
                }
            }
            catch { }
#endif
            // Check the activity id
            if (String.IsNullOrEmpty(record.LogID))
            {
                record.LogID = GetNextId().ToString();
            }

            // Check the host name
            if (String.IsNullOrEmpty(record.Host))
            {
                record.Host = Environment.MachineName;
            }

            // Check for an incoming exception
            if (record.Exception != null)
            {
                record.ExceptionString = record.Exception.ToString();
            }

            // Check for an incoming data object
            if (record.Data != null)
            {
                record.Data = JsonConvert.SerializeObject(record.Data);
            }

            // Override the time stamps
            record.Created   = DateTime.UtcNow;
            record.TimeStamp = DateTime.UtcNow;

            // Add the log record
            LogChannel.Log(record);
        }
 /// <summary>
 /// Get whether the given channel is active or not.
 /// </summary>
 /// <param name="channel"></param>
 /// <returns></returns>
 public static bool IsChannelActive(LogChannel channel)
 {
     return(ChannelsActiveState[(int)channel]);
 }
 public static void Log(string msg, LogChannel channel)
 {
     Log(msg, channel, LogLvl.Info);
 }
        public static void Log(LogChannel channel, string text, bool multi = false)
        {
            if (!multi)
                Write(new LogEntry(text, null) { channel = channel });
            else
            {
                var split = text.Split('\n');

                foreach (var line in split)
                    Write(new LogEntry(line, null) { channel = channel });
            }
        }
 public static void LogWarning(string msg, LogChannel channel)
 {
     Log(msg, channel, LogLvl.Warning);
 }
 public LogEntry(object message, object args, SendingLogger logger = SendingLogger.CONSOLE)
 {
     this.target = null;
     this.thread = Thread.CurrentThread;
     this.time = DateTime.Now;
     this.message = message;
     this.args = args;
     this.channel = null;
     this.logger = logger;
 }
 public static void LogError(string msg, LogChannel channel)
 {
     Log(msg, channel, LogLvl.Error);
 }
 public static void BareLog(LogChannel channel, string format, params object[] args)
 {
     Write (new LogEntry { message = format, args = args, thread = Thread.CurrentThread, channel = channel });
 }
 public static void LogAssertion(string msg, LogChannel channel)
 {
     Log(msg, channel, LogLvl.Assertion);
 }
 public LogEntry(object message, object args)
 {
     this.target = null;
     this.thread = Thread.CurrentThread;
     this.time = DateTime.Now;
     this.message = message;
     this.args = args;
     this.channel = null;
 }
 private static void LogFormat(string format, LogChannel channel, LogLvl level, params object[] args)
 {
     Log(string.Format(format, args), channel, level);
 }
 public static void Log(LogChannel channel, string format, params object[] args)
 {
     Write (new LogEntry (format, args) { channel = channel });
 }
 public static void LogWarningFormat(string format, LogChannel channel, params object[] args)
 {
     LogFormat(format, channel, LogLvl.Warning, args);
 }
 public static void LogErrorFormat(string format, LogChannel channel, params object[] args)
 {
     LogFormat(format, channel, LogLvl.Error, args);
 }
Ejemplo n.º 44
0
 public void Constructor()
 {
     LogChannel lc = new LogChannel("Test-Channel");
     Assert.IsNotNull(lc);
     Assert.AreEqual("Test-Channel", lc.Name);
 }