FinatraDslWindowedAggregations

abstract def configureKafkaStreams(builder: StreamsBuilder): Unit

Callback method which is executed after the injector is created and before any other lifecycle methods.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final val MinGrace: Duration

def addAdminRoute(route: Route): Unit

def addAdminRoutes(newRoutes: Seq[Route]): Unit

def addDtabs(): Unit

def addFrameworkModule(module: Module): Unit

def addFrameworkModules(modules: Module*): Unit

def addFrameworkOverrideModules(modules: Module*): Unit

def adminBoundAddress: InetSocketAddress

var adminHttpServer: ListeningServer

val adminPort: Flag[InetSocketAddress]

def afterPostWarmup(): Unit

def allowUndefinedFlags: Boolean

val allowedLateness: Flag[Duration]

val appendFlag: Flag[Boolean]

val applicationId: Flag[String]

val applicationServerConfig: Flag[String]

def args: Array[String]

final def asInstanceOf[T0]: T0

val asyncFlag: Flag[Boolean]

val asyncMaxSizeFlag: Flag[Int]

val autoWatermarkIntervalFlag: Flag[Duration]

def await(awaitables: Awaitable[_]*): Unit

def await[T <: Awaitable[_]](awaitable: T): Unit

def beforePostWarmup(): Unit

val bootstrapServer: Flag[String]

def clone(): AnyRef

final def close(deadline: Time): Future[Unit]

def close(after: Duration): Future[Unit]

final def close(): Future[Unit]

def closeAwaitably(f: ⇒ Future[Unit]): Future[Unit]

final def closeOnExit(closable: Closable): Unit

final def closeOnExitLast(closable: Closable): Unit

val commitInterval: Flag[Duration]

def configureAdminHttpServer(server: Server): Server

def configureLoggerFactories(): Unit

def consumerFlagWithKafkaDefault[T](key: String)(implicit arg0: Flaggable[T]): Flag[T]

Create a flag prefixed by "kafka.consumer." with a default value and help string that is populated from the Kafka ConsumerConfig class

def createAndStartKafkaStreams(): Unit

def createKafkaStreamsProperties(): Properties

def createKafkaStreamsTopology(): Topology

def debug(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def debug(message: ⇒ Any, cause: Throwable): Unit

def debug(marker: Marker, message: ⇒ Any): Unit

def debug(message: ⇒ Any): Unit

def debugFutureResult[T](msg: String)(func: ⇒ Future[T]): Future[T]

def debugResult[T](message: ⇒ String)(fn: ⇒ T): T

def defaultAdminPort: Int

def defaultAppend: Boolean

val defaultCloseGracePeriod: Duration

def defaultFormatter: Formatter

def defaultLogLevel: Level

def defaultOutput: String

def defaultRollPolicy: Policy

def defaultRotateCount: Int

def disableAdminHttpServer: Boolean

val dtabAddBaseFlag: Flag[Dtab]

val emitOnClose: Flag[Boolean]

val emitUpdatedEntriesOnCommit: Flag[Boolean]

val emitWatermarkPerMessageFlag: Flag[Boolean]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def error(message: ⇒ Any, cause: Throwable): Unit

def error(marker: Marker, message: ⇒ Any): Unit

def error(message: ⇒ Any): Unit

def errorResult[T](message: ⇒ String)(fn: ⇒ T): T

def exitOnError(reason: String, details: ⇒ String): Unit

def exitOnError(reason: String): Unit

def exitOnError(throwable: Throwable): Unit

def failfastOnFlagsNotParsed: Boolean

def finalize(): Unit

val flag: Flags

def flagWithKafkaDefault[T](key: String)(implicit arg0: Flaggable[T]): Flag[T]

Create a flag prefixed by "kafka." with a default value and help string that is populated from the Kafka Streams StreamsConfig class

final def getClass(): Class[_]

val group: String

def handle(clazz: Class[_ <: Handler]): Unit

def handle[T <: Handler]()(implicit arg0: Manifest[T]): Unit

def handlers: List[() ⇒ Handler]

def hashCode(): Int

def httpExternalPort: Option[Int]

def httpsExternalPort: Option[Int]

val inferClassNamesFlag: Flag[Boolean]

def info(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def info(message: ⇒ Any, cause: Throwable): Unit

def info(marker: Marker, message: ⇒ Any): Unit

def info(message: ⇒ Any): Unit

def infoResult[T](message: ⇒ String)(fn: ⇒ T): T

final def init(f: ⇒ Unit): Unit

def injector: Injector

def isDebugEnabled(marker: Marker): Boolean

def isDebugEnabled: Boolean

def isErrorEnabled(marker: Marker): Boolean

def isErrorEnabled: Boolean

def isInfoEnabled(marker: Marker): Boolean

def isInfoEnabled: Boolean

final def isInstanceOf[T0]: Boolean

def isReady(implicit permit: CanAwait): Boolean

def isTraceEnabled(marker: Marker): Boolean

def isTraceEnabled: Boolean

def isWarnEnabled(marker: Marker): Boolean

def isWarnEnabled: Boolean

def javaModules: Collection[Module]

def javaOverrideModules: Collection[Module]

def kafkaFlag[T](key: String, default: ⇒ T)(implicit arg0: Flaggable[T]): Flag[T]

Create a flag prefixed by "kafka." with the specified default value and a help string that is populated from the Kafka Streams StreamsConfig class

var kafkaStreams: KafkaStreams

val kafkaStreamsBuilder: StreamsBuilder

def kafkaStreamsClientSupplier: KafkaClientSupplier

val levelFlag: Flag[Level]

def libraryName: String

def linterRules: Seq[Rule]

def loadModules(): InstalledModules

def loadServiceBindings: Seq[Binding[_]]

final def logger: Logger

def loggerFactories: List[LoggerFactory]

final def loggerName: String

final def main(): Unit

final def main(args: Array[String]): Unit

def modules: Seq[Module]

val name: String

final def ne(arg0: AnyRef): Boolean

final def nonExitingMain(args: Array[String]): Unit

final def notify(): Unit

final def notifyAll(): Unit

final def onExit(f: ⇒ Unit): Unit

def onStateChange(newState: State, oldState: State): Unit

val outputFlag: Flag[String]

def overrideModules: Seq[Module]

def parseArgs(args: Array[String]): Unit

def postInjectorStartup(): Unit

def postWarmup(): Unit

final def postmain(f: ⇒ Unit): Unit

def prebindWarmup(): Unit

final def premain(f: ⇒ Unit): Unit

def producerFlagWithKafkaDefault[T](key: String)(implicit arg0: Flaggable[T]): Flag[T]

Create a flag prefixed by "kafka.producer." with a default value and help string that is populated from the Kafka ProducerConfig class

var properties: Properties

val queryableAfterClose: Flag[Duration]

def ready(timeout: Duration)(implicit permit: CanAwait): FinatraDslWindowedAggregations.this.type

def requiredKafkaFlag[T](key: String, helpPrefix: String = "")(implicit arg0: Flaggable[T], arg1: Manifest[T]): Flag[T]

Create a required flag prefixed by "kafka." with a help string this is populated from the Kafka Streams StreamsConfig class

def resolveFinagleClientsOnStartup: Boolean

def result(timeout: Duration)(implicit permit: CanAwait): Unit

val rollPolicyFlag: Flag[Policy]

val rotateCountFlag: Flag[Int]

def routes: Seq[Route]

final def run(): Unit

def setExceptionHandler(streams: KafkaStreams): Unit

def setup(): Unit

lazy val shutdownTimer: Timer

def start(): Unit

def statsReceiver: StatsReceiver

def statsReceiverModule: Module

def streamsProperties(config: KafkaStreamsConfig): KafkaStreamsConfig

Callback method which is executed after the injector is created and before KafkaStreams is configured.

override def streamsProperties(config: KafkaStreamsConfig): KafkaStreamsConfig = {
  super
    .streamsProperties(config)
    .retries(60)
    .retryBackoff(1.second)
    .consumer.sessionTimeout(10.seconds)
    .consumer.heartbeatInterval(1.second)
    .producer.retries(300)
    .producer.retryBackoff(1.second)
    .producer.requestTimeout(2.minutes)
    .producer.transactionTimeout(2.minutes)
    .producer.batchSize(500.kilobytes)
}

def streamsStatsReceiver: StatsReceiver

final val suppressGracefulShutdownErrors: Boolean

final def synchronized[T0](arg0: ⇒ T0): T0

def thriftPort: Option[Int]

def time[T](formatStr: String)(func: ⇒ T): T

def toString(): String

var topology: Topology

def trace(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def trace(message: ⇒ Any, cause: Throwable): Unit

def trace(marker: Marker, message: ⇒ Any): Unit

def trace(message: ⇒ Any): Unit

def traceResult[T](message: ⇒ String)(fn: ⇒ T): T

implicit def transformerFunctionToSupplier[K, V, K1, V1](transformerFactory: () ⇒ Transformer[K, V, (K1, V1)]): TransformerSupplier[K, V, KeyValue[K1, V1]]

def uncaughtException: Throwable

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def warmup(): Unit

def warmupComplete(): Unit

def warn(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def warn(message: ⇒ Any, cause: Throwable): Unit

def warn(marker: Marker, message: ⇒ Any): Unit

def warn(message: ⇒ Any): Unit

def warnResult[T](message: ⇒ String)(fn: ⇒ T): T

val windowSize: Flag[Duration]

lazy val log: Logger