/** * Sets 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 #setServiceMetaPeriod * @see #getServiceMetaPeriod * * @param frequency The metadata sync interval, in seconds. */ public void setPartialServiceMetaPeriod(int frequency) { setCacheValue("partialServiceMetaPeriod", frequency); }
/** * Sets a quarantine for events that are timestamped in the past to help * prevent main hot buckets from being polluted with fringe events. Events * that are older than "now" plus this value are quarantined. * * @param window The past event-time quarantine, in seconds. */ public void setQuarantinePastSecs(int window) { setCacheValue("quarantinePastSecs", window); }
/** * Sets the amount of memory allocated for buffering a single .tsidx * file before flushing to disk. * * @param memory The amount of memory, in MB. */ public void setMaxMemMB(int memory) { setCacheValue("maxMemMB", memory); }
/** * Sets 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. * * @param frequency The check frequency, in seconds. */ public void setRotatePeriodInSecs(int frequency) { setCacheValue("rotatePeriodInSecs", frequency); }
/** * Sets the maximum number of warm buckets. If this number is exceeded, * the warm buckets with the lowest value for their latest times will be * moved to cold. * * @param buckets The maximum number of warm buckets. */ public void setMaxWarmDBCount(int buckets) { setCacheValue("maxWarmDBCount", buckets); }
/** * Sets the frequency at which Splunkd forces a file system sync while * compressing journal slices for this index. A value of "disable" disables * this feature completely, while a value of 0 forces a file-system sync * after completing compression of every journal slice. * * @param frequency The file-system sync frequency, as an integer or * "disable". */ public void setMinRawFileSyncSecs(String frequency) { setCacheValue("minRawFileSyncSecs", frequency); }
/** * Sets a quarantine for events that are timestamped in the future to help * prevent main hot buckets from being polluted with fringe events. Events * that are newer than "now" plus this value are quarantined. * * @param window The future event-time quarantine, in seconds. */ public void setQuarantineFutureSecs(int window) { setCacheValue("quarantineFutureSecs", window); }
/** * Sets the number of events that make up a block for block signatures. A * value of 100 is recommended. A value of 0 disables block signing for this * index. * * @param value The event count for block signing. */ public void setBlockSignSize(int value) { setCacheValue("blockSignSize", value); }
/** * Sets the time that indicates a bucket age. When a warm or cold bucket * is older than this, Splunk does not create or rebuild its bloomfilter. * The valid format is <i>number</i> followed by a time unit ("s", "m", "h", * or "d"). For example, "30d" for 30 days. * @param time The time that indicates a bucket age. */ public void setMaxBloomBackfillBucketAge(String time) { setCacheValue("maxBloomBackfillBucketAge", time); }
/** * Sets the frequency at which metadata is synced to disk for this index. * * @param frequency The meta data sync frequency, in seconds. */ public void setServiceMetaPeriod(int frequency) { setCacheValue("serviceMetaPeriod", frequency); }
/** * Sets the frequency at which Splunk checks for an index throttling * condition. * * @param frequency The frequency of the throttling check, in seconds. */ public void setThrottleCheckPeriod(int frequency) { setCacheValue("throttleCheckPeriod", frequency); }
/** * Sets the number of concurrent optimize processes that can run against * a hot bucket for this index. * * @param processes The number of concurrent optimize processes. */ public void setMaxConcurrentOptimizes(int processes) { setCacheValue("maxConcurrentOptimizes", processes); }
/** * Sets the maximum size for this index. If an index grows larger than this * value, the oldest data is frozen. * * @param size The maximum index size, in MB. */ public void setMaxTotalDataSizeMB(int size) { setCacheValue("maxTotalDataSizeMB", size); }
/** * Sets whether the data retrieved from this index is UTF8-encoded. * <p> * <b>Note:</b> Indexing performance degrades when this parameter is set to * {@code true}. * * In Splunk 5.0 and later, this is a global property and cannot be set on * a per-index basis. * * @param assure {@code true} to ensure UTF8 encoding, {@code false} if not. */ public void setAssureUTF8(boolean assure) { setCacheValue("assureUTF8", assure); }
/** * Sets the upper limit 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. * <p> * This number should not exceed the acknowledgement timeout configured on * any forwarder. * * @param value The upper limit, in seconds. A value of 0 disables this * setting (not recommended). */ public void setMaxTimeUnreplicatedWithAcks(int value) { setCacheValue("maxTimeUnreplicatedWithAcks", value); }
/** * Sets the suggested size of the .tsidx file for the bucket rebuild * process. * * Valid values are: "auto", a positive integer, or a positive * integer followed by "KB", "MB", or "GB". * * @param value The suggested size of the .tsidx file for the bucket rebuild * process. */ public void setBucketRebuildMemoryHint(String value) { setCacheValue("bucketRebuildMemoryHint", value); }
/** * Sets whether asynchronous "online fsck" bucket repair is enabled. * <p> * When this feature is enabled, you don't have to wait for buckets to be * repaired before starting Splunk, but you might notice a slight * degradation in performance as a result. * * @param value {@code true} to enable online bucket repair, {@code false} * if not. */ public void setEnableOnlineBucketRepair(boolean value) { setCacheValue("enableOnlineBucketRepair", value); }
/** * Sets the maximum age for a bucket, after which the data in this index * rolls to frozen. Freezing data removes it from the index. To archive * data, see {@code coldToFrozenDir} and {@code coldToFrozenScript}. * @see #setColdToFrozenDir * @see #setColdToFrozenScript * * @param seconds The time, in seconds, after which indexed data rolls to * frozen. */ public void setFrozenTimePeriodInSecs(int seconds) { setCacheValue("frozenTimePeriodInSecs", seconds); }
/** * Sets the maximum data size before triggering a roll from hot to warm * buckets for this index. You can also specify a value to let Splunk * autotune this parameter: use "auto_high_volume" for high-volume indexes * (such as the main index, or one that gets over 10GB of data per day); * otherwise, use "auto". * @see #getMaxDataSize * * @param size The size in MB, or an autotune string. */ public void setMaxDataSize(String size) { setCacheValue("maxDataSize", size); }
/** * Sets the upper limit for how long an event can sit in a * raw slice. This value applies only when replication is enabled for this * index, and is ignored otherwise.<br> * If there are any acknowledged events sharing this raw slice, the * {@code MaxTimeUnreplicatedWithAcksparamater} applies instead. * * @param value The upper limit, in seconds. A value of 0 disables this * setting. */ public void setMaxTimeUnreplicatedNoAcks(int value) { setCacheValue("maxTimeUnreplicatedNoAcks", value); }