/** * Returns the maximum number of warm buckets for this index. If this * value is exceeded, the warm buckets with the lowest value for their * latest times are moved to cold. * * @return The maximum number of warm buckets. */ public int getMaxWarmDBCount() { return getInteger("maxWarmDBCount"); }
/** * Returns the maximum number of unique lines that are allowed * in a bucket's .data files for this index. A value of 0 means infinite * lines. * * @return The maximum number of unique lines. */ public int getMaxMetaEntries() { return getInteger("maxMetaEntries"); }
/** * Returns the frequency at which metadata is for partially synced (synced * in-place) for this index. A value of 0 disables partial syncing, so * metadata is only synced on the {@code ServiceMetaPeriod} interval. * @see #getServiceMetaPeriod * @see #setServiceMetaPeriod * * @return The metadata sync interval, in seconds. */ public int getPartialServiceMetaPeriod() { return getInteger("partialServiceMetaPeriod"); }
/** * Returns the frequency at which Splunk checks for an index throttling * condition. * * @return The frequency of the throttling check, in seconds. */ public int getThrottleCheckPeriod() { return getInteger("throttleCheckPeriod"); }
/** * Returns the current size of this index. * * @return The current size of the index, in MB. */ public int getCurrentDBSizeMB() { return getInteger("currentDBSizeMB"); }
/** * Returns the maximum age for a bucket, after which the data in this index * rolls to frozen. If archiving is necessary for frozen data, see the * {@code coldToFrozen} attributes. * * @return The maximum age, in seconds, after which data rolls to frozen. */ public int getFrozenTimePeriodInSecs() { return getInteger("frozenTimePeriodInSecs"); }
/** * Returns the maximum number of concurrent helper processes for this index. * * @return The maximum number of concurrent helper processes. */ public int getMaxRunningProcessGroups() { return getInteger("maxRunningProcessGroups", 0); }
/** * Returns the number of hot buckets that were created for this index. * * @return The number of hot buckets. */ public int getNumHotBuckets() { return getInteger("numHotBuckets", 0); }
/** * Returns the future event-time quarantine for this index. Events * that are newer than now plus this value are quarantined. * * @return The future event-time quarantine, in seconds. */ public int getQuarantineFutureSecs() { return getInteger("quarantineFutureSecs"); }
/** * Returns the past event-time quarantine for this index. Events * that are older than now minus this value are quarantined. * * @return The past event-time quarantine, in seconds. */ public int getQuarantinePastSecs() { return getInteger("quarantinePastSecs"); }
/** * Returns the target uncompressed size of individual raw slices in the * rawdata journal for this index. * * @return The target uncompressed size, in bytes. */ public int getRawChunkSizeBytes() { return getInteger("rawChunkSizeBytes"); }
/** * Returns the frequency to check for the need to create a new hot bucket * and the need to roll or freeze any warm or cold buckets for this index. * * @return The check frequency, in seconds. */ public int getRotatePeriodInSecs() { return getInteger("rotatePeriodInSecs"); }
/** * Returns the number of events that trigger the indexer to sync events. * This value is global, not a per-index value. * * @return The number of events that trigger the indexer to sync events. */ public int getSync() { return getInteger("sync"); }
/** * Returns the maximum lifetime of a hot bucket for this index. * If a hot bucket exceeds this value, Splunk rolls it to warm. * A value of 0 means an infinite lifetime. * * @return The hot bucket's maximum lifetime, in seconds. */ public int getMaxHotIdleSecs() { return getInteger("maxHotIdleSecs"); }
/** * Returns the upper bound of the target maximum timespan of * hot and warm buckets for this index. * * @return The upper bound of the target maximum timespan, in seconds. */ public int getMaxHotSpanSecs() { return getInteger("maxHotSpanSecs"); }
/** * Returns the amount of memory to allocate for buffering * a single .tsidx file into memory before flushing to disk. * * @return The amount of memory, in MB. */ public int getMaxMemMB() { return getInteger("maxMemMB"); }
/** * Returns the upper limit, in seconds, for how long an event can sit * unacknowledged in a raw slice. This value only applies when indexer * acknowledgement is enabled on forwarders and replication is enabled with * clustering. */ public int getMaxTimeUnreplicatedWithAcks() { return getInteger("maxTimeUnreplicatedWithAcks"); }
/** * Returns the number of bloom filters created for this index. * * @return The number of bloom filters. */ public int getNumBloomfilters() { return getInteger("numBloomfilters", 0); }
/** * Returns the frequency at which metadata is synced to disk for this index. * * @return The meta data sync frequency, in seconds. */ public int getServiceMetaPeriod() { return getInteger("serviceMetaPeriod"); }
/** * Returns the maximum number of hot buckets that can exist for this index. * * @return The maximum number of hot buckets. */ public int getMaxHotBuckets() { return getInteger("maxHotBuckets"); }