more kotlin examples

Author: NonSwag

core/example/src/main/kotlin/dev/faststats/example/KotlinErrorTrackerExample.kt

@@ -0,0 +1,60 @@
+package dev.faststats.example
+
+import dev.faststats.Attributes
+import dev.faststats.ErrorTracker
+import dev.faststats.FastStatsContext
+import dev.faststats.SimpleContext
+import java.lang.reflect.InvocationTargetException
+import java.nio.file.AccessDeniedException
+
+object KotlinErrorTrackerExample {
+    // Context-aware: automatically tracks uncaught errors from the same class loader
+    val CONTEXT_AWARE: ErrorTracker = ErrorTracker.contextAware() // Filter expected noise before it is submitted
+        .ignoreError(InvocationTargetException::class.java, "Expected .* but got .*")
+        .ignoreError(AccessDeniedException::class.java)
+
+    // Context-unaware: only tracks errors passed to trackError() manually
+    val CONTEXT_UNAWARE: ErrorTracker =
+        ErrorTracker.contextUnaware() // Replace sensitive values in error messages before submission
+            .anonymize("^[\\w-.]+@([\\w-]+\\.)+[\\w-]{2,4}$", "[email hidden]")
+            .anonymize("Bearer [A-Za-z0-9._~+/=-]+", "Bearer [token hidden]")
+            .anonymize("AKIA[0-9A-Z]{16}", "[aws-key hidden]")
+            .anonymize("[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}", "[uuid hidden]")
+            .anonymize("([?&](?:api_?key|token|secret)=)[^&\\s]+", "$1[redacted]")
+
+    val CONTEXT: FastStatsContext = contextFactory
+        .errorTrackerService(CONTEXT_AWARE) // Set the global/internal error tracker
+        .create()
+
+    init {
+        // Attributes on the global error tracker are attached to all reports
+        CONTEXT_AWARE.getAttributes()
+            .put("environment", "production")
+            .put("component", "global-error-handler")
+
+        // Tracker-wide attributes are attached to every report submitted by this tracker
+        CONTEXT_UNAWARE.getAttributes()
+            .put("component", "manual-error-handler")
+
+        // Register an additional tracker for submission
+        CONTEXT.errorTrackerService().orElseThrow().registerErrorTracker(CONTEXT_UNAWARE)
+    }
+
+    fun manualTracking() {
+        try {
+            throw RuntimeException("Something went wrong!")
+        } catch (e: Exception) {
+            CONTEXT_UNAWARE.trackError(e) // Add additional attributes for more context
+                .attributes(
+                    Attributes.empty()
+                        .put("operation", "manualTracking")
+                        .put("severity", "warning")
+                        .put("retryable", false)
+                ) // Define whether the error was properly handled
+                .handled(false)
+        }
+    }
+
+    private val contextFactory: SimpleContext.Factory<*, *>
+        get() = throw UnsupportedOperationException()
+}

core/example/src/main/kotlin/dev/faststats/example/KotlinFeatureFlagExample.kt

@@ -0,0 +1,65 @@
+package dev.faststats.example
+
+import dev.faststats.*
+import java.time.Duration
+import java.util.function.Consumer
+
+object KotlinFeatureFlagExample {
+    val CONTEXT: FastStatsContext = contextFactory
+        // .featureFlagService(FeatureFlagService.Factory::create) // Define a feature flag service with default settings
+        .featureFlagService { factory: FeatureFlagService.Factory? ->
+            factory!!
+                .attributes(
+                    Attributes.empty() // Define global attributes
+                        .put("version", "1.2.3")
+                        .put("java_version", System.getProperty("java.version"))
+                        .put("java_vendor", System.getProperty("java.vendor"))
+                )
+                .ttl(Duration.ofMinutes(10)) // Custom cache TTL for resolved flag values
+                .create()
+        }.create()
+
+    val SERVICE: FeatureFlagService = CONTEXT.featureFlagService().orElseThrow()
+
+    // Define flags with default values
+    val NEW_COMMANDS: FeatureFlag<Boolean> = SERVICE.define("new_commands", false)
+    val COMPRESSION: FeatureFlag<String> = SERVICE.define("compression", "zstd")
+
+    fun usage() {
+        // Async: waits for the server value to be fetched
+        NEW_COMMANDS.whenReady().thenAccept(Consumer { enabled: Boolean? ->
+            if (enabled == true) {
+                // register new commands
+            }
+        })
+
+        // Non-blocking: returns the cached value if present without triggering a fetch
+        COMPRESSION.getCached().ifPresent(Consumer { compression: String? ->
+            when (compression) {
+                "zstd" -> {}
+                "lz4" -> {}
+                else -> {}
+            }
+        })
+
+        // Refresh stale values explicitly when your code decides it is needed
+        if (COMPRESSION.isExpired()) {
+            COMPRESSION.fetch().thenAccept(Consumer { })
+        }
+
+        // Opt-in/out (requires allow_specific_opt_in on server)
+        NEW_COMMANDS.optIn().thenAccept(Consumer { updatedValue: Boolean? ->
+            if (updatedValue == true) {
+                // react to the updated server value
+            }
+        })
+        NEW_COMMANDS.optOut().thenAccept(Consumer { updatedValue: Boolean? ->
+            if (!updatedValue!!) {
+                // react to the updated server value
+            }
+        })
+    }
+
+    private val contextFactory: SimpleContext.Factory<*, *>
+        get() = throw UnsupportedOperationException()
+}

core/example/src/main/kotlin/dev/faststats/example/KotlinMetricTypesExample.kt

@@ -0,0 +1,18 @@
+package dev.faststats.example
+
+import dev.faststats.data.Metric
+
+object KotlinMetricTypesExample {
+    // Single value metrics
+    val PLAYER_COUNT: Metric<Number> = Metric.number("player_count") { 42 }
+    val SERVER_VERSION: Metric<String> = Metric.string("server_version") { "1.0.0" }
+    val MAINTENANCE_MODE: Metric<Boolean> = Metric.bool("maintenance_mode") { false }
+
+    // Array metrics
+    val INSTALLED_PLUGINS: Metric<Array<String>> = Metric.stringArray("installed_plugins") {
+        arrayOf("WorldEdit", "Essentials")
+    }
+    val WORLDS: Metric<Array<String>> = Metric.stringArray("worlds") {
+        arrayOf("city", "farmworld", "farmworld_nether", "famrworld_end")
+    }
+}