things.conf

ditto {
  mapping-strategy.implementation = "org.eclipse.ditto.services.models.things.ThingsMappingStrategies"
  cluster-downing.role = "things"

  persistence.operations.delay-after-persistence-actor-shutdown = 5s
  persistence.operations.delay-after-persistence-actor-shutdown = ${?DELAY_AFTER_PERSISTENCE_ACTOR_SHUTDOWN}

  things {
    # Logs for all incoming messages minimal information to enable message tracing throughout the system
    log-incoming-messages = true
    log-incoming-messages = ${?LOG_INCOMING_MESSAGES}

    tags {
      streaming-cache-size = 1000
      streaming-cache-size = ${?TAGS_STREAMING_CACHE_SIZE}
    }

    http {
      # InetAddress.getLocalHost.getHostAddress is used if empty
      hostname = ""
      hostname = ${?HOSTNAME}
      hostname = ${?BIND_HOSTNAME}
      port = 8080
      port = ${?HTTP_PORT}
      port = ${?PORT}
    }

    cluster {
      # as a rule of thumb: should be factor ten of the amount of cluster nodes available
      # be aware that it must be the same as for all other services (e.g. search-updater)
      number-of-shards = 30
      number-of-shards = ${?CLUSTER_NUMBER_OF_SHARDS}
    }

    thing {
      # the interval of how long to keep an "inactive" Thing in memory:
      activity.check.interval = 2h
      activity.check.interval = ${?THING_ACTIVITY_CHECK_INTERVAL} # may be overridden with this environment variable
      # the interval of how long to keep an "inactive" deleted Thing in memory:
      activity.check.deleted.interval = 5m
      activity.check.deleted.interval = ${?THING_ACTIVITY_CHECK_DELETED_INTERVAL}

      snapshot {
        # the interval when to do snapshot for a Thing which had changes to it
        interval = 15m
        interval = ${?THING_SNAPSHOT_INTERVAL} # may be overridden with this environment variable

        # the threshold after how many changes to a Thing to do a snapshot
        threshold = 500
        threshold = ${?THING_SNAPSHOT_THRESHOLD} # may be overridden with this environment variable

        # delete old Snapshot when taking a Snapshot
        delete-old = false
        delete-old = ${?THING_SNAPSHOT_DELETE_OLD} # may be overridden with this environment variable
      }

      events {
        # delete old Events when taking a Snapshot
        delete-old = false
        delete-old = ${?THING_EVENTS_DELETE_OLD} # may be overridden with this environment variable
      }

      supervisor {
        exponential-backoff {
          min = 1s
          max = 10s
          random-factor = 0.2
        }
      }
    }

    health-check {
      enabled = true
      enabled = ${?HEALTH_CHECK_ENABLED} # may be overridden with this environment variable
      interval = 60s

      persistence {
        enabled = true
        enabled = ${?HEALTH_CHECK_PERSISTENCE_ENABLED} # may be overridden with this environment variable
        timeout = 60s
      }
    }

    metrics {
      systemMetrics.enabled = true
      systemMetrics.enabled = ${?SYSTEM_METRICS_ENABLED}

      prometheus {
        enabled = true
        enabled = ${?PROMETHEUS_ENABLED}
        hostname = 0.0.0.0
        hostname = ${?PROMETHEUS_HOSTNAME}
        port = 9095
        port = ${?PROMETHEUS_PORT}
      }
    }
  }
}


akka {
  cluster {
    sharding {
      role = "things"
    }

    roles = [
      "things"
    ]
  }

  persistence {
    journal.auto-start-journals = [
      "akka-contrib-mongodb-persistence-things-journal"
    ]
    snapshot-store.auto-start-snapshot-stores = [
      "akka-contrib-mongodb-persistence-things-snapshots"
    ]
  }
}

akka-contrib-mongodb-persistence-things-journal {
  class = "akka.contrib.persistence.mongodb.MongoJournal"
  plugin-dispatcher = "thing-journal-persistence-dispatcher"

  circuit-breaker {
    max-failures = 5 # if an exception during persisting an event/snapshot occurs this often -- a successful write resets the counter
    max-failures = ${?BREAKER_MAXTRIES}
    call-timeout = 5s # MongoDB Timeouts causing the circuitBreaker to open
    call-timeout = ${?BREAKER_TIMEOUT}
    reset-timeout = 3s # after this time in "Open" state, the cicuitBreaker is "Half-opened" again
    reset-timeout = ${?BREAKER_RESET}
  }

  overrides {
    journal-collection = "things_journal"
    journal-index = "things_journal_index"

    realtime-collection = "things_realtime"
    metadata-collection = "things_metadata"
  }

  event-adapters {
    mongodbobject = "org.eclipse.ditto.services.things.persistence.serializer.ThingMongoEventAdapter"
  }

  event-adapter-bindings {
    "org.eclipse.ditto.signals.events.things.ThingEvent" = mongodbobject
    "org.bson.BsonValue" = mongodbobject
  }
}

akka-contrib-mongodb-persistence-things-snapshots {
  class = "akka.contrib.persistence.mongodb.MongoSnapshots"
  plugin-dispatcher = "thing-snaps-persistence-dispatcher"

  circuit-breaker {
    max-failures = 5 # if an exception during persisting an event/snapshot occurs this often -- a successful write resets the counter
    max-failures = ${?SNAPSHOT_BREAKER_MAXTRIES}
    call-timeout = 10s # MongoDB Timeouts causing the circuitBreaker to open
    call-timeout = ${?SNAPSHOT_BREAKER_TIMEOUT}
    reset-timeout = 6s # after this time in "Open" state, the cicuitBreaker is "Half-opened" again
    reset-timeout = ${?SNAPSHOT_BREAKER_RESET}
  }

  overrides {
    snaps-collection = "things_snaps"
    snaps-index = "things_snaps_index"
  }
}

thing-journal-persistence-dispatcher {
  type = Dispatcher
  # which mailbox to use
  mailbox-type = "org.eclipse.ditto.services.things.persistence.actors.ThingPersistenceActorMailbox"
  mailbox-capacity = 100
  executor = "fork-join-executor"
  fork-join-executor {
    parallelism-min = 4
    parallelism-factor = 3.0
    parallelism-max = 32
    parallelism-max = ${?DEFAULT_DISPATCHER_PARALLELISM_MAX}
  }
  throughput = 5
}

thing-snaps-persistence-dispatcher {
  type = Dispatcher
  # which mailbox to use
  mailbox-type = "org.eclipse.ditto.services.things.persistence.actors.ThingPersistenceActorMailbox"
  mailbox-capacity = 100
  executor = "fork-join-executor"
  fork-join-executor {
    parallelism-min = 4
    parallelism-factor = 3.0
    parallelism-max = 32
    parallelism-max = ${?DEFAULT_DISPATCHER_PARALLELISM_MAX}
  }
  throughput = 5
}

akka.contrib.persistence.mongodb.mongo {

  suffix-builder {
    separator = "@"
    separator = ${?MONGO_COLLECTION_NAME_SUFFIX_SEPARATOR}
    class = "org.eclipse.ditto.services.utils.persistence.mongo.suffixes.NamespaceSuffixCollectionNames"
    class = ${?MONGO_COLLECTION_NAME_SUFFIX_CLASS}
    supported-prefixes = ["thing"]
  }

  collection-cache {
    journal {
      class = "org.eclipse.ditto.services.utils.persistence.mongo.DittoMongoCollectionCache"
      expire-after-write = 1h // check each collection every hour whether it was created correctly
      expire-after-write = ${?MONGO_COLLECTION_CACHE_JOURNAL_TTL}
      max-size = 1000 // namespace collections cached per node
      max-size = ${?MONGO_COLLECTION_CACHE_JOURNAL_MAX_SIZE}
    }

    snaps {
      class = "org.eclipse.ditto.services.utils.persistence.mongo.DittoMongoCollectionCache"
      expire-after-write = 1h
      expire-after-write = ${?MONGO_COLLECTION_CACHE_SNAPS_TTL}
      max-size = 1000
      max-size = ${?MONGO_COLLECTION_CACHE_SNAPS_MAX_SIZE}
    }
  }
}