ignite
セキュリティモニタリングが使用可能です セキュリティモニタリングが使用可能です

ignite

Agent Check Agentチェック

Supported OS: Linux Mac OS Windows

概要

このチェックは Ignite を監視します。

セットアップ

インストール

Ignite チェックは Datadog Agent パッケージに含まれています。サーバーに追加でインストールする必要はありません。

コンフィギュレーション

Ignite のセットアップ

JMX メトリクスエクスポーターはデフォルトで有効になっていますが、ネットワークセキュリティに応じて、公開ポートを選択するか、認証を有効にする必要がある場合があります。公式の Docker イメージはデフォルトで 49112 を使用します。

ロギングについては、log4j を有効にして、完全な日付のログ形式を利用することを強くお勧めします。

ホスト

  1. ignite のパフォーマンスデータを収集するには、Agent のコンフィギュレーションディレクトリのルートにある conf.d/ フォルダーの ignite.d/conf.yaml ファイルを編集します。使用可能なすべてのコンフィギュレーションオプションについては、サンプル ignite.d/conf.yaml を参照してください。

このチェックでは、インスタンスあたりのメトリクス数が 350 に制限されています。返されたメトリクスの数は、情報ページに表示されます。 以下で説明する構成を編集することで、関心があるメトリクスを指定できます。 収集するメトリクスをカスタマイズする方法については、JMX チェックのドキュメントで詳細な手順を参照してください。 制限以上のメトリクスを監視する必要がある場合は、Datadog のサポートチームまでお問い合わせください。

  1. Agent を再起動します
ログの収集

Agent バージョン 6.0 以降で利用可能

  1. Datadog Agent で、ログの収集はデフォルトで無効になっています。以下のように、datadog.yaml でこれを有効にする必要があります。

    logs_enabled: true
  2. Ignite のログの収集を開始するには、次のコンフィギュレーションブロックを ignite.d/conf.yaml ファイルに追加します。

     logs:
       - type: file
         path: <IGNITE_HOME>/work/log/ignite-*.log
         source: ignite
         service: '<SERVICE_NAME>'
         log_processing_rules:
           - type: multi_line
             name: new_log_start_with_date
             pattern: \[\d{4}\-\d{2}\-\d{2}

    path パラメーターと service パラメーターの値を変更し、環境に合わせて構成してください。使用可能なすべてのコンフィギュレーションオプションの詳細については、サンプル ignite.d/conf.yaml を参照してください。

  3. Agent を再起動します

コンテナ化

コンテナ環境の場合は、オートディスカバリーのインテグレーションテンプレートのガイドを参照して、次のパラメーターを適用してください。

メトリクスの収集

Datadog-Ignite インテグレーションを使用してメトリクスを収集するには、JMX を使用したオートディスカバリーガイドを参照してください。

ログの収集

Agent バージョン 6.0 以降で利用可能

Datadog Agent で、ログの収集はデフォルトで無効になっています。これを有効にするには、Docker log collection を参照してください。

パラメーター
<LOG_CONFIG>{"source": "ignite", "service": "<サービス名>", "log_processing_rules":{"type":"multi_line","name":"new_log_start_with_date", "pattern":"\d{4}\-\d{2}\-\d{2}"}}

検証

Agent の status サブコマンドを実行し、Checks セクションで ignite を探します。

収集データ

メトリクス

ignite.threads.active
(gauge)
Approximate number of threads that are actively executing tasks.
Shown as thread
ignite.threads.pool_size
(gauge)
Current number of threads in the pool.
Shown as thread
ignite.threads.largest_size
(gauge)
Largest number of threads that have ever simultaneously been in the pool.
Shown as thread
ignite.threads.tasks
(rate)
Approximate total number of tasks that have been scheduled for execution.
Shown as task
ignite.threads.completed_tasks
(rate)
Approximate total number of tasks that have completed execution.
Shown as task
ignite.threads.queue_size
(gauge)
Current number of threads in the pool
Shown as thread
ignite.threads.core_pool_size
(gauge)
The core number of threads.
Shown as thread
ignite.threads.maximum_pool_size
(gauge)
The maximum allowed number of threads.
Shown as thread
ignite.allocation_rate
(gauge)
Allocation rate (pages per second) averaged across rateTimeInternal.
Shown as page
ignite.initial_memory_size
(gauge)
Initial memory region size defined by its data region.
Shown as byte
ignite.max_memory_size
(gauge)
Maximum memory region size defined by its data region.
Shown as byte
ignite.offheap_size
(gauge)
Offheap size in bytes.
Shown as byte
ignite.total_allocated_pages
(rate)
Total number of allocated pages.
Shown as page
ignite.eviction_rate
(gauge)
Eviction rate (pages per second).
Shown as page
ignite.large_entries_pages_percentage
(gauge)
Percentage of pages that are fully occupied by large entries that go beyond page size.
Shown as percent
ignite.pages_fill_factor
(gauge)
The percentage of the used space.
Shown as percent
ignite.dirty_pages
(gauge)
Number of pages in memory not yet synchronized with persistent storage.
Shown as page
ignite.pages_replace_rate
(gauge)
Rate at which pages in memory are replaced with pages from persistent storage (pages per second).
Shown as page
ignite.physical_memory_pages
(gauge)
Number of pages residing in physical RAM.
Shown as page
ignite.pages_replace_age
(gauge)
Average age at which pages in memory are replaced with pages from persistent storage (milliseconds).
Shown as page
ignite.pages_read
(rate)
Number of pages read from last restart.
Shown as page
ignite.pages_written
(rate)
Number of pages written from last restart.
Shown as page
ignite.pages_replaced
(rate)
Number of pages replaced from last restart.
Shown as page
ignite.offheap_used_size
(gauge)
Total used offheap size in bytes.
Shown as byte
ignite.total_allocated_size
(rate)
Total size of memory allocated in bytes.
Shown as byte
ignite.used_checkpoint_buffer_pages
(gauge)
Used checkpoint buffer size in pages.
Shown as page
ignite.used_checkpoint_buffer_size
(gauge)
Used checkpoint buffer size in bytes.
Shown as byte
ignite.check_point_buffer_size
(gauge)
Total size in bytes for checkpoint buffer.
Shown as byte
ignite.total_started_threads
(rate)
The total number of threads started.
Shown as thread
ignite.heap_memory_initialized
(gauge)
The initial size of memory in bytes; -1 if undefined.
Shown as byte
ignite.heap_memory_maximum
(gauge)
The maximum amount of memory in bytes; -1 if undefined.
Shown as byte
ignite.received_bytes
(rate)
Received bytes count.
Shown as byte
ignite.oubound_messages_queue_size
(gauge)
Outbound messages queue size.
Shown as message
ignite.sent_messages
(rate)
Sent messages count.
Shown as message
ignite.sent_bytes
(rate)
Sent bytes count.
Shown as byte
ignite.received_messages
(rate)
Received messages count.
Shown as message
ignite.total_cpus
(gauge)
The number of CPUs available to the Java Virtual Machine.
Shown as core
ignite.non_heap_memory_initialized
(gauge)
The initial size of non-heap memory in bytes; -1 if undefined.
Shown as byte
ignite.non_heap_memory_used
(gauge)
Current non-heap memory size that is used by Java VM.
Shown as byte
ignite.non_heap_memory_committed
(gauge)
Amount of non-heap memory in bytes that is committed for the JVM to use.
Shown as byte
ignite.non_heap_memory_maximum
(gauge)
Maximum amount of non-heap memory in bytes that can be used for memory management. -1 if undefined.
Shown as byte
ignite.current_gc_load
(gauge)
Average time spent in GC since the last update.
Shown as time
ignite.heap_memory_used
(gauge)
Current heap size that is used for object allocation.
Shown as byte
ignite.heap_memory_committed
(gauge)
The amount of committed memory in bytes.
Shown as byte
ignite.current_cpu_load
(gauge)
The system load average; or a negative value if not available.
Shown as byte
ignite.average_cpu_load
(gauge)
Average of CPU load values over all metrics kept in the history.
ignite.total_nodes
(gauge)
Total number of nodes.
Shown as node
ignite.jobs.active.maximum
(gauge)
Maximum number of jobs that ever ran concurrently on this node.
Shown as job
ignite.jobs.active.current
(gauge)
Number of currently active jobs concurrently executing on the node.
Shown as job
ignite.jobs.active.average
(gauge)
Average number of active jobs concurrently executing on the node.
Shown as job
ignite.jobs.waiting.maximum
(gauge)
Maximum number of waiting jobs this node had.
Shown as job
ignite.jobs.waiting.current
(gauge)
Number of queued jobs currently waiting to be executed.
Shown as job
ignite.jobs.waiting.average
(gauge)
Average number of waiting jobs this node had queued.
Shown as job
ignite.jobs.rejected.maximum
(gauge)
Maximum number of jobs rejected at once during a single collision resolution operation.
Shown as job
ignite.jobs.rejected.current
(gauge)
Number of jobs rejected after more recent collision resolution operation.
Shown as job
ignite.jobs.rejected.average
(gauge)
Average number of jobs this node rejects during collision resolution operations.
Shown as job
ignite.jobs.rejected.total
(rate)
Total number of jobs this node rejects during collision resolution operations since node startup.
Shown as job
ignite.jobs.cancelled.maximum
(gauge)
Maximum number of cancelled jobs this node ever had running concurrently.
Shown as job
ignite.jobs.cancelled.current
(gauge)
Number of cancelled jobs that are still running.
Shown as job
ignite.jobs.cancelled.average
(gauge)
Average number of cancelled jobs this node ever had running concurrently.
Shown as job
ignite.jobs.cancelled.total
(rate)
Total number of cancelled jobs since node startup.
Shown as job
ignite.jobs.executed.total
(rate)
Total number of jobs handled by the node.
Shown as job
ignite.jobs.execution_time.total
(rate)
Total time all finished jobs takes to execute on the node.
Shown as second
ignite.jobs.wait_time.maximum
(gauge)
Maximum time a job ever spent waiting in a queue to be executed.
Shown as second
ignite.jobs.wait_time.current
(gauge)
Current wait time of oldest job.
Shown as second
ignite.jobs.wait_time.average
(gauge)
Average time jobs spend waiting in the queue to be executed.
Shown as second
ignite.jobs.execute_time.maximum
(gauge)
Time it took to execute the longest job on the node.
Shown as second
ignite.jobs.execute_time.current
(gauge)
Longest time a current job has been executing for.
Shown as second
ignite.jobs.execute_time.average
(gauge)
Average time a job takes to execute on the node.
Shown as second
ignite.total_executed_tasks
(rate)
Total number of tasks handled by the node.
Shown as task
ignite.total_busy_time
(gauge)
Total time this node spent executing jobs.
Shown as second
ignite.total_idle_time
(gauge)
Total time this node spent idling (not executing any jobs).
Shown as second
ignite.current_idle_time
(gauge)
Time this node spend idling since executing last job.
Shown as second
ignite.busy_time_percentage
(gauge)
Percentage of time this node is busy executing jobs vs. idling.
Shown as percent
ignite.idle_time_percentage
(gauge)
Percentage of time this node is idling vs. executing jobs.
Shown as percent
ignite.heap_memory_total
(gauge)
The total amount of memory in bytes; -1 if undefined.
Shown as byte
ignite.non_heap_memory_total
(gauge)
Total amount of non-heap memory in bytes that can be used for memory management. -1 if undefined.
Shown as byte
ignite.current_thread_count
(gauge)
Current number of live threads.
Shown as thread
ignite.maximum_thread_count
(gauge)
The peak live thread count.
Shown as thread
ignite.current_daemon_thread_count
(gauge)
Current number of live daemon threads.
Shown as thread
ignite.total_baseline_nodes
(gauge)
Total baseline nodes count.
Shown as node
ignite.active_baseline_nodes
(gauge)
Active baseline nodes count.
Shown as node
ignite.total_server_nodes
(gauge)
Server nodes count.
Shown as node
ignite.total_client_nodes
(gauge)
Client nodes count.
Shown as node
ignite.jobs.maximum_failover
(gauge)
Maximum number of attempts to execute a failed job on another node.
Shown as attempt
ignite.jobs.total_failover
(rate)
Total number of jobs that were failed over.
Shown as job
ignite.transaction.committed
(rate)
The number of transactions which were committed.
Shown as transaction
ignite.transaction.rolledback
(rate)
The number of transactions which were rollback.
Shown as transaction
ignite.transaction.holding_lock
(gauge)
The number of active transactions holding at least one key lock.
Shown as transaction
ignite.transaction.locked_keys
(gauge)
The number of keys locked on the node.
Shown as key
ignite.transaction.owner
(gauge)
The number of active transactions for which this node is the initiator.
Shown as transaction
ignite.wal.archive_segments
(gauge)
Current number of WAL segments in the WAL archive.
Shown as segment
ignite.wal.logging_rate
(gauge)
Average number of WAL records per second written during the last time interval.
Shown as record
ignite.wal.writing_rate
(gauge)
Average number of bytes per second written during the last time interval.
Shown as byte
ignite.wal.buffer_poll_spin
(gauge)
WAL buffer poll spins number over the last time interval.
ignite.wal.fsync_average
(gauge)
Average WAL fsync duration in microseconds over the last time interval.
Shown as microsecond
ignite.wal.total_size
(gauge)
Total size in bytes for storage wal files.
Shown as byte
ignite.wal.last_rollover
(gauge)
Time of the last WAL segment rollover.
Shown as second
ignite.checkpoint.last_lock_wait_duration
(gauge)
Duration of the checkpoint lock wait in milliseconds.
Shown as millisecond
ignite.checkpoint.last_mark_duration
(gauge)
Duration of the checkpoint mark in milliseconds.
Shown as millisecond
ignite.checkpoint.last_pages_write_duration
(gauge)
Duration of the checkpoint pages write in milliseconds.
Shown as millisecond
ignite.checkpoint.last_fsync_duration
(gauge)
Duration of the sync phase of the last checkpoint in milliseconds.
Shown as millisecond
ignite.checkpoint.last_total_pages
(gauge)
Total number of pages written during the last checkpoint.
Shown as page
ignite.checkpoint.last_data_pages
(gauge)
Total number of data pages written during the last checkpoint.
Shown as page
ignite.checkpoint.last_copied_on_write_pages
(gauge)
Number of pages copied to a temporary checkpoint buffer during the last checkpoint.
Shown as page
ignite.checkpoint.last_duration
(gauge)
Duration of the last checkpoint in milliseconds.
Shown as second
ignite.checkpoint.total_time
(gauge)
Total checkpoint time from last restart.
Shown as second
ignite.discovery.message_worker_queue_size
(gauge)
Message worker queue current size.
ignite.discovery.nodes_joined
(rate)
Nodes joined count.
Shown as node
ignite.discovery.nodes_left
(rate)
Nodes left count.
Shown as node
ignite.discovery.nodes_failed
(rate)
Nodes failed count.
Shown as node
ignite.discovery.pending_messages_registered
(gauge)
Pending messages registered.
Shown as message
ignite.discovery.pending_messages_discarded
(gauge)
Pending messages discarded.
Shown as message
ignite.discovery.average_message_processing_time
(gauge)
Avg message processing time.
Shown as second
ignite.discovery.max_message_processing_time
(gauge)
Max message processing time.
Shown as second
ignite.discovery.total_received_messages
(rate)
Total received messages count.
Shown as message
ignite.discovery.total_processed_messages
(rate)
Total processed messages count.
Shown as message
ignite.cache.cluster_moving_partitions
(gauge)
Count of partitions for this cache group in the entire cluster with state MOVING.
ignite.cache.minimum_partition_copies
(gauge)
Minimum number of partition copies for all partitions of this cache group.
ignite.cache.maximum_partition_copies
(gauge)
Maximum number of partition copies for all partitions of this cache group.
ignite.cache.local_owning_partitions
(gauge)
Count of partitions with state OWNING for this cache group located on this node.
ignite.cache.local_moving_partitions
(gauge)
Count of partitions with state MOVING for this cache group located on this node.
ignite.cache.local_renting_partitions
(gauge)
Count of partitions with state RENTING for this cache group located on this node.
ignite.cache.local_renting_entries
(gauge)
Count of entries remains to evict in RENTING partitions located on this node for this cache group.
ignite.cache.cluster_owning_partitions
(gauge)
Count of partitions for this cache group in the entire cluster with state OWNING.
ignite.cache.backups
(gauge)
Count of backups configured for cache group.
ignite.cache.partitions
(gauge)
Count of partitions for cache group.
ignite.cache.size
(gauge)
Number of non-null values in the cache as a long value.
ignite.cache.gets
(rate)
The total number of gets to the cache.
Shown as request
ignite.cache.removals
(rate)
The total number of removals from the cache.
ignite.cache.puts
(rate)
The total number of puts to the cache.
Shown as request
ignite.cache.hits
(rate)
The number of get requests that were satisfied by the cache.
Shown as request
ignite.cache.misses
(rate)
A miss is a get request that is not satisfied.
Shown as request
ignite.cache.offheap_allocated_size
(gauge)
Memory size allocated in off-heap.
Shown as byte
ignite.cache.hit_percentage
(gauge)
Percentage of successful hits.
Shown as percent
ignite.cache.miss_percentage
(gauge)
Percentage of accesses that failed to find anything.
Shown as percent
ignite.cache.evictions
(rate)
Number of eviction entries.
Shown as eviction
ignite.cache.average_get_time
(gauge)
Average time to execute get.
Shown as second
ignite.cache.average_put_time
(gauge)
Average time to execute put.
Shown as second
ignite.cache.average_remove_time
(gauge)
Average time to execute remove.
Shown as second
ignite.cache.average_commit_time
(gauge)
Average time to commit transaction.
Shown as second
ignite.cache.average_rollback_time
(gauge)
Average time to rollback transaction.
Shown as second
ignite.cache.commits
(rate)
Number of transaction commits.
ignite.cache.rollbacks
(rate)
Number of transaction rollback.
ignite.cache.offheap_gets
(rate)
Number of gets from off-heap memory.
ignite.cache.offheap_puts
(rate)
Number of puts to off-heap memory.
ignite.cache.offheap_removals
(rate)
Number of removed entries from off-heap memory.
ignite.cache.offheap_evictions
(rate)
Number of evictions from off-heap memory.
Shown as eviction
ignite.cache.offheap_hits
(rate)
Number of hits on off-heap memory.
Shown as hit
ignite.cache.offheap_hit_percentage
(gauge)
Percentage of hits on off-heap memory.
Shown as percent
ignite.cache.offheap_misses
(rate)
Number of misses on off-heap memory.
Shown as miss
ignite.cache.offheap_miss_percentage
(gauge)
Percentage of misses on off-heap memory.
Shown as percent
ignite.cache.heap_entries
(gauge)
Number of entries in heap memory.
Shown as entry
ignite.cache.offheap_entries
(gauge)
Number of entries stored in off-heap memory.
Shown as entry
ignite.cache.offheap_primary_entries
(gauge)
Number of primary entries stored in off-heap memory.
Shown as entry
ignite.cache.offheap_backup_entries
(gauge)
Number of backup stored in off-heap memory.
ignite.cache.evict_queue_size
(gauge)
Current size of evict queue.
ignite.cache.thread_map_size
(gauge)
Transaction per-thread map size.
Shown as transaction
ignite.cache.xid_map_size
(gauge)
Transaction per-Xid map size.
Shown as transaction
ignite.cache.commit_queue_size
(gauge)
Transaction committed queue size.
Shown as transaction
ignite.cache.prepare_queue_size
(gauge)
Transaction prepared queue size.
Shown as transaction
ignite.cache.start_version_counts_size
(gauge)
Transaction start version counts map size.
Shown as transaction
ignite.cache.committed_versions_size
(gauge)
Transaction committed ID map size.
Shown as transaction
ignite.cache.rolledback_versions_size
(gauge)
Transaction rolled back ID map size.
Shown as transaction
ignite.cache.dht_thread_map_size
(gauge)
Transaction DHT per-thread map size.
Shown as transaction
ignite.cache.dht_xid_map_size
(gauge)
Transaction DHT per-Xid map size.
Shown as transaction
ignite.cache.dht_commit_queue_size
(gauge)
Transaction DHT committed queue size.
Shown as transaction
ignite.cache.dht_prepare_queue_size
(gauge)
Transaction DHT prepared queue size.
Shown as transaction
ignite.cache.dht_start_version_counts_size
(gauge)
Transaction DHT start version counts map size.
Shown as transaction
ignite.cache.dht_committed_versions_size
(gauge)
Transaction DHT committed ID map size.
Shown as transaction
ignite.cache.dht_rolledback_versions_size
(gauge)
Transaction DHT rolled back ID map size.
Shown as transaction
ignite.cache.write_behind_store_batch_size
(gauge)
Maximum size of batch for similar operations.
ignite.cache.write_behind_overflow_total
(rate)
Count of cache overflow events since write-behind cache has started.
Shown as event
ignite.cache.write_behind_overflow
(gauge)
Count of write buffer overflow events in progress at the moment.
Shown as event
ignite.cache.write_behind_retries
(gauge)
Count of cache entries that are currently in retry state.
ignite.cache.write_behind_buffer_size
(gauge)
Count of cache entries that are waiting to be flushed.
ignite.cache.entry_processor.puts
(rate)
The total number of cache invocations, caused update.
ignite.cache.entry_processor.removals
(rate)
The total number of cache invocations, caused removals.
ignite.cache.entry_processor.read_only_invocations
(rate)
The total number of cache invocations, caused no updates.
ignite.cache.entry_processor.invocations
(rate)
The total number of cache invocations.
ignite.cache.entry_processor.hits
(rate)
The total number of invocations on keys, which exist in cache.
ignite.cache.entry_processor.hit_percentage
(gauge)
The percentage of invocations on keys, which exist in cache.
Shown as percent
ignite.cache.entry_processor.misses
(rate)
The total number of invocations on keys, which don't exist in cache.
ignite.cache.entry_processor.miss_percentage
(gauge)
The percentage of invocations on keys, which don't exist in cache.
Shown as percent
ignite.cache.entry_processor.average_invocation_time
(gauge)
The mean time to execute cache invokes.
Shown as second
ignite.cache.entry_processor.minimum_invocation_time
(gauge)
So far, the minimum time to execute cache invokes.
Shown as second
ignite.cache.entry_processor.maximum_invocation_time
(gauge)
So far, the maximum time to execute cache invokes.
Shown as second
ignite.cache.total_partitions
(gauge)
Total number of partitions on current node.
ignite.cache.rebalancing_partitions
(gauge)
Number of currently rebalancing partitions on current node.
ignite.cache.rebalanced_keys
(gauge)
Number of already rebalanced keys.
Shown as key
ignite.cache.estimated_rebalancing_keys
(gauge)
Number estimated to rebalance keys.
Shown as key
ignite.cache.keys_to_rebalance
(gauge)
Estimated number of keys to be rebalanced on current node.
Shown as key
ignite.cache.rebalancing_keys_rate
(gauge)
Estimated rebalancing speed in keys.
Shown as byte
ignite.cache.rebalancing_bytes_rate
(gauge)
Estimated rebalancing speed in bytes.
Shown as byte
ignite.cache.rebalance_clearing_partitions
(gauge)
Number of partitions need to be cleared before actual rebalance start.

サービスのチェック

ignite.can_connect:
Agent が監視対象の Ignite インスタンスに接続できず、メトリクスを収集できない場合は、CRITICAL を返します。それ以外の場合は、OK を返します。

イベント

Ignite インテグレーションには、イベントは含まれません。

トラブルシューティング

ご不明な点は、Datadog のサポートチームまでお問合せください。