Version 1.3.0

Author: DIG-

app/android/build.gradle

@@ -12,6 +12,7 @@ def patch = 0
 
 def vName = versions.logger.pkg + patch
 android {
+    namespace "br.dev.dig.logger.app.android"
     compileSdk versions.android.compile
 
     defaultConfig {

app/android/src/main/AndroidManifest.xml

@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="br.dev.dig.logger.app.android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <application
         android:allowBackup="true"

build.gradle

@@ -41,15 +41,15 @@ buildscript {
             "java"   : JavaVersion.VERSION_1_8,
             "logger" : [
                     "major": "1",
-                    "minor": "2",
+                    "minor": "3",
                     "pkg"  : "",
             ],
             "android": [
                     "minimum": 21,
-                    "compile": 31,
-                    "target" : 31,
+                    "compile": 33,
+                    "target" : 33,
             ],
-            "kotlin" : "1.5.31",
+            "kotlin" : "1.8.10",
             "junit"  : "5.8.2",
             "mockito": "4.4.0",
     ]
@@ -68,19 +68,6 @@ buildscript {
                     ],
             ]
     ]
-    repositories {
-        mavenCentral()
-        google()
-    }
-    dependencies {
-        if (isAndroidEnabled) {
-            classpath "com.android.tools.build:gradle:7.1.3"
-            classpath "de.mannodermaus.gradle.plugins:android-junit5:1.8.2.0"
-            classpath "com.google.gms:google-services:4.3.10"
-            classpath "com.google.firebase:firebase-crashlytics-gradle:2.8.1"
-        }
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${versions.kotlin}"
-    }
     allprojects {
         repositories {
             mavenCentral()
@@ -89,6 +76,15 @@ buildscript {
     }
 }
 
+plugins {
+    id "org.jetbrains.kotlin.jvm" version "1.8.10" apply false
+    id "org.jetbrains.kotlin.android" version "1.8.10" apply false
+    id "com.android.application" version "7.3.1" apply false
+    id "com.google.gms.google-services" version "4.3.13" apply false
+    id "com.google.firebase.crashlytics" version "2.9.2" apply false
+    id "de.mannodermaus.android-junit5" version "1.8.2.0" apply false
+}
+
 Pattern regex = Pattern.compile("'([a-zA-Z0-9\\-_:]+)'")
 
 task deploy_ToLocal {

changelog.md

@@ -1,5 +1,13 @@
 Changelog
 =========
+1.3.0
+-----
+- Upgraded kotlin version
+- Better method to cascade tag
+- More filter options: Allowed/Blocked Throwable
+- Fix StreamLogger write method
+- Removed Deprecated PrintlnFormatter
+
 1.2.1-logger
 -----
 - Default log tag can be changed

filter-ktx/src/main/java/br/dev/dig/logger/FilterLoggerExtensions.kt

@@ -4,7 +4,7 @@ import br.dev.dig.logger.builder.LoggerBuilder
 import br.dev.dig.logger.filter.FilterLogger
 
 @Suppress("unused", "FunctionName")
-inline fun LoggerBuilder.FilterLogger(crossinline config: FilterLogger.Builder.() -> Unit): FilterLogger {
+inline fun LoggerBuilder.FilterLogger(crossinline config: FilterLogger.Builder.() -> Unit): BaseLogger {
     val builder = FilterLogger.Builder()
     config(builder)
     return builder.build()

filter/src/main/java/br/dev/dig/logger/filter/FilterLogger.java

@@ -3,30 +3,29 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.security.InvalidParameterException;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
 
 import br.dev.dig.logger.BaseLogger;
-import br.dev.dig.logger.Logger;
 import br.dev.dig.logger.intrinsics.Intrinsics;
 
-public final class FilterLogger implements BaseLogger {
-    @NotNull
-    final BaseLogger target;
-    final int level;
-
-    public FilterLogger(int minimum, @NotNull final BaseLogger target) {
-        if (minimum < Logger.LEVEL_VERBOSE || minimum > Logger.LEVEL_NONE) {
-            throw new InvalidParameterException("Minimum must be between `Logger.LEVEL_VERBOSE` and `Logger.LEVEL_NONE`.");
-        }
-        this.level = minimum;
-        this.target = Intrinsics.parameterNotNull(target, "Target BaseLogger must not be null");
+public final class FilterLogger {
+    private FilterLogger() {
+        throw new RuntimeException("Can not instantiate this class");
     }
 
     @SuppressWarnings("unused")
     public static class Builder {
         @Nullable
         BaseLogger target;
-        int level = Logger.LEVEL_NONE;
+        @Nullable
+        Integer level = null;
+        @Nullable
+        Set<Class<? extends Throwable>> allowed;
+        @Nullable
+        Set<Class<? extends Throwable>> blocked;
 
         public Builder() {
         }
@@ -36,41 +35,104 @@ public Builder(@NotNull final BaseLogger target) {
         }
 
         @Nullable
-        public BaseLogger getTarget() {
+        public final BaseLogger getTarget() {
             return target;
         }
 
-        public Builder setTarget(@NotNull final BaseLogger target) {
+        @NotNull
+        public final Builder setTarget(@NotNull final BaseLogger target) {
             this.target = target;
             return this;
         }
 
-        public int getLevel() {
+        @Nullable
+        public final Integer getLevel() {
             return level;
         }
 
-        public Builder setLevel(final int level) {
+        @NotNull
+        public final Builder setLevel(final int level) {
             this.level = level;
             return this;
         }
 
-        @SuppressWarnings("ConstantConditions")
-        public FilterLogger build() {
-            return new FilterLogger(level, target);
+        @Nullable
+        public final Set<Class<? extends Throwable>> getAllowed() {
+            return allowed;
         }
-    }
 
-    @Override
-    public void log(int level, @Nullable final String tag, @NotNull final Message message, @Nullable final Throwable throwable) {
-        if (level >= this.level) {
-            target.log(level, tag, message, throwable);
+        @NotNull
+        public final Builder setAllowed(@Nullable final Collection<Class<? extends Throwable>> allowed) {
+            if (allowed == null) {
+                this.allowed = null;
+            } else {
+                this.allowed = new HashSet<>(allowed);
+            }
+            return this;
+        }
+
+        @SafeVarargs
+        public final Builder setAllowed(@NotNull final Class<? extends Throwable>... allowed) {
+            this.allowed = new HashSet<>();
+            Collections.addAll(this.allowed, allowed);
+            return this;
+        }
+
+        @SafeVarargs
+        public final Builder addAllowed(@NotNull final Class<? extends Throwable>... allowed) {
+            if (this.allowed == null) {
+                this.allowed = new HashSet<>();
+            }
+            Collections.addAll(this.allowed, allowed);
+            return this;
+        }
+
+        @Nullable
+        public final Set<Class<? extends Throwable>> getBlocked() {
+            return blocked;
         }
-    }
 
-    @Override
-    public void log(int level, @Nullable final String tag, @Nullable final CharSequence message, @Nullable final Throwable throwable) {
-        if (level >= this.level) {
-            target.log(level, tag, message, throwable);
+
+        @NotNull
+        public final Builder setBlocked(@Nullable final Collection<Class<? extends Throwable>> blocked) {
+            if (blocked == null) {
+                this.blocked = null;
+            } else {
+                this.blocked = new HashSet<>(blocked);
+            }
+            return this;
+        }
+
+        @SafeVarargs
+        public final Builder setBlocked(@NotNull final Class<? extends Throwable>... blocked) {
+            this.blocked = new HashSet<>();
+            Collections.addAll(this.blocked, blocked);
+            return this;
+        }
+
+        @SafeVarargs
+        public final Builder addBlocked(@NotNull final Class<? extends Throwable>... blocked) {
+            if (this.blocked == null) {
+                this.blocked = new HashSet<>();
+            }
+            Collections.addAll(this.blocked, blocked);
+            return this;
+        }
+
+        @NotNull
+        public final BaseLogger build() {
+            BaseLogger previous = Intrinsics.parameterNotNull(target, "Can not build without target BaseLogger");
+            if (allowed != null) {
+                previous = new FilterLoggerByAllowedThrowable(previous, allowed);
+            }
+            if (blocked != null) {
+                previous = new FilterLoggerByBlockedThrowable(previous, blocked);
+            }
+            if (level != null) {
+                previous = new FilterLoggerByLevel(level, previous);
+            }
+            return previous;
         }
     }
-}
+
+}

filter/src/main/java/br/dev/dig/logger/filter/FilterLoggerByAllowedThrowable.java

@@ -0,0 +1,50 @@
+package br.dev.dig.logger.filter;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Set;
+
+import br.dev.dig.logger.BaseLogger;
+
+class FilterLoggerByAllowedThrowable implements BaseLogger {
+
+    @NotNull
+    final BaseLogger target;
+    @NotNull
+    final Set<Class<? extends Throwable>> allowed;
+
+    FilterLoggerByAllowedThrowable(@NotNull final BaseLogger target, @NotNull final Set<Class<? extends Throwable>> allowed) {
+        this.target = target;
+        this.allowed = allowed;
+    }
+
+    @Override
+    public void log(int level, @Nullable final String tag, @NotNull final Message message, @Nullable final Throwable throwable) {
+        if (throwable != null) {
+            for (Class<? extends Throwable> blocked : this.allowed) {
+                if (blocked.isInstance(throwable)) {
+                    target.log(level, tag, message, throwable);
+                    return;
+                }
+            }
+        } else {
+            target.log(level, tag, message, null);
+        }
+    }
+
+    @Override
+    public void log(int level, @Nullable final String tag, @Nullable final CharSequence message, @Nullable final Throwable throwable) {
+        if (throwable != null) {
+            for (Class<? extends Throwable> blocked : this.allowed) {
+                if (blocked.isInstance(throwable)) {
+                    target.log(level, tag, message, throwable);
+                    return;
+                }
+            }
+        } else {
+            target.log(level, tag, message, null);
+        }
+    }
+
+}

filter/src/main/java/br/dev/dig/logger/filter/FilterLoggerByBlockedThrowable.java

@@ -0,0 +1,46 @@
+package br.dev.dig.logger.filter;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Set;
+
+import br.dev.dig.logger.BaseLogger;
+
+class FilterLoggerByBlockedThrowable implements BaseLogger {
+
+    @NotNull
+    final BaseLogger target;
+    @NotNull
+    final Set<Class<? extends Throwable>> blocked;
+
+    FilterLoggerByBlockedThrowable(@NotNull final BaseLogger target, @NotNull final Set<Class<? extends Throwable>> blocked) {
+        this.target = target;
+        this.blocked = blocked;
+    }
+
+    @Override
+    public void log(int level, @Nullable final String tag, @NotNull final Message message, @Nullable final Throwable throwable) {
+        if (throwable != null) {
+            for (Class<? extends Throwable> blocked : this.blocked) {
+                if (blocked.isInstance(throwable)) {
+                    return;
+                }
+            }
+        }
+        target.log(level, tag, message, throwable);
+    }
+
+    @Override
+    public void log(int level, @Nullable final String tag, @Nullable final CharSequence message, @Nullable final Throwable throwable) {
+        if (throwable != null) {
+            for (Class<? extends Throwable> blocked : this.blocked) {
+                if (blocked.isInstance(throwable)) {
+                    return;
+                }
+            }
+        }
+        target.log(level, tag, message, throwable);
+    }
+
+}