Tabnine Logo
LoggingService.getLogger
Code IndexAdd Tabnine to your IDE (free)

How to use
getLogger
method
in
com.hazelcast.logging.LoggingService

Best Java code snippets using com.hazelcast.logging.LoggingService.getLogger (Showing top 20 results out of 315)

origin: hazelcast/hazelcast-jet

AbstractJobProxy(T container, long jobId) {
  this.jobId = jobId;
  this.container = container;
  this.logger = loggingService().getLogger(Job.class);
}
origin: hazelcast/hazelcast-jet

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

TransactionProxy(HazelcastClientInstanceImpl client, TransactionOptions options, ClientConnection connection) {
  this.options = options;
  this.client = client;
  this.connection = connection;
  this.logger = client.getLoggingService().getLogger(TransactionProxy.class);
}
origin: hazelcast/hazelcast-jet

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);
}
origin: hazelcast/hazelcast-code-samples

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();
}
origin: hazelcast/hazelcast-jet

public ClientPartitionServiceImpl(HazelcastClientInstanceImpl client) {
  this.client = client;
  this.logger = client.getLoggingService().getLogger(ClientPartitionService.class);
  clientExecutionService = (ClientExecutionServiceImpl) client.getClientExecutionService();
}
origin: hazelcast/hazelcast-jet

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);
}
origin: hazelcast/hazelcast-jet

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());
}
origin: hazelcast/hazelcast-jet

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);
  }
}
origin: hazelcast/hazelcast-jet

public ClientMapInvalidationMetaDataFetcher(ClientContext clientContext) {
  super(clientContext.getLoggingService().getLogger(ClientMapInvalidationMetaDataFetcher.class));
  this.clusterService = clientContext.getClusterService();
  this.clientImpl = (HazelcastClientInstanceImpl) clientContext.getHazelcastInstance();
}
origin: hazelcast/hazelcast-jet

@Override
protected void onInitialize() {
  logger = getContext().getLoggingService().getLogger(getClass());
  statsHandler = new CacheStatsHandler(getSerializationService());
}
origin: hazelcast/hazelcast-jet

public ClientCacheInvalidationMetaDataFetcher(ClientContext clientContext) {
  super(clientContext.getLoggingService().getLogger(ClientCacheInvalidationMetaDataFetcher.class));
  this.clusterService = clientContext.getClusterService();
  this.clientImpl = (HazelcastClientInstanceImpl) clientContext.getHazelcastInstance();
}
origin: hazelcast/hazelcast-jet

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());
}
origin: com.hazelcast/hazelcast-all

public ClientCacheInvalidationMetaDataFetcher(ClientContext clientContext) {
  super(clientContext.getLoggingService().getLogger(ClientCacheInvalidationMetaDataFetcher.class));
  this.clusterService = clientContext.getClusterService();
  this.clientImpl = (HazelcastClientInstanceImpl) clientContext.getHazelcastInstance();
}
origin: hazelcast/hazelcast-jet

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();
}
origin: hazelcast/hazelcast-jet

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);
}
origin: hazelcast/hazelcast-jet

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);
}
origin: hazelcast/hazelcast-jet

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());
}
origin: hazelcast/hazelcast-jet

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);
}
origin: hazelcast/hazelcast-jet

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);
  }
}
com.hazelcast.loggingLoggingServicegetLogger

Popular methods of LoggingService

  • addLogListener

Popular in Java

  • Parsing JSON documents to java classes using gson
  • setContentView (Activity)
  • onCreateOptionsMenu (Activity)
  • scheduleAtFixedRate (ScheduledExecutorService)
  • ConnectException (java.net)
    A ConnectException is thrown if a connection cannot be established to a remote host on a specific po
  • URLEncoder (java.net)
    This class is used to encode a string using the format required by application/x-www-form-urlencoded
  • NoSuchElementException (java.util)
    Thrown when trying to retrieve an element past the end of an Enumeration or Iterator.
  • ThreadPoolExecutor (java.util.concurrent)
    An ExecutorService that executes each submitted task using one of possibly several pooled threads, n
  • JFileChooser (javax.swing)
  • IOUtils (org.apache.commons.io)
    General IO stream manipulation utilities. This class provides static utility methods for input/outpu
  • CodeWhisperer alternatives
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now