/// <summary> /// Initializes a new instance of the <see cref="GroupCI"/> class /// </summary> /// <param name="exportable">A <see cref="ExportableGroupCI"/> containing group information</param> internal GroupCI(ExportableGroupCI exportable) { if (exportable == null) { throw new ArgumentNullException(nameof(exportable)); } Id = exportable.Id; Name = exportable.Name; try { CompetitorsIds = exportable.Competitors?.Select(URN.Parse); if (!exportable.CompetitorsReferences.IsNullOrEmpty()) { CompetitorsReferences = new Dictionary <URN, ReferenceIdCI>(); foreach (var competitorsReference in exportable.CompetitorsReferences) { var referenceIds = new Dictionary <string, string>(); var refs = competitorsReference.Value.Split(','); foreach (var r in refs) { var refKeyValue = r.Split('='); referenceIds.Add(refKeyValue[0], refKeyValue[1]); } CompetitorsReferences.Add(URN.Parse(competitorsReference.Key), new ReferenceIdCI(referenceIds)); } } } catch (Exception e) { SdkLoggerFactory.GetLoggerForExecution(typeof(GroupCI)).Error("Importing GroupCI", e); } }
/// <summary> /// Initializes a new instance of the <see cref="SimpleMessageProcessor" /> class. /// </summary> /// <param name="dispatcher"> /// A <see cref="IEntityDispatcher{ISportEvent}" /> whose dispatched entities will be processed by the current instance. /// </param> /// <param name="name">The name of the session/processor</param> /// <param name="log">A <see cref="ILogger" /> instance used for logging</param> public SimpleMessageProcessor(IEntityDispatcher <ISportEvent> dispatcher, string name = null, ILog log = null) { _dispatcher = dispatcher; _log = log ?? SdkLoggerFactory.GetLogger(typeof(SimpleMessageProcessor)); FeedMessages = new ConcurrentBag <FMessage>(); Name = name ?? ((IOddsFeedSession)dispatcher).Name; }
/// <summary> /// Initializes a new instance of the <see cref="Feed"/> class /// </summary> /// <param name="config">A <see cref="IOddsFeedConfiguration"/> instance representing feed configuration</param> /// <param name="isReplay">Value indicating whether the constructed instance will be used to connect to replay server</param> /// <param name="loggerFactory">A <see cref="ILoggerFactory"/> used to create <see cref="ILogger"/> used within sdk</param> /// <param name="metricsRoot">A <see cref="IMetricsRoot"/> used to provide metrics within sdk</param> protected Feed(IOddsFeedConfiguration config, bool isReplay, ILoggerFactory loggerFactory = null, IMetricsRoot metricsRoot = null) { Guard.Argument(config, nameof(config)).NotNull(); FeedInitialized = false; UnityContainer = new UnityContainer(); //UnityContainer = new UnityContainer().EnableDiagnostic(); UnityContainer.RegisterBaseTypes(config, loggerFactory, metricsRoot); InternalConfig = UnityContainer.Resolve <IOddsFeedConfigurationInternal>(); if (isReplay || InternalConfig.Environment == SdkEnvironment.Replay) { InternalConfig.EnableReplayServer(); } _log = SdkLoggerFactory.GetLoggerForExecution(typeof(Feed)); LogInit(); _metricsRoot = UnityContainer.Resolve <IMetricsRoot>(); _metricsLogger = SdkLoggerFactory.GetLoggerForStats(typeof(Feed)); _metricsTaskScheduler = new AppMetricsTaskScheduler( TimeSpan.FromSeconds(InternalConfig.StatisticsTimeout), async() => { await LogMetricsAsync(); }); }
public void CloseConnection() { lock (_syncLock) { if (_connectionSingleton != null) { try { _connectionSingleton.ConnectionBlocked -= OnConnectionBlocked; _connectionSingleton.ConnectionUnblocked -= OnConnectionUnblocked; _connectionSingleton.CallbackException -= OnCallbackException; _connectionSingleton.ConnectionShutdown -= OnConnectionShutdown; _connectionSingleton.Close(); } catch (Exception e) { SdkLoggerFactory.GetLoggerForExecution(typeof(ConfiguredConnectionFactory)).Warn("Error closing connection", e); } finally { _connectionSingleton.Dispose(); _connectionSingleton = null; ConnectionCreated = DateTime.MinValue; } } } }
/// <summary> /// Asynchronous export item's properties /// </summary> /// <returns>An <see cref="ExportableCI"/> instance containing all relevant properties</returns> public Task <ExportableGroupCI> ExportAsync() { var cr = new Dictionary <string, string>(); if (!CompetitorsReferences.IsNullOrEmpty()) { foreach (var competitorsReference in CompetitorsReferences) { try { if (!competitorsReference.Value.ReferenceIds.IsNullOrEmpty()) { var refs = string.Join(",", competitorsReference.Value.ReferenceIds.Select(s => $"{s.Key}={s.Value}")); cr.Add(competitorsReference.Key.ToString(), refs); } } catch (Exception e) { SdkLoggerFactory.GetLoggerForExecution(typeof(GroupCI)).Error("Exporting GroupCI", e); } } } return(Task.FromResult(new ExportableGroupCI { Id = Id, Name = Name, Competitors = CompetitorsIds?.Select(s => s.ToString()).ToList(), CompetitorsReferences = cr.IsNullOrEmpty() ? null : cr })); }
/// <summary> /// Asynchronous export item's properties /// </summary> /// <returns>An <see cref="ExportableCI"/> instance containing all relevant properties</returns> public Task <ExportableGroupCI> ExportAsync() { var cr = new Dictionary <string, Dictionary <string, string> >(); if (!CompetitorsReferences.IsNullOrEmpty()) { foreach (var competitorsReference in CompetitorsReferences) { try { var refs = competitorsReference.Value.ReferenceIds?.ToDictionary(r => r.Key, r => r.Value); cr.Add(competitorsReference.Key.ToString(), refs); } catch (Exception e) { SdkLoggerFactory.GetLoggerForExecution(typeof(GroupCI)).LogError(e, "Exporting GroupCI"); } } } return(Task.FromResult(new ExportableGroupCI { Id = Id, Name = Name, Competitors = CompetitorsIds?.Select(s => s.ToString()), CompetitorsReferences = cr.IsNullOrEmpty() ? null : cr })); }
public void Init() { var services = new ServiceCollection(); services.AddLogging(configure => configure.AddLog4Net("log4net.sdk.config")); var servicesProvider = services.BuildServiceProvider(); var loggerFactory = servicesProvider.GetService <ILoggerFactory>(); var _ = new SdkLoggerFactory(loggerFactory); }
public void Init() { SdkLoggerFactory.Configure(new FileInfo("log4net.sdk.config")); _sef = new TestSportEntityFactoryBuilder(); _sef.InitializeSportEntities(); _sef.LoadTournamentMissingValues(); _sef.LoadSeasonMissingValues(); }
/// <summary> /// Constructs a new instance of the <see cref="MtsSdk"/> class /// </summary> /// <param name="config">A <see cref="ISdkConfiguration"/> instance representing feed configuration</param> /// <param name="loggerFactory">A <see cref="ILoggerFactory"/> used to create <see cref="ILogger"/> used within sdk</param> /// <param name="metricsRoot">A <see cref="IMetricsRoot"/> used to provide metrics within sdk</param> public MtsSdk(ISdkConfiguration config, ILoggerFactory loggerFactory = null, IMetricsRoot metricsRoot = null) { Guard.Argument(config, nameof(config)).NotNull(); LogInit(); _isDisposed = false; _isOpened = 0; _unityContainer = new UnityContainer(); _unityContainer.RegisterTypes(config, loggerFactory, metricsRoot); _config = _unityContainer.Resolve <ISdkConfigurationInternal>(); _executionLog = SdkLoggerFactory.GetLoggerForExecution(typeof(MtsSdk)); _interactionLog = SdkLoggerFactory.GetLoggerForExecution(typeof(MtsSdk)); LogInit(); _metricsRoot = _unityContainer.Resolve <IMetricsRoot>(); _metricsLogger = SdkLoggerFactory.GetLoggerForStats(typeof(MtsSdk)); _metricsTaskScheduler = new AppMetricsTaskScheduler( TimeSpan.FromSeconds(_config.StatisticsTimeout), async() => { await LogMetricsAsync(); }); _connectionValidator = _unityContainer.Resolve <ConnectionValidator>(); BuilderFactory = _unityContainer.Resolve <IBuilderFactory>(); _ticketPublisherFactory = _unityContainer.Resolve <ITicketSenderFactory>(); _entitiesMapper = _unityContainer.Resolve <EntitiesMapper>(); _rabbitMqMessageReceiverForTickets = _unityContainer.Resolve <IRabbitMqMessageReceiver>("TicketResponseMessageReceiver"); _rabbitMqMessageReceiverForTicketCancels = _unityContainer.Resolve <IRabbitMqMessageReceiver>("TicketCancelResponseMessageReceiver"); _rabbitMqMessageReceiverForTicketCashouts = _unityContainer.Resolve <IRabbitMqMessageReceiver>("TicketCashoutResponseMessageReceiver"); _rabbitMqMessageReceiverForTicketNonSrSettle = _unityContainer.Resolve <IRabbitMqMessageReceiver>("TicketNonSrSettleResponseMessageReceiver"); ClientApi = _unityContainer.Resolve <IMtsClientApi>(); CustomBetManager = _unityContainer.Resolve <ICustomBetManager>(); ConnectionStatus = _unityContainer.Resolve <IConnectionStatus>(); ReportManager = _unityContainer.Resolve <IReportManager>(); _autoResetEventsForBlockingRequests = new ConcurrentDictionary <string, AutoResetEvent>(); _responsesFromBlockingRequests = new ConcurrentDictionary <string, ISdkTicket>(); _ticketsForNonBlockingRequests = new MemoryCache("TicketsForNonBlockingRequests"); _lockForTicketsForNonBlockingRequestsCache = new object(); foreach (var t in Enum.GetValues(typeof(SdkTicketType))) { var publisher = _ticketPublisherFactory.GetTicketSender((SdkTicketType)t); if (publisher != null) { publisher.TicketSendFailed += PublisherOnTicketSendFailed; } } }
/// <summary> /// Initializes a new instance of the <see cref="SpecificEntityProcessor{T}"/> class /// </summary> /// <param name="dispatcher">A <see cref="ISpecificEntityDispatcher{T}"/> used to obtain SDK messages</param> /// <param name="sportEntityWriter">A <see cref="SportEntityWriter"/> used to write the sport entities data</param> /// <param name="marketWriter">A <see cref="MarketWriter"/> used to write market and outcome data</param> /// <param name="log">A <see cref="ILogger"/> instance used for logging</param> public SpecificEntityProcessor(ISpecificEntityDispatcher <T> dispatcher, SportEntityWriter sportEntityWriter = null, MarketWriter marketWriter = null, ILogger log = null) { Guard.Argument(dispatcher, nameof(dispatcher)).NotNull(); Guard.Argument(log, nameof(log)).NotNull(); _log = log ?? SdkLoggerFactory.GetLogger(typeof(SpecificEntityProcessor <T>)); // new NullLogger<SpecificEntityProcessor<T>>(); _dispatcher = dispatcher; _sportEntityWriter = sportEntityWriter; _marketWriter = marketWriter; }
/// <summary> /// Sets the last timestamp before disconnect /// </summary> /// <param name="timestamp">The timestamp</param> internal void SetLastTimestampBeforeDisconnect(DateTime timestamp) { if (timestamp >= LastTimestampBeforeDisconnect) { LastTimestampBeforeDisconnect = timestamp; } else if (timestamp < LastTimestampBeforeDisconnect.AddSeconds(-MaxInactivitySeconds)) { var logger = SdkLoggerFactory.GetLoggerForExecution(typeof(Producer)); logger.Warn($"Suspicious feed message timestamp arrived for producer {Id}. Current={LastTimestampBeforeDisconnect}. Arrived={timestamp}"); } }
/// <summary> /// Initializes a new instance of the <see cref="SdkCache"/> class /// </summary> protected SdkCache(ICacheManager cacheManager) { Guard.Argument(cacheManager, nameof(cacheManager)).NotNull(); _cacheManager = cacheManager; CacheName = GetType().Name; // ReSharper disable once VirtualMemberCallInConstructor RegisterCache(); ExecutionLog = SdkLoggerFactory.GetLoggerForExecution(GetType()); }
/// <summary> /// Initializes a new instance of the <see cref="SdkCache" /> class /// </summary> protected SdkCache(ICacheManager cacheManager) { Contract.Requires(cacheManager != null); _cacheManager = cacheManager; CacheName = GetType().Name; // ReSharper disable once VirtualMemberCallInConstructor RegisterCache(); ExecutionLog = SdkLoggerFactory.GetLoggerForExecution(GetType()); }
/// <summary> /// Converts the provided int <code>value</code> to the member of the specified enum, or returns <code>defaultValue</code> /// </summary> /// <typeparam name="T">The type of enum to which to convert the <code>value</code></typeparam> /// <param name="value">The value in the feed message</param> /// <param name="defaultValue">A <see cref="T"/> member to be returned if unknown <code>value</code></param> /// <returns>The <code>value</code> converted to enum <see cref="T"/> member</returns> public static T GetEnumValue <T>(int value, T defaultValue) where T : struct, IConvertible { try { return(GetEnumValue <T>(value)); } catch { var log = SdkLoggerFactory.GetLogger(typeof(MessageMapperHelper)); log.LogError($"Enum value [{value}] not available for enum {typeof(T)}."); // ignored } return(defaultValue); }
public static void RegisterTypes(this IUnityContainer container, ISdkConfiguration userConfig, ILoggerFactory loggerFactory, IMetricsRoot metricsRoot) { Guard.Argument(container, nameof(container)).NotNull(); Guard.Argument(userConfig, nameof(userConfig)).NotNull(); ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12; if (loggerFactory != null) { var _ = new SdkLoggerFactory(loggerFactory); } _log = SdkLoggerFactory.GetLogger(typeof(SdkUnityBootstrapper)); if (metricsRoot == null) { _metricsRoot = new MetricsBuilder() .Configuration.Configure( options => { options.DefaultContextLabel = "UF SDK .NET Core"; options.Enabled = true; options.ReportingEnabled = true; }) .OutputMetrics.AsPlainText() .Build(); } else { _metricsRoot = metricsRoot; } container.RegisterInstance(_metricsRoot, new ContainerControlledLifetimeManager()); RegisterBaseClasses(container, userConfig); RegisterRabbitMqTypes(container, userConfig, _environment); RegisterTicketSenders(container); RegisterMarketDescriptionCache(container, userConfig); RegisterSdkStatisticsWriter(container); RegisterMtsAuthService(container, userConfig); RegisterClientApi(container, userConfig); RegisterReportManager(container, userConfig); RegisterCustomBet(container); }
/// <summary> /// Runs the report of <see cref="MetricsData"/> /// </summary> /// <param name="metricsData">The metrics data</param> /// <param name="healthStatus">The health status</param> /// <param name="token">The token</param> public void RunReport(MetricsData metricsData, Func <HealthStatus> healthStatus, CancellationToken token) { if (_log == null) { _log = SdkLoggerFactory.GetLoggerForStats(typeof(MetricsReporter)); } var mdr = new MetricDataReport(metricsData?.Context, _log, _printMode, _decimals); mdr.Report(metricsData); if (_runHealthStatus) { RunHealthStatus(metricsData?.Context); } }
private static void LogInit() { var msg = "MtsSdk initialization. Version: " + SdkInfo.GetVersion(); var logger = SdkLoggerFactory.GetLoggerForFeedTraffic(typeof(MtsSdk)); logger.LogInformation(msg); logger = SdkLoggerFactory.GetLoggerForCache(typeof(MtsSdk)); logger.LogInformation(msg); logger = SdkLoggerFactory.GetLoggerForClientInteraction(typeof(MtsSdk)); logger.LogInformation(msg); logger = SdkLoggerFactory.GetLoggerForRestTraffic(typeof(MtsSdk)); logger.LogInformation(msg); logger = SdkLoggerFactory.GetLoggerForStats(typeof(MtsSdk)); logger.LogInformation(msg); logger = SdkLoggerFactory.GetLoggerForExecution(typeof(MtsSdk)); logger.LogInformation(msg); }
private void LogInit() { var msg = "UF SDK .NET initialization. Version: " + SdkInfo.GetVersion(); var logger = SdkLoggerFactory.GetLoggerForExecution(typeof(Feed)); logger.Info($"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}"); logger = SdkLoggerFactory.GetLoggerForCache(typeof(Feed)); logger.Info($"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}"); logger = SdkLoggerFactory.GetLoggerForClientInteraction(typeof(Feed)); logger.Info($"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}"); logger = SdkLoggerFactory.GetLoggerForRestTraffic(typeof(Feed)); logger.Info($"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}"); logger = SdkLoggerFactory.GetLoggerForFeedTraffic(typeof(Feed)); logger.Info($"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}"); logger = SdkLoggerFactory.GetLoggerForStats(typeof(Feed)); logger.Info($"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}"); }
/// <summary> /// Initializes a new instance of the <see cref="SportEvent"/> class /// </summary> /// <param name="id">A <see cref="URN"/> uniquely identifying the sport event</param> /// <param name="sportId">A <see cref="URN"/> identifying the sport current instance belong to</param> /// <param name="executionLog">The <see cref="ILog"/> instance used for execution logging</param> /// <param name="sportEventCache">A <see cref="ISportEventCache"/> instance containing <see cref="SportEventCI"/></param> /// <param name="cultures">A <see cref="IEnumerable{CultureInfo}"/> specifying languages the current instance supports</param> /// <param name="exceptionStrategy">A <see cref="ExceptionHandlingStrategy"/> enum member specifying how the instance will handle potential exceptions</param> public SportEvent(URN id, URN sportId, ILog executionLog, ISportEventCache sportEventCache, IEnumerable <CultureInfo> cultures, ExceptionHandlingStrategy exceptionStrategy) { Contract.Requires(id != null); Contract.Requires(sportEventCache != null); Contract.Requires(cultures != null && cultures.Any()); Id = id; SportId = sportId; ExecutionLog = executionLog ?? SdkLoggerFactory.GetLoggerForExecution(typeof(SportEvent)); ExceptionStrategy = exceptionStrategy; Cultures = cultures; SportEventCache = sportEventCache; }
/// <summary> /// Initializes a new instance of the <see cref="SportEvent"/> class /// </summary> /// <param name="id">A <see cref="URN"/> uniquely identifying the sport event</param> /// <param name="sportId">A <see cref="URN"/> identifying the sport current instance belong to</param> /// <param name="executionLog">The <see cref="ILog"/> instance used for execution logging</param> /// <param name="sportEventCache">A <see cref="ISportEventCache"/> instance containing <see cref="SportEventCI"/></param> /// <param name="cultures">A <see cref="IEnumerable{CultureInfo}"/> specifying languages the current instance supports</param> /// <param name="exceptionStrategy">A <see cref="ExceptionHandlingStrategy"/> enum member specifying how the instance will handle potential exceptions</param> public SportEvent(URN id, URN sportId, ILog executionLog, ISportEventCache sportEventCache, IEnumerable <CultureInfo> cultures, ExceptionHandlingStrategy exceptionStrategy) { Guard.Argument(id, nameof(id)).NotNull(); Guard.Argument(sportEventCache, nameof(sportEventCache)).NotNull(); Guard.Argument(cultures, nameof(cultures)).NotNull().NotEmpty(); Id = id; SportId = sportId; ExecutionLog = executionLog ?? SdkLoggerFactory.GetLoggerForExecution(typeof(SportEvent)); ExceptionStrategy = exceptionStrategy; Cultures = cultures; SportEventCache = sportEventCache; }
/// <summary> /// Initializes a new instance of the <see cref="Feed"/> class /// </summary> /// <param name="config">A <see cref="IOddsFeedConfiguration"/> instance representing feed configuration</param> /// <param name="isReplay">Value indicating whether the constructed instance will be used to connect to replay server</param> protected Feed(IOddsFeedConfiguration config, bool isReplay) { Guard.Argument(config, nameof(config)).NotNull(); FeedInitialized = false; UnityContainer = new UnityContainer(); UnityContainer.RegisterBaseTypes(config); InternalConfig = UnityContainer.Resolve <IOddsFeedConfigurationInternal>(); if (isReplay || InternalConfig.Environment == SdkEnvironment.Replay) { InternalConfig.EnableReplayServer(); } _log = SdkLoggerFactory.GetLoggerForExecution(typeof(Feed)); LogInit(); }
private void LogInit() { var msg = "UF SDK .NET initialization. Version: " + SdkInfo.GetVersion(); var logger = SdkLoggerFactory.GetLoggerForFeedTraffic(typeof(Feed)); Contract.Assume(logger != null); logger.Info(msg); logger = SdkLoggerFactory.GetLoggerForCache(typeof(Feed)); logger.Info(msg); logger = SdkLoggerFactory.GetLoggerForClientInteraction(typeof(Feed)); logger.Info(msg); logger = SdkLoggerFactory.GetLoggerForRestTraffic(typeof(Feed)); logger.Info(msg); logger = SdkLoggerFactory.GetLoggerForExecution(typeof(Feed)); logger.Info(msg); logger = SdkLoggerFactory.GetLoggerForStats(typeof(Feed)); logger.Info(msg); }
/// <summary> /// Initializes a new instance of the <see cref="CompetitorCI"/> class /// </summary> /// <param name="exportable">A <see cref="ExportableCompetitorCI"/> containing information about the sport entity</param> internal void Import(ExportableCompetitorCI exportable) { try { Names = exportable.Name.IsNullOrEmpty() ? new Dictionary <CultureInfo, string>() : new Dictionary <CultureInfo, string>(exportable.Name); _countryNames = exportable.CountryNames.IsNullOrEmpty() ? new Dictionary <CultureInfo, string>() : new Dictionary <CultureInfo, string>(exportable.CountryNames); _abbreviations = exportable.Abbreviations.IsNullOrEmpty() ? new Dictionary <CultureInfo, string>() : new Dictionary <CultureInfo, string>(exportable.Abbreviations); _associatedPlayerIds = exportable.AssociatedPlayerIds.IsNullOrEmpty() ? new List <URN>() : new List <URN>(exportable.AssociatedPlayerIds.Select(URN.Parse)); _isVirtual = exportable.IsVirtual; _referenceId = exportable.ReferenceIds.IsNullOrEmpty() ? null : new ReferenceIdCI(exportable.ReferenceIds); _jerseys = exportable.Jerseys.IsNullOrEmpty() ? new List <JerseyCI>() : new List <JerseyCI>(exportable.Jerseys.Select(j => new JerseyCI(j))); _countryCode = exportable.CountryCode; _state = exportable.State; _manager = exportable.Manager == null ? null : new ManagerCI(exportable.Manager); _venue = exportable.Venue == null ? null : new VenueCI(exportable.Venue); _gender = exportable.Gender; _ageGroup = exportable.AgeGroup; _fetchedCultures = exportable.FetchedCultures.IsNullOrEmpty() ? new List <CultureInfo>() : new List <CultureInfo>(exportable.FetchedCultures); _primaryCulture = exportable.PrimaryCulture; _raceDriverProfile = exportable.RaceDriverProfile == null ? null : new RaceDriverProfileCI(exportable.RaceDriverProfile); _referenceId = exportable.ReferenceIds.IsNullOrEmpty() ? null : new ReferenceIdCI(exportable.ReferenceIds); _lastTimeCompetitorProfileFetched = DateTime.MinValue; if (exportable.LastTimeCompetitorProfileIsFetched.HasValue) { _lastTimeCompetitorProfileFetched = exportable.LastTimeCompetitorProfileIsFetched.Value; } _cultureCompetitorProfileFetched = new List <CultureInfo>(); if (exportable.CultureCompetitorProfileFetched != null) { _cultureCompetitorProfileFetched = exportable.CultureCompetitorProfileFetched.ToList(); } _sportId = exportable.SportId != null?URN.Parse(exportable.SportId) : null; _categoryId = exportable.CategoryId != null?URN.Parse(exportable.CategoryId) : null; _shortName = exportable.ShortName; } catch (Exception e) { SdkLoggerFactory.GetLoggerForExecution(typeof(CompetitorCI)).Error("Importing CompetitorCI", e); } }
private void LogInit() { var msg = "UF SDK .NET Core initialization. Version: " + SdkInfo.GetVersion(); var logger = SdkLoggerFactory.GetLoggerForExecution(typeof(Feed)); if (logger == null) { return; } logger.Log(SdkLoggerFactory.GetWriteLogLevel(logger, LogLevel.Information), $"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}"); logger = SdkLoggerFactory.GetLoggerForCache(typeof(Feed)); logger.Log(SdkLoggerFactory.GetWriteLogLevel(logger, LogLevel.Information), $"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}"); logger = SdkLoggerFactory.GetLoggerForClientInteraction(typeof(Feed)); logger.Log(SdkLoggerFactory.GetWriteLogLevel(logger, LogLevel.Information), $"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}"); logger = SdkLoggerFactory.GetLoggerForRestTraffic(typeof(Feed)); logger.Log(SdkLoggerFactory.GetWriteLogLevel(logger, LogLevel.Information), $"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}"); logger = SdkLoggerFactory.GetLoggerForFeedTraffic(typeof(Feed)); logger.Log(SdkLoggerFactory.GetWriteLogLevel(logger, LogLevel.Information), $"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}"); logger = SdkLoggerFactory.GetLoggerForStats(typeof(Feed)); logger.Log(SdkLoggerFactory.GetWriteLogLevel(logger, LogLevel.Information), $"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}"); }
private void LogInit() { var msg = "UF SDK .NET initialization. Version: " + SdkInfo.GetVersion(); var logger = SdkLoggerFactory.GetLoggerForFeedTraffic(typeof(Feed)); if (logger == null) { return; } logger.LogInformation(msg); logger = SdkLoggerFactory.GetLoggerForCache(typeof(Feed)); logger.LogInformation(msg); logger = SdkLoggerFactory.GetLoggerForClientInteraction(typeof(Feed)); logger.LogInformation(msg); logger = SdkLoggerFactory.GetLoggerForRestTraffic(typeof(Feed)); logger.LogInformation(msg); logger = SdkLoggerFactory.GetLoggerForExecution(typeof(Feed)); logger.LogInformation(msg); logger = SdkLoggerFactory.GetLoggerForStats(typeof(Feed)); logger.LogInformation(msg); }
private static void Main() { log4net.Config.XmlConfigurator.Configure(new FileInfo("log4net.config")); SdkLoggerFactory.Configure(new FileInfo("log4net.sdk.config")); _log = LogManager.GetLogger(typeof(Start)); if (!SdkLoggerFactory.CheckAllLoggersExists()) { _log.Warn("Loggers are not set correctly!"); } var key = 'y'; while (key.Equals('y')) { DoExampleSelection(); Console.WriteLine(string.Empty); Console.Write("Want to run another example? (y|n): "); key = Console.ReadKey().KeyChar; Console.WriteLine(string.Empty); } }
private static void PrintLogManagerStatus() { Console.WriteLine($"Number of loggers: {LogManager.GetCurrentLoggers().Length}"); foreach (var l in LogManager.GetCurrentLoggers()) { Console.WriteLine($"\tLogger: {l.Logger.Name}"); foreach (var a in l.Logger.Repository.GetAppenders()) { Console.WriteLine($"\t\t Appender: {a.Name}"); } } Console.WriteLine($"Number of repositories: {LogManager.GetAllRepositories().Length}"); foreach (var l in LogManager.GetAllRepositories()) { Console.WriteLine($"\tRepository: {l.Name}"); } Console.WriteLine(Environment.NewLine); var logDefault = SdkLoggerFactory.GetLogger(typeof(SdkLogTest), SdkCommon.TestData.SdkTestLogRepositoryName); var logCache = SdkLoggerFactory.GetLoggerForCache(typeof(SdkLogTest), SdkCommon.TestData.SdkTestLogRepositoryName); var logClientIteration = SdkLoggerFactory.GetLoggerForClientInteraction(typeof(SdkLogTest), SdkCommon.TestData.SdkTestLogRepositoryName); var logFeedTraffic = SdkLoggerFactory.GetLoggerForFeedTraffic(typeof(SdkLogTest), SdkCommon.TestData.SdkTestLogRepositoryName); var logRestTraffic = SdkLoggerFactory.GetLoggerForRestTraffic(typeof(SdkLogTest), SdkCommon.TestData.SdkTestLogRepositoryName); var logStatsTraffic = SdkLoggerFactory.GetLoggerForStats(typeof(SdkLogTest), SdkCommon.TestData.SdkTestLogRepositoryName); LogPrint(logDefault); LogPrint(logCache); LogPrint(logClientIteration); LogPrint(logFeedTraffic); LogPrint(logRestTraffic); LogPrint(logStatsTraffic); //for (int i = 0; i < 10000; i++) //{ // LogPrint(logRestTraffic); //} }
public void Init() { SdkLoggerFactory.Configure(new FileInfo("log4net.sdk.config"), SdkCommon.TestData.SdkTestLogRepositoryName); }
/// <summary>When overridden in a derived class, invokes the method that is specified in the provided <see cref="T:System.Runtime.Remoting.Messaging.IMessage" /> on the remote object that is represented by the current instance.</summary> /// <returns>The message returned by the invoked method, containing the return value and any out or ref parameters.</returns> /// <param name="msg">A <see cref="T:System.Runtime.Remoting.Messaging.IMessage" /> that contains a <see cref="T:System.Collections.IDictionary" /> of information about the method call. </param> public override IMessage Invoke(IMessage msg) { var logEnabled = false; var methodCall = msg as IMethodCallMessage; if (methodCall == null) { throw new ArgumentException("Input parameter 'msg' not valid IMethodCallMessage."); } var methodInfo = methodCall.MethodBase as MethodInfo; if (methodInfo == null) { throw new ArgumentException("Input parameter 'msg' does not have MethodBase as MethodInfo."); } var logger = SdkLoggerFactory.GetLogger(methodCall.MethodBase.ReflectedType, SdkLoggerFactory.SdkLogRepositoryName, _defaultLoggerType); if (_filter != null && _filter(methodInfo)) { logEnabled = true; } if (!logEnabled || _canOverrideLoggerType) { var attributes = methodInfo.GetCustomAttributes(true).ToList(); if (methodInfo.DeclaringType != null) { attributes.AddRange(methodInfo.DeclaringType.GetCustomAttributes(true)); } if (attributes.Count > 0) { foreach (var t in attributes) { if (!(t is LogAttribute)) { continue; } logEnabled = true; if (_canOverrideLoggerType) { logger = SdkLoggerFactory.GetLogger(methodCall.MethodBase.ReflectedType, SdkLoggerFactory.SdkLogRepositoryName, ((LogAttribute)t).LoggerType); } break; } } } var watch = new Stopwatch(); watch.Start(); try { if (methodCall.MethodName == "GetType") { logEnabled = false; } if (logEnabled) { logger.Info($"Starting executing '{methodCall.MethodName}' ..."); } if (logEnabled && methodCall.InArgCount > 0) { logger.Debug($"{methodCall.MethodName} arguments:"); for (var i = 0; i < methodCall.InArgCount; i++) { logger.Debug($"\t{((Type[]) methodCall.MethodSignature)[i].Name}={methodCall.InArgs[i]}"); } } var result = methodInfo.Invoke(_decorated, methodCall.InArgs); // MAIN EXECUTION var task = result as Task; if (task != null) { var perm = new LogProxyPerm { LogEnabled = logEnabled, Logger = logger, MethodCall = methodCall, MethodInfo = methodInfo, Result = result, Watch = watch }; _proxyPerms.Add(task.Id, perm); if (logEnabled) { logger.Debug($"TaskId:{task.Id} is executing and we wait to finish ..."); } task.ContinueWith(TaskExecutionFinished); return(new ReturnMessage(result, null, 0, methodCall.LogicalCallContext, methodCall)); } FinishExecution(logEnabled, methodCall, methodInfo, result?.GetType().Name, result, logger, watch); return(new ReturnMessage(result, null, 0, methodCall.LogicalCallContext, methodCall)); } catch (Exception e) { watch.Stop(); if (logEnabled) { logger.Error($"Exception during executing '{methodCall.MethodName}': {Environment.NewLine}", e); } return(new ReturnMessage(e, methodCall)); } }
public void Init() { _log = SdkLoggerFactory.GetLogger(typeof(EntityPrinterTest)); }