diff --git a/kotlin/BUILD b/kotlin/BUILD
index b69cba7..e7ab37c 100644
--- a/kotlin/BUILD
+++ b/kotlin/BUILD
@@ -17,10 +17,26 @@
 load("//kotlin/internal:bootstrap.bzl", "kt_toolchain_ide_info")
 
 config_setting(
-    name = "builder_debug_setting",
-    values = {
-        "define": "kt_debug=1"
-    }
+    name = "builder_debug_timings",
+    values = { "define": "kt_timings=1" }
+)
+
+config_setting(
+    name = "builder_debug_trace",
+    values = { "define": "kt_trace=1" }
+)
+
+define_kt_toolchain(
+    name = "default_toolchain",
+    debug=
+        select({
+            "//kotlin:builder_debug_trace": ["trace"],
+            "//conditions:default": []
+        }) +
+        select({
+            "//kotlin:builder_debug_timings": ["timings"],
+            "//conditions:default": []
+        })
 )
 
 toolchain_type(
@@ -28,14 +44,6 @@
     visibility = ["//visibility:public"]
 )
 
-define_kt_toolchain(
-    name = "default_toolchain",
-    debug=select({
-        "//kotlin:builder_debug_setting": 1,
-        "//conditions:default": 0
-    })
-)
-
 kt_toolchain_ide_info(name="kt_toolchain_ide_info")
 
 exports_files(["toolchains.bzl", "kotlin.bzl"], visibility=["//docs:__subpackages__"])
diff --git a/kotlin/builder/proto/jars/libkotlin_model_proto-speed.jar b/kotlin/builder/proto/jars/libkotlin_model_proto-speed.jar
index 1411450..3e72540 100755
--- a/kotlin/builder/proto/jars/libkotlin_model_proto-speed.jar
+++ b/kotlin/builder/proto/jars/libkotlin_model_proto-speed.jar
Binary files differ
diff --git a/kotlin/builder/proto/kotlin_model.proto b/kotlin/builder/proto/kotlin_model.proto
index 5344fed..8814ef6 100644
--- a/kotlin/builder/proto/kotlin_model.proto
+++ b/kotlin/builder/proto/kotlin_model.proto
@@ -96,8 +96,10 @@
     repeated string friend_paths = 8;
     // The path of the primary output for the task, this is derived from the flagfile.
     string primary_output_path = 9;
-    // If this is true the builder will print out debug messages.
-    int32 debug = 10;
+    // Strings to enable various debugging behaviours
+    // trace: enables trace logging.
+    // timings: causes timing information to be printed at the of an action.
+    repeated string debug = 10;
 }
 
 // Mested messages not marked with stable could be refactored.
diff --git a/kotlin/builder/src/io/bazel/kotlin/builder/tasks/KotlinBuilder.kt b/kotlin/builder/src/io/bazel/kotlin/builder/tasks/KotlinBuilder.kt
index 8c6c973..c834790 100644
--- a/kotlin/builder/src/io/bazel/kotlin/builder/tasks/KotlinBuilder.kt
+++ b/kotlin/builder/src/io/bazel/kotlin/builder/tasks/KotlinBuilder.kt
@@ -49,16 +49,24 @@
 
     override fun apply(args: List<String>): Int {
         val (argMap, context) = buildContext(args)
+        var success = false
+        var status = 0
         try {
             @Suppress("WHEN_ENUM_CAN_BE_NULL_IN_JAVA")
             when (context.info.platform) {
                 Platform.JVM -> executeJvmTask(context, argMap)
                 Platform.UNRECOGNIZED, Platform.JS -> throw IllegalStateException("unrecognized platform: ${context.info}")
             }
+            success = true
         } catch (ex: CompilationStatusException) {
-            return ex.status
+            status = ex.status
+        } catch(throwable: Throwable) {
+            context.reportUnhandledException(throwable)
+            throw throwable
+        } finally {
+            context.finalize(success)
         }
-        return 0
+        return status
     }
 
     private fun buildContext(args: List<String>): Pair<ArgMap, CompilationTaskContext> {
@@ -129,7 +137,8 @@
 
     private fun buildTaskInfo(argMap: ArgMap): CompilationTaskInfo.Builder =
         with(CompilationTaskInfo.newBuilder()) {
-            debug = argMap.mandatorySingle(KotlinBuilderFlags.DEBUG).toInt()
+            addAllDebug(argMap.mandatory(KotlinBuilderFlags.DEBUG))
+
             label = argMap.mandatorySingle(JavaBuilderFlags.TARGET_LABEL)
             argMap.mandatorySingle(JavaBuilderFlags.RULE_KIND).split("_").also {
                 check(it.size == 3 && it[0] == "kt") { "invalid rule kind $it" }
@@ -152,7 +161,9 @@
 
     private fun executeJvmTask(context: CompilationTaskContext, argMap: ArgMap) {
         val task = buildJvmTask(context.info, argMap)
-        context.debugPrintProto("jvm task message", task)
+        context.whenTracing {
+            printProto("jvm task message", task)
+        }
         jvmTaskExecutor.execute(context, task)
     }
 
@@ -178,7 +189,7 @@
                 putAllIndirectDependencies(argMap.labelDepMap(JavaBuilderFlags.DIRECT_DEPENDENCY))
                 putAllIndirectDependencies(argMap.labelDepMap(JavaBuilderFlags.INDIRECT_DEPENDENCY))
 
-                argMap.optional(JavaBuilderFlags.SOURCES)?.iterator()?.partitionSources(
+                argMap.optional(JavaBuilderFlags.SOURCES)?.iterator()?.partitionJvmSources(
                     { addKotlinSources(it) },
                     { addJavaSources(it) }
                 )
diff --git a/kotlin/builder/src/io/bazel/kotlin/builder/tasks/jvm/KotlinJvmTaskExecutor.kt b/kotlin/builder/src/io/bazel/kotlin/builder/tasks/jvm/KotlinJvmTaskExecutor.kt
index caa3372..bac2bcd 100644
--- a/kotlin/builder/src/io/bazel/kotlin/builder/tasks/jvm/KotlinJvmTaskExecutor.kt
+++ b/kotlin/builder/src/io/bazel/kotlin/builder/tasks/jvm/KotlinJvmTaskExecutor.kt
@@ -15,12 +15,9 @@
  */
 package io.bazel.kotlin.builder.tasks.jvm
 
-
 import io.bazel.kotlin.builder.toolchain.CompilationStatusException
-import io.bazel.kotlin.builder.utils.CompilationTaskContext
-import io.bazel.kotlin.builder.utils.IS_JVM_SOURCE_FILE
-import io.bazel.kotlin.builder.utils.ensureDirectories
-import io.bazel.kotlin.builder.utils.expandWithSources
+import io.bazel.kotlin.builder.utils.*
+import io.bazel.kotlin.builder.utils.jars.JarCreator
 import io.bazel.kotlin.builder.utils.jars.SourceJarCreator
 import io.bazel.kotlin.builder.utils.jars.SourceJarExtractor
 import io.bazel.kotlin.model.JvmCompilationTask
@@ -34,74 +31,50 @@
 class KotlinJvmTaskExecutor @Inject internal constructor(
     private val kotlinCompiler: KotlinJvmCompiler,
     private val javaCompiler: JavaCompiler,
-    private val jDepsGenerator: JDepsGenerator,
-    private val outputJarCreator: OutputJarCreator
+    private val jDepsGenerator: JDepsGenerator
 ) {
     fun execute(context: CompilationTaskContext, task: JvmCompilationTask) {
-        val preprocessedTask = preprocessingSteps(task)
-        // fix error handling
+        // TODO fix error handling
         try {
-            val commandWithApSources = context.execute("kapt") {
-                runAnnotationProcessors(context, preprocessedTask)
-            }
-            compileClasses(context, commandWithApSources)
-            context.execute("create jar") {
-                outputJarCreator.createOutputJar(commandWithApSources)
-            }
-            produceSourceJar(commandWithApSources)
-            context.execute("generate jdeps") {
-                jDepsGenerator.generateJDeps(commandWithApSources)
-            }
+            val preprocessedTask = task.preprocessingSteps(context)
+            context.execute("compile classes") { preprocessedTask.compileClasses(context) }
+            context.execute("create jar") { preprocessedTask.createOutputJar() }
+            context.execute("produce src jar") { preprocessedTask.produceSourceJar() }
+            context.execute("generate jdeps") { preprocessedTask.generateJDeps() }
         } catch (ex: Throwable) {
             throw RuntimeException(ex)
         }
     }
 
-
-    private fun preprocessingSteps(command: JvmCompilationTask): JvmCompilationTask {
+    private fun JvmCompilationTask.preprocessingSteps(context: CompilationTaskContext): JvmCompilationTask {
         ensureDirectories(
-            command.directories.classes,
-            command.directories.temp,
-            command.directories.generatedSources,
-            command.directories.generatedClasses
+            directories.temp,
+            directories.generatedSources,
+            directories.generatedClasses
         )
-        return expandWithSourceJarSources(command)
+        val taskWithAdditionalSources = context.execute("expand sources") { expandWithSourceJarSources() }
+        return context.execute("kapt") { taskWithAdditionalSources.runAnnotationProcessors(context) }
     }
 
-    /**
-     * If any srcjars were provided expand the jars sources and create a new [JvmCompilationTask] with the
-     * Java and Kotlin sources merged in.
-     */
-    private fun expandWithSourceJarSources(command: JvmCompilationTask): JvmCompilationTask =
-        if (command.inputs.sourceJarsList.isEmpty()) {
-            command
-        } else {
-            SourceJarExtractor(
-                destDir = Paths.get(command.directories.temp).resolve("_srcjars"),
-                fileMatcher = IS_JVM_SOURCE_FILE
-            ).also {
-                it.jarFiles.addAll(command.inputs.sourceJarsList.map { p -> Paths.get(p) })
-                it.execute()
-            }.let {
-                command.expandWithSources(it.sourcesList.iterator())
-            }
-        }
+    private fun JvmCompilationTask.generateJDeps() {
+        jDepsGenerator.generateJDeps(this)
+    }
 
-    private fun produceSourceJar(command: JvmCompilationTask) {
-        Paths.get(command.outputs.srcjar).also { sourceJarPath ->
+    private fun JvmCompilationTask.produceSourceJar() {
+        Paths.get(outputs.srcjar).also { sourceJarPath ->
             Files.createFile(sourceJarPath)
             SourceJarCreator(
                 sourceJarPath
             ).also { creator ->
                 // This check asserts that source jars were unpacked if present.
                 check(
-                    command.inputs.sourceJarsList.isEmpty() ||
-                            Files.exists(Paths.get(command.directories.temp).resolve("_srcjars"))
+                    inputs.sourceJarsList.isEmpty() ||
+                            Files.exists(Paths.get(directories.temp).resolve("_srcjars"))
                 )
                 listOf(
                     // Any (input) source jars should already have been expanded so do not add them here.
-                    command.inputs.javaSourcesList.stream(),
-                    command.inputs.kotlinSourcesList.stream()
+                    inputs.javaSourcesList.stream(),
+                    inputs.kotlinSourcesList.stream()
                 ).stream()
                     .flatMap { it.map { p -> Paths.get(p) } }
                     .also { creator.addSources(it) }
@@ -110,35 +83,46 @@
         }
     }
 
-    private fun runAnnotationProcessors(
-        context: CompilationTaskContext,
-        command: JvmCompilationTask
+    private fun JvmCompilationTask.runAnnotationProcessors(
+        context: CompilationTaskContext
     ): JvmCompilationTask =
         try {
-            if (command.info.plugins.annotationProcessorsList.isNotEmpty()) {
-                kotlinCompiler.runAnnotationProcessor(context, command)
-                File(command.directories.generatedSources).walkTopDown()
-                    .filter { it.isFile }
-                    .map { it.path }
-                    .iterator()
-                    .let { command.expandWithSources(it) }
+            if (info.plugins.annotationProcessorsList.isEmpty()) {
+                this
             } else {
-                command
+                val kaptOutput = kotlinCompiler.runAnnotationProcessor(context, this)
+                context.whenTracing { printLines("kapt output", kaptOutput) }
+                expandWithGeneratedSources()
             }
         } catch (ex: CompilationStatusException) {
             ex.lines.also(context::printCompilerOutput)
             throw ex
         }
 
-    private fun compileClasses(
-        context: CompilationTaskContext,
-        command: JvmCompilationTask
-    ) {
+    /**
+     * Produce the primary output jar.
+     */
+    private fun JvmCompilationTask.createOutputJar() =
+        JarCreator(
+            path = Paths.get(outputs.jar),
+            normalize = true,
+            verbose = false
+        ).also {
+            it.addDirectory(Paths.get(directories.classes))
+            it.addDirectory(Paths.get(directories.generatedClasses))
+            it.setJarOwner(info.label, info.bazelRuleKind)
+            it.execute()
+        }
+
+    private fun JvmCompilationTask.compileClasses(context: CompilationTaskContext) {
+        ensureDirectories(
+            directories.classes
+        )
         var kotlinError: CompilationStatusException? = null
         var result: List<String>? = null
         context.execute("kotlinc") {
             result = try {
-                kotlinCompiler.compile(command)
+                kotlinCompiler.compile(this)
             } catch (ex: CompilationStatusException) {
                 kotlinError = ex
                 ex.lines
@@ -146,11 +130,57 @@
         }
         try {
             context.execute("javac") {
-                javaCompiler.compile(command)
+                javaCompiler.compile(this)
             }
         } finally {
             checkNotNull(result).also(context::printCompilerOutput)
             kotlinError?.also { throw it }
         }
     }
+
+    /**
+     * If any srcjars were provided expand the jars sources and create a new [JvmCompilationTask] with the
+     * Java and Kotlin sources merged in.
+     */
+    private fun JvmCompilationTask.expandWithSourceJarSources(): JvmCompilationTask =
+        if (inputs.sourceJarsList.isEmpty())
+            this
+        else expandWithSources(
+            SourceJarExtractor(
+                destDir = Paths.get(directories.temp).resolve("_srcjars"),
+                fileMatcher = IS_JVM_SOURCE_FILE
+            ).also {
+                it.jarFiles.addAll(inputs.sourceJarsList.map { p -> Paths.get(p) })
+                it.execute()
+            }.sourcesList.iterator()
+        )
+
+    /**
+     * Create a new [JvmCompilationTask] with sources found in the generatedSources directory. This should be run after
+     * annotation processors have been run.
+     */
+    private fun JvmCompilationTask.expandWithGeneratedSources(): JvmCompilationTask =
+        expandWithSources(
+            File(directories.generatedSources).walkTopDown()
+                .filter { it.isFile }
+                .map { it.path }
+                .iterator()
+        )
+
+    private fun JvmCompilationTask.expandWithSources(sources: Iterator<String>): JvmCompilationTask =
+        updateBuilder { builder ->
+            sources.partitionJvmSources(
+                { builder.inputsBuilder.addKotlinSources(it) },
+                { builder.inputsBuilder.addJavaSources(it) })
+        }
+
+    private fun JvmCompilationTask.updateBuilder(
+        block: (JvmCompilationTask.Builder) -> Unit
+    ): JvmCompilationTask =
+        toBuilder().let {
+            block(it)
+            it.build()
+        }
 }
+
+
diff --git a/kotlin/builder/src/io/bazel/kotlin/builder/tasks/jvm/OutputJarCreator.kt b/kotlin/builder/src/io/bazel/kotlin/builder/tasks/jvm/OutputJarCreator.kt
deleted file mode 100644
index 0233dc5..0000000
--- a/kotlin/builder/src/io/bazel/kotlin/builder/tasks/jvm/OutputJarCreator.kt
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright 2018 The Bazel Authors. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package io.bazel.kotlin.builder.tasks.jvm
-
-import io.bazel.kotlin.builder.utils.bazelRuleKind
-import io.bazel.kotlin.builder.utils.jars.JarCreator
-import io.bazel.kotlin.model.JvmCompilationTask
-import java.nio.file.Paths
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-internal class OutputJarCreator @Inject constructor() {
-    fun createOutputJar(command: JvmCompilationTask) {
-        JarCreator(
-            path = Paths.get(command.outputs.jar),
-            normalize = true,
-            verbose = false
-        ).also {
-            it.addDirectory(Paths.get(command.directories.classes))
-            it.addDirectory(Paths.get(command.directories.generatedClasses))
-            it.setJarOwner(command.info.label, command.info.bazelRuleKind)
-            it.execute()
-        }
-    }
-}
diff --git a/kotlin/builder/src/io/bazel/kotlin/builder/utils/CompilationTaskContext.kt b/kotlin/builder/src/io/bazel/kotlin/builder/utils/CompilationTaskContext.kt
index 17946ae..fc85d0a 100644
--- a/kotlin/builder/src/io/bazel/kotlin/builder/utils/CompilationTaskContext.kt
+++ b/kotlin/builder/src/io/bazel/kotlin/builder/utils/CompilationTaskContext.kt
@@ -25,39 +25,51 @@
 
 class CompilationTaskContext(val info: CompilationTaskInfo, private val out: PrintStream) {
     private val executionRoot: String = Paths.get("").toAbsolutePath().toString() + File.separator
-    private val timings = mutableListOf<String>()
-    val isDebug: Boolean = info.debug > 0
+    private val timings: MutableList<String>?
+    @PublishedApi
+    internal val isTracing: Boolean
 
-    /**
-     * Print debugging messages if it is enabled for the task.
-     */
-    fun debugPrint(msg: String) {
-        if (info.debug > 0) {
-            out.println(msg)
-        }
+    init {
+        val debugging = info.debugList.toSet()
+        timings = if (debugging.contains("timings")) mutableListOf() else null
+        isTracing = debugging.contains("trace")
     }
 
+    fun reportUnhandledException(throwable: Throwable) { throwable.printStackTrace(out) }
+
     /**
-     * Print a debugging message if it debugging is enabled for the task. The lines are tab seperated.
+     * Print a list of debugging lines.
+     *
+     * @param header a header string
+     * @param lines a list of lines to print out
+     * @param prefix a prefix to add to each line
+     * @param filterEmpty if empty lines should be discarded or not
      */
-    private inline fun debugPrintHeadedLines(header: String, lines: () -> String) {
-        if (info.debug > 0) {
-            out.println(if (header.endsWith(":")) header else "$header:")
-            out.print("|  ${lines().replace("\n", "\n|  ")}")
+    fun printLines(header: String, lines: List<String>, prefix: String = "|  ", filterEmpty: Boolean = false) {
+        check(header.isNotEmpty())
+        out.println(if (header.endsWith(":")) header else "$header:")
+        lines.forEach {
+            if (it.isNotEmpty() || !filterEmpty) {
+                out.println("$prefix$it")
+            }
         }
+        out.println()
+    }
+
+    inline fun <T> whenTracing(block: CompilationTaskContext.() -> T): T? {
+        return if(isTracing) { block() } else null
     }
 
     /**
      * Print a proto message if debugging is enabled for the task.
      */
-    fun debugPrintProto(header: String, msg: MessageOrBuilder) {
-        debugPrintHeadedLines(header) { TextFormat.printToString(msg) }
+    fun printProto(header: String, msg: MessageOrBuilder) {
+        printLines(header, TextFormat.printToString(msg).split("\n"), filterEmpty = true)
     }
 
-    fun printCompilerOutput(line: String) {
-        out.println(trimExecutionRootPrefix(line))
-    }
-
+    /**
+     * This method normalizes and reports the output from the Kotlin compiler.
+     */
     fun printCompilerOutput(lines: List<String>) {
         lines.map(::trimExecutionRootPrefix).forEach(out::println)
     }
@@ -69,13 +81,31 @@
         } else toPrint
     }
 
+    /**
+     * Runs a task and records the timings.
+     */
     fun <T> execute(name: String, task: () -> T): T {
-        val start = System.currentTimeMillis()
-        return try {
+        return if (timings == null) {
             task()
-        } finally {
-            val stop = System.currentTimeMillis()
-            timings += "$name: ${stop - start} ms"
+        } else {
+            val start = System.currentTimeMillis()
+            try {
+                task()
+            } finally {
+                val stop = System.currentTimeMillis()
+                timings += "$name: ${stop - start} ms"
+            }
+        }
+    }
+
+    /**
+     * This method should be called at the end of builder invocation.
+     *
+     * @param succesfull true if the task finished succesfully.
+     */
+    fun finalize(succesfull: Boolean) {
+        if(succesfull) {
+            timings?.also { printLines("Task timings", it, prefix = "  * ") }
         }
     }
 }
diff --git a/kotlin/builder/src/io/bazel/kotlin/builder/utils/KotlinCompilerPluginArgsEncoder.kt b/kotlin/builder/src/io/bazel/kotlin/builder/utils/KotlinCompilerPluginArgsEncoder.kt
index 6974f0c..8e00e13 100644
--- a/kotlin/builder/src/io/bazel/kotlin/builder/utils/KotlinCompilerPluginArgsEncoder.kt
+++ b/kotlin/builder/src/io/bazel/kotlin/builder/utils/KotlinCompilerPluginArgsEncoder.kt
@@ -99,7 +99,9 @@
                 arg["javacArguments"] = javacArgs.let(Companion::encodeMap)
                 arg["aptMode"] = "stubsAndApt"
                 arg["correctErrorTypes"] = "true"
-                arg["verbose"] = context.isDebug.toString()
+                context.whenTracing {
+                    arg["verbose"] = "true"
+                }
 
                 arg["processors"] = plugin.annotationProcessorsList
                     .filter { it.processorClass.isNotEmpty() }
diff --git a/kotlin/builder/src/io/bazel/kotlin/builder/utils/TaskUtils.kt b/kotlin/builder/src/io/bazel/kotlin/builder/utils/TaskUtils.kt
index 67c607a..2f91ca6 100644
--- a/kotlin/builder/src/io/bazel/kotlin/builder/utils/TaskUtils.kt
+++ b/kotlin/builder/src/io/bazel/kotlin/builder/utils/TaskUtils.kt
@@ -19,28 +19,11 @@
 import io.bazel.kotlin.model.JvmCompilationTask
 import java.io.File
 
-fun JvmCompilationTask.expandWithSources(
-    sources: Iterator<String>
-): JvmCompilationTask =
-    updateBuilder { builder ->
-        sources.partitionSources(
-            { builder.inputsBuilder.addKotlinSources(it) },
-            { builder.inputsBuilder.addJavaSources(it) })
-    }
-
 val JvmCompilationTask.Inputs.joinedClasspath: String get() = this.classpathList.joinToString(File.pathSeparator)
 
 val CompilationTaskInfo.bazelRuleKind: String get() = "kt_${platform.name.toLowerCase()}_${ruleKind.name.toLowerCase()}"
 
-private fun JvmCompilationTask.updateBuilder(
-    init: (JvmCompilationTask.Builder) -> Unit
-): JvmCompilationTask =
-    toBuilder().let {
-        init(it)
-        it.build()
-    }
-
-fun Iterator<String>.partitionSources(kt: (String) -> Unit, java: (String) -> Unit) {
+fun Iterator<String>.partitionJvmSources(kt: (String) -> Unit, java: (String) -> Unit) {
     forEach {
         when {
             it.endsWith(".kt") -> kt(it)
diff --git a/kotlin/internal/compile.bzl b/kotlin/internal/compile.bzl
index 1d61f17..47e45a4 100644
--- a/kotlin/internal/compile.bzl
+++ b/kotlin/internal/compile.bzl
@@ -33,7 +33,14 @@
     args.add("--kotlin_api_version", toolchain.api_version)
     args.add("--kotlin_language_version", toolchain.language_version)
     args.add("--kotlin_passthrough_flags", "-Xcoroutines=%s" % toolchain.coroutines)
-    args.add("--kotlin_debug", toolchain.debug)
+
+    debug = depset(toolchain.debug)
+    for tag in ctx.attr.tags:
+        if tag == "trace":
+            debug = debug + [tag]
+        if tag == "timings":
+            debug = debug + [tag]
+    args.add("--kotlin_debug", debug)
 
     return args
 
diff --git a/kotlin/toolchains.bzl b/kotlin/toolchains.bzl
index 0e08ab8..c61c8ce 100644
--- a/kotlin/toolchains.bzl
+++ b/kotlin/toolchains.bzl
@@ -71,8 +71,12 @@
             "1.2",
         ],
     ),
-    "debug": attr.int(
-        doc="if this is non zero then the builder will produce debug logging."
+    "debug": attr.string_list(
+        allow_empty=True,
+        doc="""Debugging tags passed to the builder. Two tags are supported. `timings` will cause the builder to print
+timing information. `trace` will cause the builder to print tracing messages. These tags can be enabled via the default
+toolchain via the defines `kt_timings=1` and `kt_trace=1`. The tags may also be picked up via the `tags` attribute
+defined directly on the rules."""
     ),
     "coroutines": attr.string(
         default = "enable",
@@ -151,7 +155,7 @@
     api_version=None,
     jvm_target=None,
     coroutines=None,
-    debug=0
+    debug=[]
 ):
     """Define a Kotlin JVM Toolchain, the name is used in the `toolchain` rule so can be used to register the toolchain
     in the WORKSPACE file.
@@ -163,7 +167,7 @@
         api_version = api_version,
         jvm_target = jvm_target,
         coroutines = coroutines,
-        debug=debug,
+        debug = debug,
         visibility = ["//visibility:public"]
     )
     native.toolchain(