application.conf

akka {
    log-config-on-start = off
    log-config-on-start = ${?KNORA_AKKA_LOG_CONFIG_ON_START}
    loggers = ["akka.event.slf4j.Slf4jLogger"]
    loglevel = "ERROR"
    loglevel = ${?KNORA_AKKA_LOGLEVEL}
    stdout-loglevel = "ERROR"
    stdout-loglevel = ${?KNORA_AKKA_STDOUT_LOGLEVEL}
    logging-filter = "akka.event.slf4j.Slf4jLoggingFilter"
    log-dead-letters = off
    log-dead-letters-during-shutdown = off

    // akka-http configuration
    http {
        server {
            # The requested maximum length of the queue of incoming connections.
            # If the server is busy and the backlog is full the OS will start dropping
            # SYN-packets and connection attempts may fail. Note, that the backlog
            # size is usually only a maximum size hint for the OS and the OS can
            # restrict the number further based on global limits.
            backlog = 100

            # The time after which an idle connection will be automatically closed.
            # Set to `infinite` to completely disable idle connection timeouts.
            #
            # Must be larger then request-timeout
            idle-timeout = 30 minutes

            # Defines the default time period within which the application has to
            # produce an HttpResponse for any given HttpRequest it received.
            # The timeout begins to run when the *end* of the request has been
            # received, so even potentially long uploads can have a short timeout.
            # Set to `infinite` to completely disable request timeout checking.
            #
            # If this setting is not `infinite` the HTTP server layer attaches a
            # `Timeout-Access` header to the request, which enables programmatic
            # customization of the timeout period and timeout response for each
            # request individually.
            #
            # Must be smaller then idle-timeout
            request-timeout = 30 minutes

            # The maximum number of concurrently accepted connections when using the
            # `Http().bindAndHandle` methods.
            #
            # This setting doesn't apply to the `Http().bind` method which will still
            # deliver an unlimited backpressured stream of incoming connections.
            #
            # Note, that this setting limits the number of the connections on a best-effort basis.
            # It does *not* strictly guarantee that the number of established TCP connections will never
            # exceed the limit (but it will be approximately correct) because connection termination happens
            # asynchronously. It also does *not* guarantee that the number of concurrently active handler
            # flow materializations will never exceed the limit for the reason that it is impossible to reliably
            # detect when a materialization has ended.
            max-connections = 1024

            # The maximum number of requests that are accepted (and dispatched to
            # the application) on one single connection before the first request
            # has to be completed.
            # Incoming requests that would cause the pipelining limit to be exceeded
            # are not read from the connections socket so as to build up "back-pressure"
            # to the client via TCP flow control.
            # A setting of 1 disables HTTP pipelining, since only one request per
            # connection can be "open" (i.e. being processed by the application) at any
            # time. Set to higher values to enable HTTP pipelining.
            # This value must be > 0 and <= 1024.
            pipelining-limit = 1

            parsing {
                max-content-length = 110M

                # Defines the maximum length of the URL
                # Set to 10k because Sparql queries for the extended search v2 are submitted as segments of the URL
                max-uri-length = 10k

            }
        }

        client {
            # The time period within which the TCP connecting process must be completed.
            connecting-timeout = 9999 ms // 10 s

            # The time after which an idle connection will be automatically closed.
            # Set to `infinite` to completely disable idle timeouts.
            idle-timeout = 479999 ms // 480 s

            parsing {
                max-chunk-size             = 2m
                max-response-reason-length = 1024
            }
        }

        host-connection-pool {
            # The maximum number of parallel connections that a connection pool to a
            # single host endpoint is allowed to establish. Must be greater than zero.
            max-connections = 15

            # The minimum number of parallel connections that a pool should keep alive ("hot").
            # If the number of connections is falling below the given threshold, new ones are being spawned.
            # You can use this setting to build a hot pool of "always on" connections.
            # Default is 0, meaning there might be no active connection at given moment.
            # Keep in mind that `min-connections` should be smaller than `max-connections` or equal
            min-connections = 0

            # The maximum number of times failed requests are attempted again,
            # (if the request can be safely retried) before giving up and returning an error.
            # Set to zero to completely disable request retries.
            max-retries = 3

            # The maximum number of open requests accepted into the pool across all
            # materializations of any of its client flows.
            # Protects against (accidentally) overloading a single pool with too many client flow materializations.
            # Note that with N concurrent materializations the max number of open request in the pool
            # will never exceed N * max-connections * pipelining-limit.
            # Must be a power of 2 and > 0!
            max-open-requests = 64

            # The maximum number of requests that are dispatched to the target host in
            # batch-mode across a single connection (HTTP pipelining).
            # A setting of 1 disables HTTP pipelining, since only one request per
            # connection can be "in flight" at any time.
            # Set to higher values to enable HTTP pipelining.
            # This value must be > 0.
            # (Note that, independently of this setting, pipelining will never be done
            # on a connection that still has a non-idempotent request in flight.
            #
            # Before increasing this value, make sure you understand the effects of head-of-line blocking.
            # Using a connection pool, a request may be issued on a connection where a previous
            # long-running request hasn't finished yet. The response to the pipelined requests may then be stuck
            # behind the response of the long-running previous requests on the server. This may introduce an
            # unwanted "coupling" of run time between otherwise unrelated requests.
            #
            # See http://tools.ietf.org/html/rfc7230#section-6.3.2 for more info.)
            pipelining-limit = 1

            # The time after which an idle connection pool (without pending requests)
            # will automatically terminate itself. Set to `infinite` to completely disable idle timeouts.
            idle-timeout = 30 s

            # Modify to tweak client settings for host connection pools only.
            #
            # IMPORTANT:
            # Please note that this section mirrors `akka.http.client` however is used only for pool-based APIs,
            # such as `Http().superPool` or `Http().singleRequest`.
            client = {
                # no overrides, see `akka.http.client` for used values
            }
        }
    }
}

akka.actor.deployment {

    /applicationManager/storeManager/triplestoreManager/httpTriplestoreRouter {
        router = balancing-pool
        nr-of-instances = 10
        nr-of-instances = ${?KNORA_WEBAPI_DB_CONNECTIONS}
        pool-dispatcher {
            executor = "thread-pool-executor"

            # allocate exactly 10 threads for this pool
            thread-pool-executor {
                core-pool-size-min = 2
                core-pool-size-min = ${?KNORA_WEBAPI_DB_CONNECTIONS}
                core-pool-size-max = 2
                core-pool-size-max = ${?KNORA_WEBAPI_DB_CONNECTIONS}
            }
        }
    }

    /applicationManager/storeManager/iiifManager/sipiConnector {
        router = balancing-pool
        nr-of-instances = 10
        pool-dispatcher {
            executor = "thread-pool-executor"

            # allocate exactly 10 threads for this pool
            thread-pool-executor {
                core-pool-size-min = 10
                core-pool-size-max = 10
            }
        }
    }
}

// all responder actors should run on this dispatcher
knora-actor-dispatcher {
    type = Dispatcher

    executor = "fork-join-executor"
    # Configuration for the fork join pool
    fork-join-executor {
        parallelism-min = 8
        parallelism-factor = 2.0
        parallelism-max = 32
    }

    throughput = 5
}

// any futures or blocking code should run on this dispatcher
knora-blocking-dispatcher {
    type = Dispatcher

    executor = "thread-pool-executor"

    thread-pool-executor {
        core-pool-size-min = 8
        core-pool-size-factor = 2.0
        core-pool-size-max = 32
    }

    throughput = 1
}

akka-http-cors {

  # If enabled, allow generic requests (that are outside the scope of the specification)
  # to pass through the directive. Else, strict CORS filtering is applied and any
  # invalid request will be rejected.
  allow-generic-http-requests = yes

  # Indicates whether the resource supports user credentials.  If enabled, the header
  # `Access-Control-Allow-Credentials` is set in the response, indicating that the
  # actual request can include user credentials. Examples of user credentials are:
  # cookies, HTTP authentication or client-side certificates.
  allow-credentials = yes

  # List of origins that the CORS filter must allow. Can also be set to `*` to allow
  # access to the resource from any origin. Controls the content of the
  # `Access-Control-Allow-Origin` response header: if parameter is `*` and credentials
  # are not allowed, a `*` is set in `Access-Control-Allow-Origin`. Otherwise, the
  # origins given in the `Origin` request header are echoed.
  #
  # Hostname starting with `*.` will match any sub-domain.
  # The scheme and the port are always strictly matched.
  #
  # The actual or preflight request is rejected if any of the origins from the request
  # is not allowed.
  allowed-origins = "*"

  # List of request headers that can be used when making an actual request. Controls
  # the content of the `Access-Control-Allow-Headers` header in a preflight response:
  # if parameter is `*`, the headers from `Access-Control-Request-Headers` are echoed.
  # Otherwise the parameter list is returned as part of the header.
  allowed-headers = "*"

  # List of methods that can be used when making an actual request. The list is
  # returned as part of the `Access-Control-Allow-Methods` preflight response header.
  #
  # The preflight request will be rejected if the `Access-Control-Request-Method`
  # header's method is not part of the list.
  allowed-methods = ["GET", "PUT", "POST", "DELETE", "HEAD", "OPTIONS"]

  # List of headers (other than simple response headers) that browsers are allowed to access.
  # If not empty, this list is returned as part of the `Access-Control-Expose-Headers`
  # header in the actual response.
  exposed-headers = ["Server"]

  # When set, the amount of seconds the browser is allowed to cache the results of a preflight request.
  # This value is returned as part of the `Access-Control-Max-Age` preflight response header.
  # If `null`, the header is not added to the preflight response.
  max-age = 1800 seconds
}

app {
    print-extended-config = false // If true, an extended list of configuration parameters will be printed out at startup.
    print-extended-config = ${?KNORA_WEBAPI_PRINT_EXTENDED_CONFIG}

    // default ask timeout. can be same or lower then akka.http.server.request-timeout.
    default-timeout = 30 minutes

    // If true, log all messages sent from and received by routes. Since messages are logged at DEBUG level, you will
    // need to set loglevel = "DEBUG" in the akka section of this file, and <root level="DEBUG"> in logback.xml.
    dump-messages = false

    show-internal-errors = true // If true, clients will see error messages from internal errors. Useful for debugging. If false, those error messages will appear only in the log.

    skip-authentication = false // If true, the authentication process is skiped and the Lothar Schmidt user is returned by default.

    bcrypt-password-strength = 12 // Value range is 10-32.
    bcrypt-password-strength = ${?KNORA_WEBAPI_BCRYPT_PASSWORD_STRENGTH}

    // the JSON Web Token secret which should be changed.
    jwt-secret-key = "UP 4888, nice 4-8-4 steam engine"
    jwt-secret-key = ${?KNORA_WEBAPI_JWT_SECRET_KEY}

    // the JSON Web Token longevity
    jwt-longevity = 30 days
    jwt-longevity = ${?KNORA_WEBAPI_JWT_LONGEVITY}

    // this domain will be set in the session cookie. needs to be set to the parent domain
    // under which webapi and sipi will run, i.e. example.com if 'api.example.com' and 'iiif.example.com'
    // are used for webapi and sipi.
    cookie-domain = "0.0.0.0"
    cookie-domain = ${?KNORA_WEBAPI_COOKIE_DOMAIN}

    // DANGER: If true, will accept messages to the /admin/store route, which allows to restore the contend of the triplestore
    allow-reload-over-http = false
    allow-reload-over-http = ${?KNORA_WEBAPI_ALLOW_RELOAD_OVER_HTTP}

    // Configuration for updating the repository when Knora is upgraded
    upgrade {
        // The directory to which the repository should be downloaded. If not configured, a temporary directory is used.
        // download-dir = "/tmp/knora-upgrade"
    }

    knora-api {
        // relevant for direct communication inside the knora stack
        internal-host = "0.0.0.0"
        internal-host = ${?KNORA_WEBAPI_KNORA_API_INTERNAL_HOST}
        internal-port = 3333
        internal-port = ${?KNORA_WEBAPI_KNORA_API_INTERNAL_PORT}

        // relevant for the client, i.e. browser
        external-protocol = "http" // optional ssl termination needs to be done by the proxy
        external-protocol = ${?KNORA_WEBAPI_KNORA_API_EXTERNAL_PROTOCOL}
        external-host = "0.0.0.0"
        external-host = ${?KNORA_WEBAPI_KNORA_API_EXTERNAL_HOST}
        external-port = 3333
        external-port = ${?KNORA_WEBAPI_KNORA_API_EXTERNAL_PORT}
    }

    sipi {
        // relevant for direct communication inside the knora stack
        internal-protocol = "http"
        internal-protocol = ${?KNORA_WEBAPI_SIPI_INTERNAL_PROTOCOL}
        internal-host = "0.0.0.0"
        internal-host = ${?KNORA_WEBAPI_SIPI_INTERNAL_HOST}
        internal-port = 1024
        internal-port = ${?KNORA_WEBAPI_SIPI_INTERNAL_PORT}

        timeout = 120 seconds

        // relevant for the client, i.e. browser
        external-protocol = "http"
        external-protocol = ${?KNORA_WEBAPI_SIPI_EXTERNAL_PROTOCOL}
        external-host = "0.0.0.0"
        external-host = ${?KNORA_WEBAPI_SIPI_EXTERNAL_HOST}
        external-port = 1024
        external-port = ${?KNORA_WEBAPI_SIPI_EXTERNAL_PORT}

        file-server-path = "server"

        v1 {
            path-conversion-route = "convert_from_path"
            file-conversion-route = "convert_from_file"
        }

        v2 {
            file-metadata-route = "knora.json"
            move-file-route = "store"
            delete-temp-file-route = "delete_temp_file"
        }

        image-mime-types = ["image/tiff", "image/jpeg", "image/png", "image/jp2", "image/jpx"]
        document-mime-types = ["application/pdf"]
        text-mime-types = ["application/xml", "text/xml", "text/csv"]
        movie-mime-types = []
        sound-mime-types = []
    }

    ark {
        resolver = "http://0.0.0.0:3336"
        resolver = ${?KNORA_WEBAPI_ARK_RESOLVER_URL}
        assigned-number = 72163
        assigned-number = ${?KNORA_WEBAPI_ARK_NAAN}
    }

    salsah1 {
        base-url = "http://0.0.0.0:3335/"
        base-url = ${?KNORA_WEBAPI_SALSAH1_BASE_URL}
        project-icons-basepath = "project-icons/"
    }

    // http://www.ehcache.org/apidocs/2.10/index.html
    caches = [
        {
            cache-name = "ontologyCache"
            max-elements-in-memory = 0
            overflow-to-disk = false
            eternal = true
            time-to-live-seconds = 0
            time-to-idle-seconds = 0
        },
        {
            cache-name = "userProfileCache"
            max-elements-in-memory = 0
            overflow-to-disk = false
            eternal = true
            time-to-live-seconds = 600
            time-to-idle-seconds = 0
        },
        {
            cache-name = "userADMCache"
            max-elements-in-memory = 0
            overflow-to-disk = false
            eternal = true
            time-to-live-seconds = 600
            time-to-idle-seconds = 0
        },
        {
            cache-name = "permissionsCache"
            max-elements-in-memory = 0
            overflow-to-disk = false
            eternal = true
            time-to-live-seconds = 0
            time-to-idle-seconds = 0
        },
        {
            cache-name = "authenticationInvalidationCache"
            max-elements-in-memory = 0
            overflow-to-disk = false
            eternal = true
            time-to-live-seconds = 2592000
            time-to-idle-seconds = 0
        },
        {
            cache-name = "mappingCache"
            max-elements-in-memory = 0
            overflow-to-disk = false
            eternal = true
            time-to-live-seconds = 600
            time-to-idle-seconds = 0
        },
        {
            cache-name = "xsltCache"
            max-elements-in-memory = 100
            overflow-to-disk = false
            eternal = true
            time-to-live-seconds = 600
            time-to-idle-seconds = 0
        }

    ]

    tmp-datadir = "/tmp/webapi_tmp/" // dir must exist on disk!
    datadir = "/tmp/webapi/" // dir must exist on disk!

    max-results-per-search-result-page = 500

    standoff-per-page = 100 // the number of standoff tags to be returned per page

    v2 {
        resources-sequence {
            results-per-page = 25 // results to be returned per page
        },
        fulltext-search {
            search-value-min-length = 3
        },
        graph-route {
            default-graph-depth = 4
            max-graph-depth = 10
            max-graph-breadth = 50
        }
    }

    gui {
        // The default size of resource type icons. TODO: put icon sizes in the triplestore instead.
        default-icon-size {
            dimX = 32
            dimY = 32
        }
    }

    # Array containing route paths which should be rejected. This can be used to selectively disable routes
    # in the configuration.
    routes-to-reject = [
        "v1/test",
        "v2/test"
    ]

    triplestore {
        dbtype = "fuseki"
        dbtype = ${?KNORA_WEBAPI_TRIPLESTORE_DBTYPE}
        // dbtype = "graphdb-se"
        // dbtype = "graphdb-free"
        // dbtype = "embedded-jena-tdb"
        // dbtype = "embedded-jena-graphdb"
        // dbtype = "fake-triplestore"

        use-https = false
        use-https = ${?KNORA_WEBAPI_TRIPLESTORE_USE_HTTPS}

        host = "localhost"
        host = ${?KNORA_WEBAPI_TRIPLESTORE_HOST}

        // timeout for triplestore queries. can be same or lower then akka.http.server.request-timeout.
        query-timeout = 10 seconds

        // timeout for tripelstore updates. can be same or lower then akka.http.server.request-timeout.
        update-timeout = 30 minutes

        // triplestore auto init. initialize triplestore at startup if necessary.
        auto-init = false
        auto-init = ${?KNORA_WEBAPI_TRIPLESTORE_AUTOINIT}

        graphdb {
            port = 7200
            port = ${?KNORA_WEBAPI_TRIPLESTORE_GRAPHDB_PORT}
            repository-name = "knora-test"
            repository-name = ${?KNORA_WEBAPI_TRIPLESTORE_GRAPHDB_REPOSITORY_NAME}
            username = "admin"
            username = ${?KNORA_WEBAPI_TRIPLESTORE_GRAPHDB_USERNAME}
            password = "root"
            password = ${?KNORA_WEBAPI_TRIPLESTORE_GRAPHDB_PASSWORD}
        }

        fuseki {
            port = 3030
            port = ${?KNORA_WEBAPI_TRIPLESTORE_FUSEKI_PORT}
            repository-name = "knora-test"
            repository-name = ${?KNORA_WEBAPI_TRIPLESTORE_FUSEKI_REPOSITORY_NAME}
            username = "admin"
            username = ${?KNORA_WEBAPI_TRIPLESTORE_FUSEKI_USERNAME}
            password = "test"
            password = ${?KNORA_WEBAPI_TRIPLESTORE_FUSEKI_PASSWORD}
        }

        embedded-jena-tdb {
            persisted = true // "false" -> memory, "true" -> disk
            loadExistingData = false // "false" -> use data if exists, "false" -> create a fresh store
            storage-path = "_TMP" // ignored if "memory"
        }

        embedded-jena-graphdb {
            graphdb-persisted-storage = true
            graphdb-storage-path = "_TMP_GRAPHDB"
        }

        fake-jena-tdb {
            fake-persisted-storage = true
            fake-triplestore-data-dir = "src/main/resources/query-log"
        }

        reload-on-start = false // ignored if "memory" as it will always reload

        # This data is automatically loaded during resetting of the triple store content initiated
        # through the `ResetTriplestoreContent` message. The main usage is in unit testing, where
        # we want a known state of the triple store data. If additional triples need to be loaded,
        # then a list of `RdfDataObject` instances containing the path and the name of the named graph
        # can be supplied to the `ResetTriplestoreContent` message.
        default-rdf-data = [
            {
                path = "knora-ontologies/knora-admin.ttl"
                name = "http://www.knora.org/ontology/knora-admin"
            }
            {
                path = "knora-ontologies/knora-base.ttl"
                name = "http://www.knora.org/ontology/knora-base"
            }
            {
                path = "knora-ontologies/standoff-onto.ttl"
                name = "http://www.knora.org/ontology/standoff"
            }
            {
                path = "knora-ontologies/standoff-data.ttl"
                name = "http://www.knora.org/data/standoff"
            }
            {
                path = "knora-ontologies/salsah-gui.ttl"
                name = "http://www.knora.org/ontology/salsah-gui"
            }
            {
                path = "test_data/all_data/admin-data.ttl"
                name = "http://www.knora.org/data/admin"
            }
            {
                path = "test_data/all_data/permissions-data.ttl"
                name = "http://www.knora.org/data/permissions"
            }
            {
                path = "test_data/all_data/system-data.ttl"
                name = "http://www.knora.org/data/0000/SystemProject"
            }
            {
                path = "test_data/ontologies/anything-onto.ttl"
                name = "http://www.knora.org/ontology/0001/anything"
            }
            {
                path = "test_data/ontologies/something-onto.ttl"
                name = "http://www.knora.org/ontology/0001/something"
            }
            {
                path = "test_data/ontologies/images-onto.ttl"
                name = "http://www.knora.org/ontology/00FF/images"
            }
            {
                path = "test_data/ontologies/beol-onto.ttl"
                name = "http://www.knora.org/ontology/0801/beol"
            }
            {
                path = "test_data/ontologies/biblio-onto.ttl"
                name = "http://www.knora.org/ontology/0801/biblio"
            }
            {
                path = "test_data/ontologies/incunabula-onto.ttl"
                name = "http://www.knora.org/ontology/0803/incunabula"
            }
            {
                path = "test_data/ontologies/dokubib-onto.ttl"
                name = "http://www.knora.org/ontology/0804/dokubib"
            }
            {
                path = "test_data/ontologies/webern-onto.ttl"
                name = "http://www.knora.org/ontology/08AE/webern"
            }
        ]

        # This data is loaded if the `webapi` server is started with the `loadDemoData` flag, which initiates
        # sending of `ResetTriplestoreContent` with a list of `RdfDataObject` instances containing this data.
        # The result will be a triplestore containing `default-rdf-data` and `rdf-data`
        rdf-data = [
            {
                path = "test_data/ontologies/incunabula-onto.ttl"
                name = "http://www.knora.org/ontology/0803/incunabula"
            }
            {
                path = "test_data/demo_data/incunabula-demo-data.ttl"
                name = "http://www.knora.org/data/incunabula"
            }
            {
                path = "test_data/ontologies/images-onto.ttl"
                name = "http://www.knora.org/ontology/00FF/images"
            }
            {
                path = "test_data/demo_data/images-demo-data.ttl"
                name = "http://www.knora.org/data/00FF/images"
            }

        ]

        // If true, the time taken by each SPARQL query is logged at DEBUG level. To see these messages,
        // set loglevel = "DEBUG" above, and
        // <logger name="org.knora.webapi.store.triplestore.http.HttpTriplestoreConnector" level="DEBUG"/>
        // in logback.xml.
        profile-queries = false

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Fake triplestore settings
        //
        // The application can generate a fake triplestore, consisting of SPARQL queries and responses saved in
        // text files (in fake-triplestore-query-dir). This is useful for:
        //
        // * measuring the response time of the application minus the response time of the triplestore.
        //
        // * debugging SPARQL queries, because you can open the generated queries in a text editor and copy and paste
        //   them into something like GraphDB Workbench to experiment with them.
        //
        // * benchmarking triplestores, because you can feed the whole fake triplestore file structure to RDFBench.
        //
        // To generate a fake triplestore, set fake-triplestore to "prepare", start the application, and run one or more
        // API operations. The fake triplestore will contain all the SPARQL queries and responses involved in those
        // operations.
        //
        // To have the application use the fake triplestore, set fake-triplestore to "use", and restart the application.
        // The entire contents of the fake triplestore will be loaded when the application starts, and all SPARQL queries
        // will simply be hashtable lookups in this in-memory data.
        //
        // To just use a real triplestore, set fake-triplestore to "off".
        fake-triplestore = "off"
        fake-triplestore-data-dir = "src/main/resources/query-log"
    }

    cache-service {

        enabled = true
        enabled = ${?KNORA_WEBAPI_CACHE_SERVICE_ENABLED}

        redis {
            host = "localhost"
            host = ${?KNORA_WEBAPI_CACHE_SERVICE_REDIS_HOST}
            port = 6379
            port = ${?KNORA_WEBAPI_CACHE_SERVICE_REDIS_PORT}
        }
    }

    monitoring {
        prometheus-endpoint: false
        prometheus-endpoing: ${?KNORA_WEBAPI_PROMETHEUS_ENDPOINT}
    }
}

user {
    default-language: "en"
}

kamon.prometheus.embedded-server {

    # Hostname and port used by the embedded web server to publish the
    # prometheus scraping enpoint.
    hostname = 0.0.0.0
    hostname = ${?KNORA_WEBAPI_PROMETHEUS_HOST}
    port = 9095
    port = ${?KNORA_WEBAPI_PROMETHEUS_PORT}
}