How to use

getLogger

method

in

com.hazelcast.logging.LoggingService

AbstractJobProxy(T container, long jobId) {
  this.jobId = jobId;
  this.container = container;
  this.logger = loggingService().getLogger(Job.class);
}

public ManagementCenterPublisher(
    @Nonnull LoggingService loggingService,
    @Nonnull ObjLongConsumer<byte[]> writeFn
) {
  this.consumer = writeFn;
  logger = loggingService.getLogger(getClass());
  reset(INITIAL_BUFFER_SIZE);
}

TransactionProxy(HazelcastClientInstanceImpl client, TransactionOptions options, ClientConnection connection) {
  this.options = options;
  this.client = client;
  this.connection = connection;
  this.logger = client.getLoggingService().getLogger(TransactionProxy.class);
}

public TcpIpConnector(TcpIpConnectionManager connectionManager) {
  this.connectionManager = connectionManager;
  this.ioService = connectionManager.getIoService();
  this.logger = ioService.getLoggingService().getLogger(getClass());
  Collection<Integer> ports = ioService.getOutboundPorts();
  this.outboundPortCount = ports.size();
  this.outboundPorts.addAll(ports);
}

private SimpleMapTest(int threadCount, int entryCount, int valueSize, int getPercentage, int putPercentage, boolean load) {
  this.threadCount = threadCount;
  this.entryCount = entryCount;
  this.valueSize = valueSize;
  this.getPercentage = getPercentage;
  this.putPercentage = putPercentage;
  this.load = load;
  Config cfg = new XmlConfigBuilder().build();
  instance = Hazelcast.newHazelcastInstance(cfg);
  logger = instance.getLoggingService().getLogger("SimpleMapTest");
  random = new Random();
}

public ClientPartitionServiceImpl(HazelcastClientInstanceImpl client) {
  this.client = client;
  this.logger = client.getLoggingService().getLogger(ClientPartitionService.class);
  clientExecutionService = (ClientExecutionServiceImpl) client.getClientExecutionService();
}

public TcpIpConnection(TcpIpConnectionManager connectionManager,
            int connectionId,
            Channel channel) {
  this.connectionId = connectionId;
  this.connectionManager = connectionManager;
  this.ioService = connectionManager.getIoService();
  this.logger = ioService.getLoggingService().getLogger(TcpIpConnection.class);
  this.channel = channel;
  channel.attributeMap().put(TcpIpConnection.class, this);
}

public TcpIpConnectionErrorHandler(TcpIpConnectionManager connectionManager, Address endPoint) {
  this.endPoint = endPoint;
  this.ioService = connectionManager.getIoService();
  this.minInterval = ioService.getConnectionMonitorInterval();
  this.maxFaults = ioService.getConnectionMonitorMaxFaults();
  this.logger = ioService.getLoggingService().getLogger(getClass());
}

AbstractJobProxy(T container, long jobId, DAG dag, JobConfig config) {
  this.jobId = jobId;
  this.container = container;
  this.logger = loggingService().getLogger(Job.class);
  try {
    doSubmitJob(dag, config);
    joinedJob.set(true);
    doInvokeJoinJob();
  } catch (Throwable t) {
    throw rethrow(t);
  }
}

public ClientMapInvalidationMetaDataFetcher(ClientContext clientContext) {
  super(clientContext.getLoggingService().getLogger(ClientMapInvalidationMetaDataFetcher.class));
  this.clusterService = clientContext.getClusterService();
  this.clientImpl = (HazelcastClientInstanceImpl) clientContext.getHazelcastInstance();
}

@Override
protected void onInitialize() {
  logger = getContext().getLoggingService().getLogger(getClass());
  statsHandler = new CacheStatsHandler(getSerializationService());
}

public ClientCacheInvalidationMetaDataFetcher(ClientContext clientContext) {
  super(clientContext.getLoggingService().getLogger(ClientCacheInvalidationMetaDataFetcher.class));
  this.clusterService = clientContext.getClusterService();
  this.clientImpl = (HazelcastClientInstanceImpl) clientContext.getHazelcastInstance();
}

public TextDecoder(TcpIpConnection connection, TextEncoder encoder, TextProtocolFilter textProtocolFilter,
    TextParsers textParsers) {
  IOService ioService = connection.getConnectionManager().getIoService();
  this.textCommandService = ioService.getTextCommandService();
  this.encoder = encoder;
  this.connection = connection;
  this.textProtocolFilter = textProtocolFilter;
  this.textParsers = textParsers;
  this.logger = ioService.getLoggingService().getLogger(getClass());
}

public ClientCacheInvalidationMetaDataFetcher(ClientContext clientContext) {
  super(clientContext.getLoggingService().getLogger(ClientCacheInvalidationMetaDataFetcher.class));
  this.clusterService = clientContext.getClusterService();
  this.clientImpl = (HazelcastClientInstanceImpl) clientContext.getHazelcastInstance();
}

public ClientMembershipListener(HazelcastClientInstanceImpl client) {
  this.client = client;
  logger = client.getLoggingService().getLogger(ClientMembershipListener.class);
  connectionManager = (ClientConnectionManagerImpl) client.getConnectionManager();
  partitionService = (ClientPartitionServiceImpl) client.getClientPartitionService();
  clusterService = (ClientClusterServiceImpl) client.getClientClusterService();
}

public IOBalancer(NioThread[] inputThreads,
         NioThread[] outputThreads,
         String hzName,
         int balancerIntervalSeconds, LoggingService loggingService) {
  this.logger = loggingService.getLogger(IOBalancer.class);
  this.balancerIntervalSeconds = balancerIntervalSeconds;
  this.strategy = createMigrationStrategy();
  this.hzName = hzName;
  this.inLoadTracker = new LoadTracker(inputThreads, logger);
  this.outLoadTracker = new LoadTracker(outputThreads, logger);
  this.enabled = isEnabled(inputThreads, outputThreads);
}

public ClientConnection(HazelcastClientInstanceImpl client, int connectionId) {
  this.client = client;
  this.responseHandler = client.getInvocationService().getResponseHandler();
  this.connectionManager = (ClientConnectionManagerImpl) client.getConnectionManager();
  this.lifecycleService = client.getLifecycleService();
  this.connectionId = connectionId;
  this.channel = null;
  this.logger = client.getLoggingService().getLogger(ClientConnection.class);
}

public ClientReliableTopicProxy(String objectId, ClientContext context, HazelcastClientInstanceImpl client) {
  super(SERVICE_NAME, objectId, context);
  this.ringbuffer = client.getRingbuffer(TOPIC_RB_PREFIX + objectId);
  this.serializationService = client.getSerializationService();
  this.config = client.getClientConfig().getReliableTopicConfig(objectId);
  this.executor = getExecutor(config, client);
  this.overloadPolicy = config.getTopicOverloadPolicy();
  logger = client.getLoggingService().getLogger(getClass());
}

public XATransactionProxy(HazelcastClientInstanceImpl client, ClientConnection connection, Xid xid, int timeout) {
  this.client = client;
  this.connection = connection;
  this.timeout = timeout;
  this.xid = new SerializableXID(xid.getFormatId(), xid.getGlobalTransactionId(), xid.getBranchQualifier());
  logger = client.getLoggingService().getLogger(XATransactionProxy.class);
}

private void registerInvalidationListener() {
  try {
    invalidationListenerId = addNearCacheInvalidationListener(new ReplicatedMapAddNearCacheEventHandler());
  } catch (Exception e) {
    ILogger logger = getContext().getLoggingService().getLogger(ClientReplicatedMapProxy.class);
    logger.severe("-----------------\nNear Cache is not initialized!\n-----------------", e);
  }
}