component-050-kernel.conf

#
# Made with all the love in the world
# by scireum in Remshalden, Germany
#
# Copyright by scireum GmbH
# http://www.scireum.de - info@scireum.de
#

# Contains product specific information. This should most probably be overridden in the application.conf.
product {

    # Contains the name of the product
    name = ""

    # Contains the current version of the product
    version = ""

    # Contains the current build number
    build = ""

    # Contains the main / base URL under which this system is reachable. Can be left empty, if no webserver
    # is running.
    baseUrl = ""

    # Contains the build date
    date = ""

    # Contains the current vcs revision
    vcs = ""

    # Contains all modules known to the system
    modules {
        # Adding the kernel module to the list of known modules...
        sirius-kernel {
            version = "${project.version}"
            build = "${build.number}"
            date = "${timestamp}"
            vcs = "${build.vcs.number}"
        }
    }

}

# Contains framework specific information
sirius {

    # Sets the node name of this instance. This should be setup in the instance.conf. If the value is empty,
    # the current hostname is used.
    nodeName = ""

    # Modules can be split into frameworks which can be disabled if not needed.
    # The kernel itself provides the TimerService which calls participants in regular intervals. This can
    # be disabled via the kernel.timer framework.
    frameworks {
        kernel.timer = true
    }

    # By default no customizations are active. This can be used to enable one or more customizations.
    # This will enable classes in "customizations.[name]" as well as resources in "customizations/[name]/resource-path".
    # This can be used to adjust small pieces of the software for multiple customers while maintaining a single
    # consistent codebase.
    customizations = []

    # If enabled a set of provided rules ensures that a minimal amount of system configuration and data is
    # present. This can be used to automatically setup an empty database etc. By default this is disabled and
    # has to be enabled for development / staging / test environments.
    autoSetup = false

}

# Contains the configuration of the native language support
nls {

    # Sets the default language as two-letter code
    defaultLanguage = en
}

# Contains settings for the dependency injector
di {
    # Lists root packages to scan. An empty lists will cause all packages to be scanned.
    # If a list is provided, it must contain "sirius" as root package so that core classes
    # are included.
    packageFilter = []
}

# Sets the logging configuration. Each logger can be enumerated here, along with its log level
# This can be OFF, FINE, INFO, WARNING, SEVERE - the default level is INFO
logging {
    # Turn this on to log "ignored" or unnecessary exceptions.
    ignored = OFF
}

# Determines when the processing of end of day tasks starts.
# The processing will run until all tasks are completed or until health.endOfDayTasksLimit is reached...
timer.daily.end-of-day = 22

# Sets up the caching system
cache {

    # Default settings applied to each cache if not further specified
    default {
        # Determines the maximal number of entries in the cache
        maxSize = 128

        # Determines the maximal time to live for a cached object. After this period, the entry will be evicted.
        ttl = 1 hour

        # If the cache can verify values, this determines the interval after which a value needs to be verified
        # before it is served to the requestor.
        verification = 1 hour
    }

}

http.outcall {
    # Outcall (and also XMLCall and SOAPClient) use an internal mini-blacklist. Each host which ran into a
    # connect timeout, is put onto a "blacklist" and no further connections will be attempted for the given
    # amount of time as defined here.
    #
    # This hopefully prevents "cascading" failures e.g. if a page load itself triggers multiple requests
    # (think of a shop system which tries to fetch prices for multiple items), the connect timeout might
    # add up pretty quickly. Therefore, we only try once and then stop trying so that we can render the
    # remaining part of the site (or at least fail gracefully).
    #
    # Set this value to 0 to disable blacklisting.
    connectTimeoutBlacklistDuration = 10s

    # Contains the default timeouts. "default" will take effect in every call in which no other timeout is specified.
    #
    # This timeouts can be expanded by new blocks in dependant projects. For the configuration to take effect, on an
    # outcall the sirius.kernel.xml.Outcall.withConfiguredTimeout needs to be called with the defined block
    # key as parameter.
    timeouts {

        # Defines the default timeouts which are set if no other timeout was configured
        default {
            # The default outcall connect timeout
            connectTimeout = 30s

            # The default outcall read timeout
            readTimeout = 5m
        }

        # Defines the default soap timeouts
        soap {
            # The default soap outcall connect timeout
            connectTimeout = 5s

            # The default soap outcall read timeout
            readTimeout = 5s
        }
    }
}

# Sets of the async execution system
async {

    executor {

        # Default settings applied to each executor if not further specified
        default {
            # Max number of parallel threads used by this executor
            poolSize = 20

            # Max number of tasks queued if all threads are busy. If the queue length is reached, the executor will
            # either block the caller and execute tasks at the callsite or it will drop the task and not do anything
            # at all (if a drop handler for this task is present). If a value of 0 is specified an unbounded
            # queue is used. If a negative value is used, no items will be queued.
            queueLength = 200
        }

        # Used by BackgroundLoop(s) as default executor to perform system maintenance tasks
        background {
            poolSize = 32
            queueLength = 0
        }

        # The Timers class starts all timer related tasks in this executor. Since one might task some time to
        # initialize we use two threads. We also provide a bit of a queue as the Timers class shovels all
        # tasks into the executor at once, so there might be a short contention.
        timer {
            poolSize = 2
            queueLength = 50
        }
    }

}


# Configures the system health monitoring
health {

    # Determines settings for the MemoryBasedHealthMonitor, which provides logs and error reporting
    # if no other LogTap or ExceptionHandler is installed. This is also used to report how many
    # logs / min and exceptions / min occur.
    memory {
        # Max number of exceptions to keep in ram
        max-errors = 100

        # Max number of logs to keep in ram
        max-logs = 100
    }

    # Specifies the limit (in milliseconds) for GC pauses to be logged. Note that the GCMonitoringTask measures
    # the cumulative GC runtime every 10 seconds. If the runtime exceeds the given threshold and the logger
    # "gc" is set to FINE, an appropriate message will be logged.
    # Note that this is sort of a debugging tool for desperate measures and thus disabled by default. Ongoing excessive
    # GC usage will already be detected by the metrics collector (see limit jvm-gc-utilization) - this is more of a
    # way to correlate application lags to GC pauses.
    gcPauseLoggingThreshold = 1000

    # Determines the last hour (inclusive) in which end of day tasks are executed.
    # If procesing after that hour (of day) hasn't been completed, it is aborted
    # and wil be resumed in the next night. See EndOfDayTask for a detailed
    # description on the theory of operations.
    end-of-day-limit = 5

    # Defines limits for all collected metrics which will cause the system state to be set appropriately
    # Note that 0 means "no limit". Also all given limits are best guesses and depend heavily on the application
    # and the machine the software is running on. The given values are always "per minute" or in percents.
    # .gray always defines a limit where everything below is considered "uninteresting" (GRAY). Everything above
    # .warn and below .warning is "ok" (GREEN). Everything above .warning and below .error is "warning" (YELLOW) and
    # indicates that a metric is in a critical region. Everything above .red is "error" (RED) and signals a failure
    # condition. Using "0" for any value disable the respective limit.
    limits {

        # Number of log lines written per minute
        sys-logs.gray = 10
        sys-logs.warning = 100
        sys-logs.error = 250

        # Number of incidents
        sys-incidents.gray = 1
        sys-incidents.warning = 1000
        sys-incidents.error = 0

        # Number of unique incidents (from different locations)
        sys-unique-incidents.gray = 1
        sys-unique-incidents.warning = 10
        sys-unique-incidents.error = 25

        # Size of all log files in mb
        sys-log-size.gray = 32
        sys-log-size.warning = 128
        sys-log-size.error = 0

        # Filesystem usage in %
        sys-fs.gray = 80
        sys-fs.warning = 80
        sys-fs.error = 95

        # CPU utilization caused by the JVM in %
        jvm-cpu.gray = 10
        jvm-cpu.warning = 80
        jvm-cpu.error = 0

        # Heap usage in %
        jvm-heap.gray = 50
        jvm-heap.warning = 75
        jvm-heap.error = 0

        # Old gen usage in %
        jvm-old-heap.gray = 50
        jvm-old-heap.warning = 75
        jvm-old-heap.error = 0

        # Number of garbage collections performed
        jvm-gc-runs.gray = 25
        jvm-gc-runs.warning = 100
        jvm-gc-runs.error = 0

        # Garbage collector utilization in %.
        # For a measured interval, this is the percentage of system time spent running one of its
        # collectors.
        jvm-gc-utilization.gray = 5
        jvm-gc-utilization.warning = 10
        jvm-gc-utilization.error = 0

        # Number of tasks / events processed by the system
        sys-interactions.gray = 250
        sys-interactions.warning = 0
        sys-interactions.error = 0

        # Number of tasks / events processed by the system
        sys-interactions.gray = 250
        sys-interactions.warning = 0
        sys-interactions.error = 0

        # Number of active operations
        active-operations.gray = 0

        # Number of (probably) hanging operations
        hanging-operations.gray = 0
        hanging-operations.warning = 1
        hanging-operations.error = 2

        # Number of tasks being put into the delay line
        delay-line-tasks.gray = 10
        delay-line-tasks.warning = 0
        delay-line-tasks.error = 0

        # Number of tasks currently in the delay line
        delay-line-length.gray = 0
        delay-line-length.warning = 100
        delay-line-length.error = 0

        # Number of HTTP(S) outcalls
        sys-outcall-count.gray = 0
        sys-outcall-count.warning = 0
        sys-outcall-count.error = 0

        # Avg. time to first bytes of HTTP(S) outcalls
        sys-outcall-avg-ttfb.gray = 0
        sys-outcall-avg-ttfb.warning = 1000
        sys-outcall-avg-ttfb.error = 0

        # Number of SOAP outcalls
        sys-soapcall-count.gray = 0
        sys-soapcall-count.warning = 0
        sys-soapcall-count.error = 0

        # Avg. response time of SOAP calls
        sys-soap-avg-response-time.gray = 0
        sys-soap-avg-response-time.warning = 250
        sys-soap-avg-response-time.error = 0
    }

}

# Contains settings which determines which docker-compose file to start
docker {
    # Contains the name of the docker-compose file to use...
    file = []
    file = [${?SIRIUS_DOCKER_FILE}]

    # Determines if docker-compose pull should be executed for each start...
    pull = false

    # Contains the number of retries when talking to docker-compose
    retryAttempts = 2

    # Contains the project name to use (empty = random name)
    project = ""
    project = ${?SIRIUS_DOCKER_PROJECT}

    # Can be used to supply a custom host IP. This might be useful
    # when the environment is composed within a container (e.g. on a build system).
    # It will supply the docker-compose environment
    # with the value as 'DOCKER_HOST' and use the IP for internal addressing.
    # 'DOCKER_HOST' will be prepended with TCP protocol and appended with #docker.hostPort.
    # E.g.: DOCKER_HOST = "tcp://<IP>:2375"
    # If left empty, docker-compose will default to local docker daemon via socket
    # (like unix:///var/run/docker.sock Note: that is no valid configuration as IP is missing).
    hostIp = ""
    hostIp = ${?SIRIUS_DOCKER_HOST}

    # Used in combination with #docker.hostIp to determine the 'DOCKER_HOST' TCP address.
    hostPort = "2375"
    hostPort = ${?SIRIUS_DOCKER_PORT}

    # Determines if docker containers are kept running across restarts.
    # This should most probably set to true in development environment and set to
    # false when running tests.
    keepRunning = false
}