diff --git a/bom/application/pom.xml b/bom/application/pom.xml
index a23b245708ee0..57504808a7327 100644
--- a/bom/application/pom.xml
+++ b/bom/application/pom.xml
@@ -17,7 +17,7 @@
         <bouncycastle.version>1.69</bouncycastle.version>
         <bouncycastle.fips.version>1.0.2.1</bouncycastle.fips.version>
         <bouncycastle.tls.fips.version>1.0.12.2</bouncycastle.tls.fips.version>
-        <jandex.version>2.3.1.Final</jandex.version>
+        <jandex.version>2.4.0.Final</jandex.version>
         <resteasy.version>4.7.0.Final</resteasy.version>
         <opentracing.version>0.33.0</opentracing.version>
         <opentracing-jaxrs.version>1.0.0</opentracing-jaxrs.version>
@@ -4365,6 +4365,11 @@
                 <artifactId>asm-analysis</artifactId>
                 <version>${asm.version}</version>
             </dependency>
+            <dependency>
+                <groupId>org.ow2.asm</groupId>
+                <artifactId>asm-commons</artifactId>
+                <version>${asm.version}</version>
+            </dependency>
             <dependency>
                 <groupId>org.slf4j</groupId>
                 <artifactId>slf4j-api</artifactId>
diff --git a/build-parent/pom.xml b/build-parent/pom.xml
index e7c6e7f70fe40..605cba756dbd3 100644
--- a/build-parent/pom.xml
+++ b/build-parent/pom.xml
@@ -34,7 +34,7 @@
         <failsafe-plugin.version>${version.surefire.plugin}</failsafe-plugin.version>
 
         <!-- jandex maven plugin version -->
-        <jandex-maven-plugin.version>1.1.1</jandex-maven-plugin.version>
+        <jandex-maven-plugin.version>1.2.0</jandex-maven-plugin.version>
 
         <!-- These properties are needed in order for them to be resolvable by the documentation -->
         <!-- The Graal version we suggest using in documentation - as that's
diff --git a/core/deployment/pom.xml b/core/deployment/pom.xml
index 6976efd549c85..c8d86191ff280 100644
--- a/core/deployment/pom.xml
+++ b/core/deployment/pom.xml
@@ -38,6 +38,10 @@
             <groupId>org.ow2.asm</groupId>
             <artifactId>asm</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.ow2.asm</groupId>
+            <artifactId>asm-commons</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-development-mode-spi</artifactId>
diff --git a/core/deployment/src/main/java/io/quarkus/deployment/builditem/BytecodeTransformerBuildItem.java b/core/deployment/src/main/java/io/quarkus/deployment/builditem/BytecodeTransformerBuildItem.java
index 966114f1b8609..80a9a3214984c 100644
--- a/core/deployment/src/main/java/io/quarkus/deployment/builditem/BytecodeTransformerBuildItem.java
+++ b/core/deployment/src/main/java/io/quarkus/deployment/builditem/BytecodeTransformerBuildItem.java
@@ -40,6 +40,8 @@ public final class BytecodeTransformerBuildItem extends MultiBuildItem {
 
     final boolean cacheable;
 
+    final int classReaderOptions;
+
     public BytecodeTransformerBuildItem(String classToTransform,
             BiFunction<String, ClassVisitor, ClassVisitor> visitorFunction) {
         this(classToTransform, visitorFunction, null);
@@ -75,6 +77,7 @@ public BytecodeTransformerBuildItem(boolean eager, String classToTransform,
         this.requireConstPoolEntry = requireConstPoolEntry;
         this.cacheable = cacheable;
         this.inputTransformer = null;
+        this.classReaderOptions = 0;
     }
 
     public BytecodeTransformerBuildItem(Builder builder) {
@@ -84,6 +87,7 @@ public BytecodeTransformerBuildItem(Builder builder) {
         this.requireConstPoolEntry = builder.requireConstPoolEntry;
         this.cacheable = builder.cacheable;
         this.inputTransformer = builder.inputTransformer;
+        this.classReaderOptions = builder.classReaderOptions;
         if (visitorFunction == null && inputTransformer == null) {
             throw new IllegalArgumentException("One of either visitorFunction or inputTransformer must be set");
         }
@@ -109,6 +113,10 @@ public boolean isCacheable() {
         return cacheable;
     }
 
+    public int getClassReaderOptions() {
+        return classReaderOptions;
+    }
+
     public BiFunction<String, byte[], byte[]> getInputTransformer() {
         return inputTransformer;
     }
@@ -120,6 +128,7 @@ public static class Builder {
         private Set<String> requireConstPoolEntry = null;
         private boolean eager = false;
         private boolean cacheable = false;
+        private int classReaderOptions = 0;
 
         public Builder setInputTransformer(BiFunction<String, byte[], byte[]> inputTransformer) {
             this.inputTransformer = inputTransformer;
@@ -151,6 +160,11 @@ public Builder setCacheable(boolean cacheable) {
             return this;
         }
 
+        public Builder setClassReaderOptions(int classReaderOptions) {
+            this.classReaderOptions = classReaderOptions;
+            return this;
+        }
+
         public BytecodeTransformerBuildItem build() {
             return new BytecodeTransformerBuildItem(this);
         }
diff --git a/core/deployment/src/main/java/io/quarkus/deployment/index/IndexWrapper.java b/core/deployment/src/main/java/io/quarkus/deployment/index/IndexWrapper.java
index 05a7ca734d7bb..6da05bc210274 100644
--- a/core/deployment/src/main/java/io/quarkus/deployment/index/IndexWrapper.java
+++ b/core/deployment/src/main/java/io/quarkus/deployment/index/IndexWrapper.java
@@ -19,6 +19,7 @@
 import org.jboss.jandex.Index;
 import org.jboss.jandex.IndexView;
 import org.jboss.jandex.Indexer;
+import org.jboss.jandex.ModuleInfo;
 import org.jboss.jandex.Type;
 import org.jboss.logging.Logger;
 
@@ -139,6 +140,21 @@ public Collection<AnnotationInstance> getAnnotationsWithRepeatable(DotName annot
         return this.index.getAnnotationsWithRepeatable(annotationName, index);
     }
 
+    @Override
+    public Collection<ModuleInfo> getKnownModules() {
+        return this.index.getKnownModules();
+    }
+
+    @Override
+    public ModuleInfo getModuleByName(DotName moduleName) {
+        return this.index.getModuleByName(moduleName);
+    }
+
+    @Override
+    public Collection<ClassInfo> getKnownUsers(DotName className) {
+        return this.index.getKnownUsers(className);
+    }
+
     private void getAllKnownSubClasses(DotName className, Set<ClassInfo> allKnown, Set<DotName> processedClasses) {
         final Set<DotName> subClassesToProcess = new HashSet<DotName>();
         subClassesToProcess.add(className);
diff --git a/core/deployment/src/main/java/io/quarkus/deployment/logging/LoggingWithPanacheProcessor.java b/core/deployment/src/main/java/io/quarkus/deployment/logging/LoggingWithPanacheProcessor.java
new file mode 100644
index 0000000000000..8cc8b42b2825e
--- /dev/null
+++ b/core/deployment/src/main/java/io/quarkus/deployment/logging/LoggingWithPanacheProcessor.java
@@ -0,0 +1,198 @@
+package io.quarkus.deployment.logging;
+
+import org.jboss.jandex.ClassInfo;
+import org.jboss.jandex.DotName;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.commons.LocalVariablesSorter;
+
+import io.quarkus.deployment.annotations.BuildProducer;
+import io.quarkus.deployment.annotations.BuildStep;
+import io.quarkus.deployment.builditem.BytecodeTransformerBuildItem;
+import io.quarkus.deployment.builditem.CombinedIndexBuildItem;
+import io.quarkus.gizmo.Gizmo;
+
+public class LoggingWithPanacheProcessor {
+    private static final DotName QUARKUS_LOG_DOTNAME = DotName.createSimple("io.quarkus.logging.Log");
+
+    private static final String QUARKUS_LOG_BINARY_NAME = "io/quarkus/logging/Log";
+
+    private static final String SYNTHETIC_LOGGER_FIELD_NAME = "quarkusSyntheticLogger";
+
+    private static final String JBOSS_LOGGER_BINARY_NAME = "org/jboss/logging/Logger";
+    private static final String JBOSS_LOGGER_DESCRIPTOR = "L" + JBOSS_LOGGER_BINARY_NAME + ";";
+    private static final String GET_LOGGER_DESCRIPTOR = "(Ljava/lang/String;)" + JBOSS_LOGGER_DESCRIPTOR;
+
+    @BuildStep
+    public void process(CombinedIndexBuildItem index, BuildProducer<BytecodeTransformerBuildItem> transformers) {
+        for (ClassInfo clazz : index.getIndex().getKnownUsers(QUARKUS_LOG_DOTNAME)) {
+            String className = clazz.name().toString();
+
+            transformers.produce(new BytecodeTransformerBuildItem.Builder()
+                    .setClassToTransform(className)
+                    .setVisitorFunction((ignored, visitor) -> new AddLoggerFieldAndRewriteInvocations(visitor, className))
+                    .setClassReaderOptions(ClassReader.EXPAND_FRAMES)
+                    .build());
+        }
+    }
+
+    /**
+     * Makes the following modifications to the visited class:
+     * <ul>
+     * <li>adds a {@code private static final} field of type {@code org.jboss.logging.Logger};</li>
+     * <li>initializes the field (to {@code Logger.getLogger(className)}) at the beginning of the
+     * static initializer (creating one if missing);</li>
+     * <li>rewrites all invocations of {@code static} methods on {@code io.quarkus.logging.Log}
+     * to corresponding invocations of virtual methods on the logger field.</li>
+     * </ul>
+     * Assumes that the set of {@code static} methods on {@code io.quarkus.runtime.logging.Log}
+     * is identical (when it comes to names, return types and parameter types) to the set of virtual methods
+     * on {@code org.jboss.logging.BasicLogger}.
+     */
+    private static class AddLoggerFieldAndRewriteInvocations extends ClassVisitor {
+        private final String className;
+        private final String classNameBinary;
+
+        private boolean generatedLoggerField;
+        private boolean generatedLoggerFieldInitialization;
+
+        public AddLoggerFieldAndRewriteInvocations(ClassVisitor visitor, String className) {
+            super(Gizmo.ASM_API_VERSION, visitor);
+            this.className = className;
+            this.classNameBinary = className.replace(".", "/");
+        }
+
+        @Override
+        public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {
+            if (!generatedLoggerField) {
+                // should be the first field
+                // if there's no field, this will be called in visitEnd
+                generateLoggerField();
+            }
+
+            return super.visitField(access, name, descriptor, signature, value);
+        }
+
+        @Override
+        public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
+            MethodVisitor visitor = super.visitMethod(access, name, descriptor, signature, exceptions);
+            if (visitor == null) {
+                return null;
+            }
+
+            return new LocalVariablesSorter(Gizmo.ASM_API_VERSION, access, descriptor, visitor) {
+                @Override
+                public void visitCode() {
+                    if ("<clinit>".equals(name)) {
+                        super.visitLdcInsn(className);
+                        super.visitMethodInsn(Opcodes.INVOKESTATIC, JBOSS_LOGGER_BINARY_NAME, "getLogger",
+                                GET_LOGGER_DESCRIPTOR, false);
+                        super.visitFieldInsn(Opcodes.PUTSTATIC, classNameBinary, SYNTHETIC_LOGGER_FIELD_NAME,
+                                JBOSS_LOGGER_DESCRIPTOR);
+                        generatedLoggerFieldInitialization = true;
+                    }
+
+                    super.visitCode();
+                }
+
+                @Override
+                public void visitMethodInsn(int opcode, String owner, String name, String descriptor, boolean isInterface) {
+                    if (!QUARKUS_LOG_BINARY_NAME.equals(owner)) {
+                        super.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
+                        return;
+                    }
+
+                    Type[] argTypes = Type.getArgumentTypes(descriptor);
+                    int numArgs = argTypes.length;
+                    int[] locals = null;
+
+                    boolean directStackManipulation = isDirectStackManipulationPossible(argTypes);
+
+                    // for 0, 1 or 2 arguments of the logger method, where each only takes 1 stack slot,
+                    // direct stack manipulation is possible
+                    // for 3 or more arguments, or less arguments but at least one taking 2 stack slots,
+                    // we move them from stack to local variables and restore later
+                    if (!directStackManipulation) {
+                        // stack: [arg1 arg2 arg3 arg4] locals: {}
+                        // stack: [arg1 arg2 arg3]      locals: {l1 = arg4}
+                        // stack: [arg1 arg2]           locals: {l1 = arg4 l2 = arg3}
+                        // stack: [arg1]                locals: {l1 = arg4 l2 = arg3 l3 = arg2}
+                        // stack: []                    locals: {l1 = arg4 l2 = arg3 l3 = arg2 l4 = arg1}
+                        locals = new int[numArgs];
+                        for (int i = numArgs - 1; i >= 0; i--) {
+                            locals[i] = newLocal(argTypes[i]);
+                            super.visitVarInsn(argTypes[i].getOpcode(Opcodes.ISTORE), locals[i]);
+                        }
+                    }
+
+                    // stack: [] -> [logger]
+                    super.visitFieldInsn(Opcodes.GETSTATIC, classNameBinary, SYNTHETIC_LOGGER_FIELD_NAME,
+                            JBOSS_LOGGER_DESCRIPTOR);
+
+                    if (directStackManipulation) {
+                        if (numArgs == 1) {
+                            // stack: [arg1 logger] -> [logger arg1]
+                            super.visitInsn(Opcodes.SWAP);
+                        } else if (numArgs == 2) {
+                            // stack: [arg1 arg2 logger] -> [logger arg1 arg2 logger]
+                            super.visitInsn(Opcodes.DUP_X2);
+                            // stack: [logger arg1 arg2 logger] -> [logger arg1 arg2]
+                            super.visitInsn(Opcodes.POP);
+                        }
+                    } else {
+                        // stack: [logger]                     locals: {l1 = arg4 l2 = arg3 l3 = arg2 l4 = arg1}
+                        // stack: [logger arg1]                locals: {l1 = arg4 l2 = arg3 l3 = arg2}
+                        // stack: [logger arg1 arg2]           locals: {l1 = arg4 l2 = arg3}
+                        // stack: [logger arg1 arg2 arg3]      locals: {l1 = arg4}
+                        // stack: [logger arg1 arg2 arg3 arg4] locals: {}
+                        for (int i = 0; i < numArgs; i++) {
+                            super.visitVarInsn(argTypes[i].getOpcode(Opcodes.ILOAD), locals[i]);
+                        }
+                    }
+
+                    super.visitMethodInsn(Opcodes.INVOKEVIRTUAL, JBOSS_LOGGER_BINARY_NAME, name, descriptor, false);
+                }
+
+                private boolean isDirectStackManipulationPossible(Type[] argTypes) {
+                    return argTypes.length == 0
+                            || argTypes.length == 1 && argTypes[0].getSize() == 1
+                            || argTypes.length == 2 && argTypes[0].getSize() == 1 && argTypes[1].getSize() == 1;
+                }
+            };
+        }
+
+        @Override
+        public void visitEnd() {
+            if (!generatedLoggerField) {
+                generateLoggerField();
+            }
+
+            if (!generatedLoggerFieldInitialization) {
+                MethodVisitor visitor = super.visitMethod(Opcodes.ACC_STATIC, "<clinit>", "()V", null, null);
+                visitor.visitCode();
+                visitor.visitLdcInsn(className);
+                visitor.visitMethodInsn(Opcodes.INVOKESTATIC, JBOSS_LOGGER_BINARY_NAME, "getLogger",
+                        GET_LOGGER_DESCRIPTOR, false);
+                visitor.visitFieldInsn(Opcodes.PUTSTATIC, classNameBinary, SYNTHETIC_LOGGER_FIELD_NAME,
+                        JBOSS_LOGGER_DESCRIPTOR);
+                visitor.visitInsn(Opcodes.RETURN);
+                visitor.visitMaxs(1, 0);
+                visitor.visitEnd();
+
+                generatedLoggerFieldInitialization = true;
+            }
+
+            super.visitEnd();
+        }
+
+        private void generateLoggerField() {
+            super.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL,
+                    SYNTHETIC_LOGGER_FIELD_NAME, JBOSS_LOGGER_DESCRIPTOR, null, null);
+            generatedLoggerField = true;
+        }
+    }
+}
diff --git a/core/deployment/src/main/java/io/quarkus/deployment/steps/ClassTransformingBuildStep.java b/core/deployment/src/main/java/io/quarkus/deployment/steps/ClassTransformingBuildStep.java
index cb766156fd4c9..25426d105d2dc 100644
--- a/core/deployment/src/main/java/io/quarkus/deployment/steps/ClassTransformingBuildStep.java
+++ b/core/deployment/src/main/java/io/quarkus/deployment/steps/ClassTransformingBuildStep.java
@@ -78,6 +78,7 @@ TransformedClassesBuildItem handleClassTransformation(List<BytecodeTransformerBu
         Map<String, Set<String>> constScanning = new HashMap<>();
         Set<String> eager = new HashSet<>();
         Set<String> nonCacheable = new HashSet<>();
+        Map<String, Integer> classReaderOptions = new HashMap<>();
         for (BytecodeTransformerBuildItem i : bytecodeTransformerBuildItems) {
             bytecodeTransformers.computeIfAbsent(i.getClassToTransform(), (h) -> new ArrayList<>())
                     .add(i);
@@ -93,6 +94,7 @@ TransformedClassesBuildItem handleClassTransformation(List<BytecodeTransformerBu
             if (!i.isCacheable()) {
                 nonCacheable.add(i.getClassToTransform());
             }
+            classReaderOptions.put(i.getClassToTransform(), i.getClassReaderOptions());
         }
         QuarkusClassLoader cl = (QuarkusClassLoader) Thread.currentThread().getContextClassLoader();
         Map<String, Path> transformedToArchive = new ConcurrentHashMap<>();
@@ -132,7 +134,8 @@ public byte[] apply(String className, byte[] originalBytes) {
                                 return originalBytes;
                             }
                         }
-                        byte[] data = transformClass(className, visitors, classData, preVisitFunctions);
+                        byte[] data = transformClass(className, visitors, classData, preVisitFunctions,
+                                classReaderOptions.getOrDefault(className, 0));
                         TransformedClassesBuildItem.TransformedClass transformedClass = new TransformedClassesBuildItem.TransformedClass(
                                 className, data,
                                 classFileName, eager.contains(className));
@@ -190,7 +193,8 @@ public TransformedClassesBuildItem.TransformedClass call() throws Exception {
                                         return null;
                                     }
                                 }
-                                byte[] data = transformClass(className, visitors, classData, preVisitFunctions);
+                                byte[] data = transformClass(className, visitors, classData, preVisitFunctions,
+                                        classReaderOptions.getOrDefault(className, 0));
                                 TransformedClassesBuildItem.TransformedClass transformedClass = new TransformedClassesBuildItem.TransformedClass(
                                         className, data,
                                         classFileName, eager.contains(className));
@@ -256,7 +260,7 @@ private void handleRemovedResources(ClassLoadingConfig classLoadingConfig, Curat
     }
 
     private byte[] transformClass(String className, List<BiFunction<String, ClassVisitor, ClassVisitor>> visitors,
-            byte[] classData, List<BiFunction<String, byte[], byte[]>> preVisitFunctions) {
+            byte[] classData, List<BiFunction<String, byte[], byte[]>> preVisitFunctions, int classReaderOptions) {
         for (BiFunction<String, byte[], byte[]> i : preVisitFunctions) {
             classData = i.apply(className, classData);
             if (classData == null) {
@@ -272,7 +276,7 @@ private byte[] transformClass(String className, List<BiFunction<String, ClassVis
             for (BiFunction<String, ClassVisitor, ClassVisitor> i : visitors) {
                 visitor = i.apply(className, visitor);
             }
-            cr.accept(visitor, 0);
+            cr.accept(visitor, classReaderOptions);
             data = writer.toByteArray();
         } else {
             data = classData;
diff --git a/core/runtime/src/main/java/io/quarkus/logging/Log.java b/core/runtime/src/main/java/io/quarkus/logging/Log.java
new file mode 100644
index 0000000000000..e72b9977f489e
--- /dev/null
+++ b/core/runtime/src/main/java/io/quarkus/logging/Log.java
@@ -0,0 +1,2310 @@
+package io.quarkus.logging;
+
+import org.jboss.logging.Logger;
+
+/**
+ * Copy of {@link org.jboss.logging.BasicLogger}.
+ * Invocations of all {@code static} methods of this class are, during build time, replaced by invocations
+ * of the same methods on a generated instance of {@link Logger}.
+ */
+public final class Log {
+
+    /**
+     * Check to see if the given level is enabled for this logger.
+     *
+     * @param level the level to check for
+     * @return {@code true} if messages may be logged at the given level, {@code false} otherwise
+     */
+    public static boolean isEnabled(Logger.Level level) {
+        throw fail();
+    }
+
+    /**
+     * Check to see if the {@code TRACE} level is enabled for this logger.
+     *
+     * @return {@code true} if messages logged at {@link org.jboss.logging.Logger.Level#TRACE} may be accepted, {@code false}
+     *         otherwise
+     */
+    public static boolean isTraceEnabled() {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of TRACE.
+     *
+     * @param message the message
+     */
+    public static void trace(Object message) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message and throwable with a level of TRACE.
+     *
+     * @param message the message
+     * @param t the throwable
+     */
+    public static void trace(Object message, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message and throwable with a level of TRACE and a specific logger class name.
+     *
+     * @param loggerFqcn the logger class name
+     * @param message the message
+     * @param t the throwable
+     */
+    public static void trace(String loggerFqcn, Object message, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with parameters and a throwable with a level of TRACE.
+     *
+     * @param loggerFqcn the logger class name
+     * @param message the message
+     * @param params the message parameters
+     * @param t the throwable
+     */
+    public static void trace(String loggerFqcn, Object message, Object[] params, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void tracev(String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void tracev(String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void tracev(String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void tracev(String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void tracev(Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void tracev(Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void tracev(Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void tracev(Throwable t, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param params the parameters
+     */
+    public static void tracef(String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the sole parameter
+     */
+    public static void tracef(String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void tracef(String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void tracef(String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param params the parameters
+     */
+    public static void tracef(Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the sole parameter
+     */
+    public static void tracef(Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void tracef(Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void tracef(Throwable t, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg the parameter
+     */
+    public static void tracef(String format, int arg) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void tracef(String format, int arg1, int arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void tracef(String format, int arg1, Object arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void tracef(String format, int arg1, int arg2, int arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void tracef(String format, int arg1, int arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void tracef(String format, int arg1, Object arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg the parameter
+     */
+    public static void tracef(Throwable t, String format, int arg) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void tracef(Throwable t, String format, int arg1, int arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void tracef(Throwable t, String format, int arg1, Object arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void tracef(Throwable t, String format, int arg1, int arg2, int arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void tracef(Throwable t, String format, int arg1, int arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void tracef(Throwable t, String format, int arg1, Object arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg the parameter
+     */
+    public static void tracef(String format, long arg) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void tracef(String format, long arg1, long arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void tracef(String format, long arg1, Object arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void tracef(String format, long arg1, long arg2, long arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void tracef(String format, long arg1, long arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void tracef(String format, long arg1, Object arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg the parameter
+     */
+    public static void tracef(Throwable t, String format, long arg) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void tracef(Throwable t, String format, long arg1, long arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void tracef(Throwable t, String format, long arg1, Object arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void tracef(Throwable t, String format, long arg1, long arg2, long arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void tracef(Throwable t, String format, long arg1, long arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of TRACE.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void tracef(Throwable t, String format, long arg1, Object arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Check to see if the {@code DEBUG} level is enabled for this logger.
+     *
+     * @return {@code true} if messages logged at {@link org.jboss.logging.Logger.Level#DEBUG} may be accepted, {@code false}
+     *         otherwise
+     */
+    public static boolean isDebugEnabled() {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of DEBUG.
+     *
+     * @param message the message
+     */
+    public static void debug(Object message) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message and throwable with a level of DEBUG.
+     *
+     * @param message the message
+     * @param t the throwable
+     */
+    public static void debug(Object message, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message and throwable with a level of DEBUG and a specific logger class name.
+     *
+     * @param loggerFqcn the logger class name
+     * @param message the message
+     * @param t the throwable
+     */
+    public static void debug(String loggerFqcn, Object message, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with parameters and a throwable with a level of DEBUG.
+     *
+     * @param loggerFqcn the logger class name
+     * @param message the message
+     * @param params the message parameters
+     * @param t the throwable
+     */
+    public static void debug(String loggerFqcn, Object message, Object[] params, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void debugv(String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void debugv(String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void debugv(String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void debugv(String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void debugv(Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void debugv(Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void debugv(Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void debugv(Throwable t, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param params the parameters
+     */
+    public static void debugf(String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the sole parameter
+     */
+    public static void debugf(String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void debugf(String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void debugf(String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param params the parameters
+     */
+    public static void debugf(Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the sole parameter
+     */
+    public static void debugf(Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void debugf(Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void debugf(Throwable t, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg the parameter
+     */
+    public static void debugf(String format, int arg) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void debugf(String format, int arg1, int arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void debugf(String format, int arg1, Object arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void debugf(String format, int arg1, int arg2, int arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void debugf(String format, int arg1, int arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void debugf(String format, int arg1, Object arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg the parameter
+     */
+    public static void debugf(Throwable t, String format, int arg) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void debugf(Throwable t, String format, int arg1, int arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void debugf(Throwable t, String format, int arg1, Object arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void debugf(Throwable t, String format, int arg1, int arg2, int arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void debugf(Throwable t, String format, int arg1, int arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void debugf(Throwable t, String format, int arg1, Object arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg the parameter
+     */
+    public static void debugf(String format, long arg) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void debugf(String format, long arg1, long arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void debugf(String format, long arg1, Object arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void debugf(String format, long arg1, long arg2, long arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void debugf(String format, long arg1, long arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void debugf(String format, long arg1, Object arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg the parameter
+     */
+    public static void debugf(Throwable t, String format, long arg) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void debugf(Throwable t, String format, long arg1, long arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     */
+    public static void debugf(Throwable t, String format, long arg1, Object arg2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void debugf(Throwable t, String format, long arg1, long arg2, long arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void debugf(Throwable t, String format, long arg1, long arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of DEBUG.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param arg1 the first parameter
+     * @param arg2 the second parameter
+     * @param arg3 the third parameter
+     */
+    public static void debugf(Throwable t, String format, long arg1, Object arg2, Object arg3) {
+        throw fail();
+    }
+
+    /**
+     * Check to see if the {@code INFO} level is enabled for this logger.
+     *
+     * @return {@code true} if messages logged at {@link org.jboss.logging.Logger.Level#INFO} may be accepted, {@code false}
+     *         otherwise
+     */
+    public static boolean isInfoEnabled() {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of INFO.
+     *
+     * @param message the message
+     */
+    public static void info(Object message) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message and throwable with a level of INFO.
+     *
+     * @param message the message
+     * @param t the throwable
+     */
+    public static void info(Object message, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message and throwable with a level of INFO and a specific logger class name.
+     *
+     * @param loggerFqcn the logger class name
+     * @param message the message
+     * @param t the throwable
+     */
+    public static void info(String loggerFqcn, Object message, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with parameters and a throwable with a level of INFO.
+     *
+     * @param loggerFqcn the logger class name
+     * @param message the message
+     * @param params the message parameters
+     * @param t the throwable
+     */
+    public static void info(String loggerFqcn, Object message, Object[] params, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void infov(String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void infov(String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void infov(String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void infov(String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void infov(Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void infov(Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void infov(Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void infov(Throwable t, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of INFO.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param params the parameters
+     */
+    public static void infof(String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of INFO.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the sole parameter
+     */
+    public static void infof(String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of INFO.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void infof(String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of INFO.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void infof(String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of INFO.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param params the parameters
+     */
+    public static void infof(Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of INFO.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the sole parameter
+     */
+    public static void infof(Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of INFO.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void infof(Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of INFO.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void infof(Throwable t, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of WARN.
+     *
+     * @param message the message
+     */
+    public static void warn(Object message) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message and throwable with a level of WARN.
+     *
+     * @param message the message
+     * @param t the throwable
+     */
+    public static void warn(Object message, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message and throwable with a level of WARN and a specific logger class name.
+     *
+     * @param loggerFqcn the logger class name
+     * @param message the message
+     * @param t the throwable
+     */
+    public static void warn(String loggerFqcn, Object message, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with parameters and a throwable with a level of WARN.
+     *
+     * @param loggerFqcn the logger class name
+     * @param message the message
+     * @param params the message parameters
+     * @param t the throwable
+     */
+    public static void warn(String loggerFqcn, Object message, Object[] params, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void warnv(String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void warnv(String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void warnv(String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void warnv(String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void warnv(Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void warnv(Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void warnv(Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void warnv(Throwable t, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of WARN.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param params the parameters
+     */
+    public static void warnf(String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of WARN.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the sole parameter
+     */
+    public static void warnf(String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of WARN.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void warnf(String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of WARN.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void warnf(String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of WARN.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param params the parameters
+     */
+    public static void warnf(Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of WARN.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the sole parameter
+     */
+    public static void warnf(Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of WARN.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void warnf(Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of WARN.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void warnf(Throwable t, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of ERROR.
+     *
+     * @param message the message
+     */
+    public static void error(Object message) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message and throwable with a level of ERROR.
+     *
+     * @param message the message
+     * @param t the throwable
+     */
+    public static void error(Object message, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message and throwable with a level of ERROR and a specific logger class name.
+     *
+     * @param loggerFqcn the logger class name
+     * @param message the message
+     * @param t the throwable
+     */
+    public static void error(String loggerFqcn, Object message, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with parameters and a throwable with a level of ERROR.
+     *
+     * @param loggerFqcn the logger class name
+     * @param message the message
+     * @param params the message parameters
+     * @param t the throwable
+     */
+    public static void error(String loggerFqcn, Object message, Object[] params, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void errorv(String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void errorv(String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void errorv(String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void errorv(String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void errorv(Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void errorv(Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void errorv(Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void errorv(Throwable t, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of ERROR.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param params the parameters
+     */
+    public static void errorf(String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of ERROR.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the sole parameter
+     */
+    public static void errorf(String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of ERROR.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void errorf(String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of ERROR.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void errorf(String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of ERROR.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param params the parameters
+     */
+    public static void errorf(Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of ERROR.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the sole parameter
+     */
+    public static void errorf(Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of ERROR.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void errorf(Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of ERROR.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void errorf(Throwable t, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of FATAL.
+     *
+     * @param message the message
+     */
+    public static void fatal(Object message) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message and throwable with a level of FATAL.
+     *
+     * @param message the message
+     * @param t the throwable
+     */
+    public static void fatal(Object message, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message and throwable with a level of FATAL and a specific logger class name.
+     *
+     * @param loggerFqcn the logger class name
+     * @param message the message
+     * @param t the throwable
+     */
+    public static void fatal(String loggerFqcn, Object message, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with parameters and a throwable with a level of FATAL.
+     *
+     * @param loggerFqcn the logger class name
+     * @param message the message
+     * @param params the message parameters
+     * @param t the throwable
+     */
+    public static void fatal(String loggerFqcn, Object message, Object[] params, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void fatalv(String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void fatalv(String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void fatalv(String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void fatalv(String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void fatalv(Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void fatalv(Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void fatalv(Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void fatalv(Throwable t, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of FATAL.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param params the parameters
+     */
+    public static void fatalf(String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of FATAL.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the sole parameter
+     */
+    public static void fatalf(String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of FATAL.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void fatalf(String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of FATAL.
+     *
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void fatalf(String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of FATAL.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param params the parameters
+     */
+    public static void fatalf(Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of FATAL.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the sole parameter
+     */
+    public static void fatalf(Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of FATAL.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void fatalf(Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message with a level of FATAL.
+     *
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void fatalf(Throwable t, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Log a message at the given level.
+     *
+     * @param level the level
+     * @param message the message
+     */
+    public static void log(Logger.Level level, Object message) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message and throwable at the given log level.
+     *
+     * @param level the level
+     * @param message the message
+     * @param t the throwable
+     */
+    public static void log(Logger.Level level, Object message, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message and throwable at the given log level and a specific logger class name.
+     *
+     * @param level the level
+     * @param loggerFqcn the logger class name
+     * @param message the message
+     * @param t the throwable
+     */
+    public static void log(Logger.Level level, String loggerFqcn, Object message, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message with parameters and a throwable at the given log level.
+     *
+     * @param loggerFqcn the logger class name
+     * @param level the level
+     * @param message the message
+     * @param params the message parameters
+     * @param t the throwable
+     */
+    public static void log(String loggerFqcn, Logger.Level level, Object message, Object[] params, Throwable t) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param level the level
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void logv(Logger.Level level, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param level the level
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void logv(Logger.Level level, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param level the level
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void logv(Logger.Level level, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param level the level
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void logv(Logger.Level level, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param level the level
+     * @param t the throwable
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void logv(Logger.Level level, Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param level the level
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void logv(Logger.Level level, Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param level the level
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void logv(Logger.Level level, Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param level the level
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void logv(Logger.Level level, Throwable t, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param loggerFqcn the logger class name
+     * @param level the level
+     * @param t the throwable
+     * @param format the message format string
+     * @param params the parameters
+     */
+    public static void logv(String loggerFqcn, Logger.Level level, Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param loggerFqcn the logger class name
+     * @param level the level
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the sole parameter
+     */
+    public static void logv(String loggerFqcn, Logger.Level level, Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param loggerFqcn the logger class name
+     * @param level the level
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void logv(String loggerFqcn, Logger.Level level, Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting.
+     *
+     * @param loggerFqcn the logger class name
+     * @param level the level
+     * @param t the throwable
+     * @param format the message format string
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void logv(String loggerFqcn, Logger.Level level, Throwable t, String format, Object param1, Object param2,
+            Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message at the given log level.
+     *
+     * @param level the level
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param params the parameters
+     */
+    public static void logf(Logger.Level level, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message at the given log level.
+     *
+     * @param level the level
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the sole parameter
+     */
+    public static void logf(Logger.Level level, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message at the given log level.
+     *
+     * @param level the level
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void logf(Logger.Level level, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message at the given log level.
+     *
+     * @param level the level
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void logf(Logger.Level level, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message at the given log level.
+     *
+     * @param level the level
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param params the parameters
+     */
+    public static void logf(Logger.Level level, Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message at the given log level.
+     *
+     * @param level the level
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the sole parameter
+     */
+    public static void logf(Logger.Level level, Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message at the given log level.
+     *
+     * @param level the level
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void logf(Logger.Level level, Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Issue a formatted log message at the given log level.
+     *
+     * @param level the level
+     * @param t the throwable
+     * @param format the format string, as per {@link String#format(String, Object...)}
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void logf(Logger.Level level, Throwable t, String format, Object param1, Object param2, Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Log a message at the given level.
+     *
+     * @param loggerFqcn the logger class name
+     * @param level the level
+     * @param t the throwable cause
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the sole parameter
+     */
+    public static void logf(String loggerFqcn, Logger.Level level, Throwable t, String format, Object param1) {
+        throw fail();
+    }
+
+    /**
+     * Log a message at the given level.
+     *
+     * @param loggerFqcn the logger class name
+     * @param level the level
+     * @param t the throwable cause
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     */
+    public static void logf(String loggerFqcn, Logger.Level level, Throwable t, String format, Object param1, Object param2) {
+        throw fail();
+    }
+
+    /**
+     * Log a message at the given level.
+     *
+     * @param loggerFqcn the logger class name
+     * @param level the level
+     * @param t the throwable cause
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param param1 the first parameter
+     * @param param2 the second parameter
+     * @param param3 the third parameter
+     */
+    public static void logf(String loggerFqcn, Logger.Level level, Throwable t, String format, Object param1, Object param2,
+            Object param3) {
+        throw fail();
+    }
+
+    /**
+     * Log a message at the given level.
+     *
+     * @param loggerFqcn the logger class name
+     * @param level the level
+     * @param t the throwable cause
+     * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor
+     * @param params the message parameters
+     */
+    public static void logf(String loggerFqcn, Logger.Level level, Throwable t, String format, Object... params) {
+        throw fail();
+    }
+
+    private static UnsupportedOperationException fail() {
+        return new UnsupportedOperationException("Using " + Log.class.getName()
+                + " is only possible with Quarkus bytecode transformation");
+    }
+}
diff --git a/core/runtime/src/test/java/io/quarkus/logging/GenerateLog.java b/core/runtime/src/test/java/io/quarkus/logging/GenerateLog.java
new file mode 100644
index 0000000000000..af56239be10d4
--- /dev/null
+++ b/core/runtime/src/test/java/io/quarkus/logging/GenerateLog.java
@@ -0,0 +1,72 @@
+package io.quarkus.logging;
+
+import static java.net.http.HttpResponse.BodyHandlers;
+
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.jboss.logging.BasicLogger;
+
+public class GenerateLog {
+    private static final String PACKAGE_AND_IMPORT = "" +
+            "package " + Log.class.getPackageName() + ";\n" +
+            "\n" +
+            "import org.jboss.logging.Logger;";
+    private static final String CLASS_HEADER = "" +
+            "/**\n" +
+            " * Copy of {@link org.jboss.logging.BasicLogger}.\n" +
+            " * Invocations of all {@code static} methods of this class are, during build time, replaced by invocations\n" +
+            " * of the same methods on a generated instance of {@link Logger}.\n" +
+            " */\n" +
+            "public final class Log";
+    private static final String LOG_METHOD_BODY = ") {\n" +
+            "        throw fail();\n" +
+            "    }";
+    private static final String FAIL_METHOD = "" +
+            "\n" +
+            "    private static UnsupportedOperationException fail() {\n" +
+            "        return new UnsupportedOperationException(\"Using \" + Log.class.getName()\n" +
+            "                + \" is only possible with Quarkus bytecode transformation\");\n" +
+            "    }\n";
+
+    public static void main(String[] args) throws Exception {
+        String source = BasicLogger.class.getProtectionDomain().getCodeSource().getLocation().getPath();
+        Matcher matcher = Pattern.compile("\\d+\\.\\d+\\.\\d+\\.Final").matcher(source);
+        if (matcher.find()) {
+            String version = matcher.group();
+            String url = "https://raw.githubusercontent.com/jboss-logging/jboss-logging/" + version
+                    + "/src/main/java/org/jboss/logging/BasicLogger.java";
+            HttpClient client = HttpClient.newBuilder()
+                    .followRedirects(HttpClient.Redirect.NORMAL)
+                    .connectTimeout(Duration.ofSeconds(10))
+                    .build();
+            HttpRequest request = HttpRequest.newBuilder(new URI(url)).build();
+            HttpResponse<String> response = client.send(request, BodyHandlers.ofString(StandardCharsets.UTF_8));
+            if (response.statusCode() == 200) {
+                generateLogClass(response.body());
+            } else {
+                throw new Exception("Failed fetching " + url);
+            }
+        } else {
+            throw new Exception("Couldn't find JBoss Logging version in " + source);
+        }
+    }
+
+    private static void generateLogClass(String basicLogger) {
+        String quarkusLog = basicLogger
+                .replaceFirst("(?s).*?package org.jboss.logging;", PACKAGE_AND_IMPORT)
+                .replaceFirst("(?s)/\\*\\*.*?public interface BasicLogger", CLASS_HEADER)
+                .replaceAll("void", "public static void")
+                .replaceAll("boolean", "public static boolean")
+                .replaceAll("\\);", LOG_METHOD_BODY)
+                .replaceFirst("}\\s*$", FAIL_METHOD + "}\n");
+
+        System.out.println(quarkusLog);
+    }
+}
diff --git a/core/runtime/src/test/java/io/quarkus/logging/LoggingApiCompletenessTest.java b/core/runtime/src/test/java/io/quarkus/logging/LoggingApiCompletenessTest.java
new file mode 100644
index 0000000000000..d4cf29662b0e5
--- /dev/null
+++ b/core/runtime/src/test/java/io/quarkus/logging/LoggingApiCompletenessTest.java
@@ -0,0 +1,73 @@
+package io.quarkus.logging;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+
+import org.jboss.logging.BasicLogger;
+import org.junit.jupiter.api.Test;
+
+public class LoggingApiCompletenessTest {
+    @Test
+    public void compareWithJbossLogging() {
+        Method[] jbossLoggingMethods = BasicLogger.class.getDeclaredMethods();
+        Method[] quarkusLogMethods = Arrays.stream(Log.class.getDeclaredMethods())
+                .filter(Predicate.not(LoggingApiCompletenessTest::isPrivateStaticFail))
+                .toArray(Method[]::new);
+
+        List<String> mismatches = new ArrayList<>();
+
+        for (Method jbossLoggingMethod : jbossLoggingMethods) {
+            boolean match = false;
+            for (Method quarkusLogMethod : quarkusLogMethods) {
+                if (areEquivalent(jbossLoggingMethod, quarkusLogMethod)) {
+                    match = true;
+                    break;
+                }
+            }
+
+            if (!match) {
+                mismatches.add("JBoss Logging method [" + jbossLoggingMethod
+                        + "] doesn't have an equivalent in " + Log.class.getName());
+            }
+        }
+
+        for (Method quarkusLogMethod : quarkusLogMethods) {
+            boolean match = false;
+            for (Method jbossLoggingMethod : jbossLoggingMethods) {
+                if (areEquivalent(jbossLoggingMethod, quarkusLogMethod)) {
+                    match = true;
+                    break;
+                }
+            }
+
+            if (!match) {
+                mismatches.add(Log.class.getName() + " method [" + quarkusLogMethod
+                        + "] doesn't have an equivalent in JBoss Logging");
+            }
+        }
+
+        if (!mismatches.isEmpty()) {
+            mismatches.add(0, "Mismatch between JBoss Logging and " + Log.class.getName() + " detected, "
+                    + "use GenerateLog and GenerateAllLogUsages to regenerate the Log class and the integration test");
+            fail(String.join("\n- ", mismatches));
+        }
+    }
+
+    private static boolean isPrivateStaticFail(Method method) {
+        return Modifier.isPrivate(method.getModifiers())
+                && Modifier.isStatic(method.getModifiers())
+                && "fail".equals(method.getName());
+    }
+
+    private static boolean areEquivalent(Method jbossLoggingMethod, Method quarkusLogMethod) {
+        return jbossLoggingMethod.getName().equals(quarkusLogMethod.getName())
+                && jbossLoggingMethod.getReturnType().equals(quarkusLogMethod.getReturnType())
+                && Arrays.equals(jbossLoggingMethod.getParameterTypes(), quarkusLogMethod.getParameterTypes());
+    }
+}
diff --git a/docs/src/main/asciidoc/logging.adoc b/docs/src/main/asciidoc/logging.adoc
index 398ca51b2bac7..7a6c2aae20284 100644
--- a/docs/src/main/asciidoc/logging.adoc
+++ b/docs/src/main/asciidoc/logging.adoc
@@ -9,7 +9,7 @@ include::./attributes.adoc[]
 
 This guide explains logging and how to configure it.
 
-Internally, Quarkus uses JBoss Log Manager and the JBoss Logging facade. +
+Internally, Quarkus uses JBoss Log Manager and the JBoss Logging facade.
 You can use the JBoss Logging facade inside your code as it's already provided,
 or any of the supported Logging API listed in the next chapter as Quarkus will send them to JBoss Log Manager.
 
@@ -51,6 +51,34 @@ public class ExampleResource {
 
 NOTE: If you use JBoss Logging but one of your libraries uses a different logging API, you may need to configure a link:#logging-adapters[Logging Adapter].
 
+=== Logging with Panache
+
+Instead of declaring a `Logger` field, you can use the simplified logging API:
+
+[source,java]
+----
+package com.example;
+
+import io.quarkus.logging.Log; // <1>
+
+class MyService { // <2>
+    public void doSomething() {
+        Log.info("Simple!"); // <3>
+    }
+}
+----
+<1> The `io.quarkus.logging.Log` class mirrors the JBoss Logging API, except all methods are `static`.
+<2> Note that the class doesn't declare a logger field.
+This is because during application build, a `private static final org.jboss.logging.Logger` field is created automatically, in each class that uses the `Log` API.
+The fully qualified name of the class that calls the `Log` methods is used as a logger name.
+In this example, the logger name would be `com.example.MyService`.
+<3> Finally, during application build, all calls to `Log` methods are rewritten to regular JBoss Logging calls on the logger field.
+
+WARNING: Only use the `Log` API in application classes, not in external dependencies.
+`Log` method calls that are not processed by Quarkus at build time will throw an exception.
+
+=== Injecting a Logger
+
 You can also inject a configured `org.jboss.logging.Logger` instance in your beans and resource classes.
 
 [source, java]
diff --git a/independent-projects/arc/pom.xml b/independent-projects/arc/pom.xml
index 4ac3b17b0ea46..af87d4d60866d 100644
--- a/independent-projects/arc/pom.xml
+++ b/independent-projects/arc/pom.xml
@@ -38,7 +38,7 @@
         <!-- Versions -->
         <version.cdi>2.0.2</version.cdi>
         <version.jta>1.3.3</version.jta>
-        <version.jandex>2.3.1.Final</version.jandex>
+        <version.jandex>2.4.0.Final</version.jandex>
         <version.junit5>5.7.2</version.junit5>
         <version.maven>3.8.1</version.maven>
         <version.assertj>3.20.2</version.assertj>
diff --git a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanArchives.java b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanArchives.java
index 3ea6daa02c1d2..6e7299cef1daa 100644
--- a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanArchives.java
+++ b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanArchives.java
@@ -32,6 +32,7 @@
 import org.jboss.jandex.Index;
 import org.jboss.jandex.IndexView;
 import org.jboss.jandex.Indexer;
+import org.jboss.jandex.ModuleInfo;
 import org.jboss.jandex.Type;
 import org.jboss.logging.Logger;
 
@@ -177,6 +178,21 @@ public Collection<AnnotationInstance> getAnnotationsWithRepeatable(DotName annot
             return this.index.getAnnotationsWithRepeatable(annotationName, index);
         }
 
+        @Override
+        public Collection<ModuleInfo> getKnownModules() {
+            return this.index.getKnownModules();
+        }
+
+        @Override
+        public ModuleInfo getModuleByName(DotName moduleName) {
+            return this.index.getModuleByName(moduleName);
+        }
+
+        @Override
+        public Collection<ClassInfo> getKnownUsers(DotName className) {
+            return this.index.getKnownUsers(className);
+        }
+
         private void getAllKnownSubClasses(DotName className, Set<ClassInfo> allKnown, Set<DotName> processedClasses) {
             final Set<DotName> subClassesToProcess = new HashSet<DotName>();
             subClassesToProcess.add(className);
diff --git a/independent-projects/resteasy-reactive/pom.xml b/independent-projects/resteasy-reactive/pom.xml
index f43d16df34780..97550a20502e9 100644
--- a/independent-projects/resteasy-reactive/pom.xml
+++ b/independent-projects/resteasy-reactive/pom.xml
@@ -37,7 +37,7 @@
         <maven.compiler.release>11</maven.compiler.release>
         <!-- Versions -->
         <version.cdi>2.0.2</version.cdi>
-        <version.jandex>2.3.1.Final</version.jandex>
+        <version.jandex>2.4.0.Final</version.jandex>
         <version.junit5>5.7.2</version.junit5>
         <version.maven>3.8.1</version.maven>
         <version.assertj>3.20.2</version.assertj>
diff --git a/independent-projects/tools/pom.xml b/independent-projects/tools/pom.xml
index 5b5fc826e20ef..69b9bf3c9181f 100644
--- a/independent-projects/tools/pom.xml
+++ b/independent-projects/tools/pom.xml
@@ -54,7 +54,7 @@
         <maven-model-helper.version>18</maven-model-helper.version>
         <commons-io.version>2.11.0</commons-io.version>
         <smallrye-common.version>1.6.0</smallrye-common.version>
-        <jandex-maven-plugin.version>1.1.1</jandex-maven-plugin.version>
+        <jandex-maven-plugin.version>1.2.0</jandex-maven-plugin.version>
     </properties>
     <modules>
         <module>artifact-api</module>
diff --git a/integration-tests/logging-panache/pom.xml b/integration-tests/logging-panache/pom.xml
new file mode 100644
index 0000000000000..e15484e26d3e5
--- /dev/null
+++ b/integration-tests/logging-panache/pom.xml
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <artifactId>quarkus-integration-tests-parent</artifactId>
+        <groupId>io.quarkus</groupId>
+        <version>999-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>quarkus-integration-test-logging-panache</artifactId>
+
+    <name>Quarkus - Integration Tests - Logging with Panache</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-arc-deployment</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-resteasy</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-junit5-internal</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.rest-assured</groupId>
+            <artifactId>rest-assured</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <!-- Minimal test dependencies to *-deployment artifacts for consistent build order -->
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-resteasy-deployment</artifactId>
+            <version>${project.version}</version>
+            <type>pom</type>
+            <scope>test</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>*</groupId>
+                    <artifactId>*</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/integration-tests/logging-panache/src/test/java/io/quarkus/logging/GenerateAllLogUsages.java b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/GenerateAllLogUsages.java
new file mode 100644
index 0000000000000..4341ee3c653da
--- /dev/null
+++ b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/GenerateAllLogUsages.java
@@ -0,0 +1,62 @@
+package io.quarkus.logging;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Parameter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+import org.jboss.logging.Logger;
+
+public class GenerateAllLogUsages {
+    public static void main(String[] args) {
+        println("package io.quarkus.logging;");
+        println("");
+        println("// generated by GenerateAllLogUsages, don't update manually");
+        println("public class GeneratedBean {");
+        println("    public void testLogging() {");
+        Arrays.stream(Log.class.getDeclaredMethods())
+                .filter(method -> Modifier.isPublic(method.getModifiers()))
+                .sorted(Comparator.comparing(Method::getName).thenComparingInt(Method::getParameterCount))
+                .forEach(method -> {
+                    Parameter[] parameters = method.getParameters();
+                    String[] arguments = new String[method.getParameterCount()];
+                    for (int i = 0; i < parameters.length; i++) {
+                        Parameter parameter = parameters[i];
+                        String argument;
+                        if (parameter.getType() == Object.class && "message".equals(parameter.getName())) {
+                            argument = "\"foobar\"";
+                        } else if (parameter.getType() == Object.class
+                                && (parameter.getName().startsWith("param") || parameter.getName().startsWith("arg"))) {
+                            argument = "new Object()";
+                        } else if (parameter.getType() == Object[].class && "params".equals(parameter.getName())) {
+                            argument = "new Object[] {}";
+                        } else if (parameter.getType() == String.class && "loggerFqcn".equals(parameter.getName())) {
+                            argument = "\"io.quarkus.logging.GeneratedBean\"";
+                        } else if (parameter.getType() == String.class && "format".equals(parameter.getName())) {
+                            argument = "\"foobar\"";
+                        } else if (parameter.getType() == int.class) {
+                            argument = "13";
+                        } else if (parameter.getType() == long.class) {
+                            argument = "42L";
+                        } else if (parameter.getType() == Throwable.class) {
+                            argument = "new NoStackTraceTestException()";
+                        } else if (parameter.getType() == Logger.Level.class) {
+                            argument = "org.jboss.logging.Logger.Level.INFO";
+                        } else {
+                            throw new RuntimeException("Couldn't generate argument value for parameter " + i + " of type "
+                                    + method.getParameterTypes()[i] + ": " + method);
+                        }
+                        arguments[i] = argument;
+                    }
+
+                    println("        Log." + method.getName() + "(" + String.join(", ", arguments) + ");");
+                });
+        println("    }");
+        println("}");
+    }
+
+    private static void println(String string) {
+        System.out.println(string);
+    }
+}
diff --git a/integration-tests/logging-panache/src/test/java/io/quarkus/logging/GeneratedBean.java b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/GeneratedBean.java
new file mode 100644
index 0000000000000..7dea885e5c4c9
--- /dev/null
+++ b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/GeneratedBean.java
@@ -0,0 +1,219 @@
+package io.quarkus.logging;
+
+// generated by GenerateAllLogUsages, don't update manually
+public class GeneratedBean {
+    public void testLogging() {
+        Log.debug("foobar");
+        Log.debug("foobar", new NoStackTraceTestException());
+        Log.debug("io.quarkus.logging.GeneratedBean", "foobar", new NoStackTraceTestException());
+        Log.debug("io.quarkus.logging.GeneratedBean", "foobar", new Object[] {}, new NoStackTraceTestException());
+        Log.debugf("foobar", new Object[] {});
+        Log.debugf("foobar", new Object());
+        Log.debugf("foobar", 13);
+        Log.debugf("foobar", 42L);
+        Log.debugf("foobar", 13, new Object());
+        Log.debugf("foobar", 13, 13);
+        Log.debugf(new NoStackTraceTestException(), "foobar", 13);
+        Log.debugf(new NoStackTraceTestException(), "foobar", new Object[] {});
+        Log.debugf("foobar", new Object(), new Object());
+        Log.debugf(new NoStackTraceTestException(), "foobar", new Object());
+        Log.debugf(new NoStackTraceTestException(), "foobar", 42L);
+        Log.debugf("foobar", 42L, new Object());
+        Log.debugf("foobar", 42L, 42L);
+        Log.debugf(new NoStackTraceTestException(), "foobar", 42L, new Object());
+        Log.debugf(new NoStackTraceTestException(), "foobar", 42L, 42L);
+        Log.debugf("foobar", 13, 13, new Object());
+        Log.debugf("foobar", 13, 13, 13);
+        Log.debugf(new NoStackTraceTestException(), "foobar", 13, new Object());
+        Log.debugf(new NoStackTraceTestException(), "foobar", 13, 13);
+        Log.debugf("foobar", 13, new Object(), new Object());
+        Log.debugf("foobar", new Object(), new Object(), new Object());
+        Log.debugf(new NoStackTraceTestException(), "foobar", new Object(), new Object());
+        Log.debugf("foobar", 42L, 42L, 42L);
+        Log.debugf("foobar", 42L, 42L, new Object());
+        Log.debugf("foobar", 42L, new Object(), new Object());
+        Log.debugf(new NoStackTraceTestException(), "foobar", 42L, 42L, 42L);
+        Log.debugf(new NoStackTraceTestException(), "foobar", 42L, 42L, new Object());
+        Log.debugf(new NoStackTraceTestException(), "foobar", 42L, new Object(), new Object());
+        Log.debugf(new NoStackTraceTestException(), "foobar", new Object(), new Object(), new Object());
+        Log.debugf(new NoStackTraceTestException(), "foobar", 13, new Object(), new Object());
+        Log.debugf(new NoStackTraceTestException(), "foobar", 13, 13, new Object());
+        Log.debugf(new NoStackTraceTestException(), "foobar", 13, 13, 13);
+        Log.debugv("foobar", new Object[] {});
+        Log.debugv("foobar", new Object());
+        Log.debugv(new NoStackTraceTestException(), "foobar", new Object[] {});
+        Log.debugv("foobar", new Object(), new Object());
+        Log.debugv(new NoStackTraceTestException(), "foobar", new Object());
+        Log.debugv("foobar", new Object(), new Object(), new Object());
+        Log.debugv(new NoStackTraceTestException(), "foobar", new Object(), new Object());
+        Log.debugv(new NoStackTraceTestException(), "foobar", new Object(), new Object(), new Object());
+        Log.error("foobar");
+        Log.error("foobar", new NoStackTraceTestException());
+        Log.error("io.quarkus.logging.GeneratedBean", "foobar", new NoStackTraceTestException());
+        Log.error("io.quarkus.logging.GeneratedBean", "foobar", new Object[] {}, new NoStackTraceTestException());
+        Log.errorf("foobar", new Object[] {});
+        Log.errorf("foobar", new Object());
+        Log.errorf("foobar", new Object(), new Object());
+        Log.errorf(new NoStackTraceTestException(), "foobar", new Object());
+        Log.errorf(new NoStackTraceTestException(), "foobar", new Object[] {});
+        Log.errorf(new NoStackTraceTestException(), "foobar", new Object(), new Object());
+        Log.errorf("foobar", new Object(), new Object(), new Object());
+        Log.errorf(new NoStackTraceTestException(), "foobar", new Object(), new Object(), new Object());
+        Log.errorv("foobar", new Object[] {});
+        Log.errorv("foobar", new Object());
+        Log.errorv(new NoStackTraceTestException(), "foobar", new Object());
+        Log.errorv("foobar", new Object(), new Object());
+        Log.errorv(new NoStackTraceTestException(), "foobar", new Object[] {});
+        Log.errorv(new NoStackTraceTestException(), "foobar", new Object(), new Object());
+        Log.errorv("foobar", new Object(), new Object(), new Object());
+        Log.errorv(new NoStackTraceTestException(), "foobar", new Object(), new Object(), new Object());
+        Log.fatal("foobar");
+        Log.fatal("foobar", new NoStackTraceTestException());
+        Log.fatal("io.quarkus.logging.GeneratedBean", "foobar", new NoStackTraceTestException());
+        Log.fatal("io.quarkus.logging.GeneratedBean", "foobar", new Object[] {}, new NoStackTraceTestException());
+        Log.fatalf("foobar", new Object());
+        Log.fatalf("foobar", new Object[] {});
+        Log.fatalf(new NoStackTraceTestException(), "foobar", new Object[] {});
+        Log.fatalf(new NoStackTraceTestException(), "foobar", new Object());
+        Log.fatalf("foobar", new Object(), new Object());
+        Log.fatalf("foobar", new Object(), new Object(), new Object());
+        Log.fatalf(new NoStackTraceTestException(), "foobar", new Object(), new Object());
+        Log.fatalf(new NoStackTraceTestException(), "foobar", new Object(), new Object(), new Object());
+        Log.fatalv("foobar", new Object[] {});
+        Log.fatalv("foobar", new Object());
+        Log.fatalv(new NoStackTraceTestException(), "foobar", new Object[] {});
+        Log.fatalv(new NoStackTraceTestException(), "foobar", new Object());
+        Log.fatalv("foobar", new Object(), new Object());
+        Log.fatalv(new NoStackTraceTestException(), "foobar", new Object(), new Object());
+        Log.fatalv("foobar", new Object(), new Object(), new Object());
+        Log.fatalv(new NoStackTraceTestException(), "foobar", new Object(), new Object(), new Object());
+        Log.info("foobar");
+        Log.info("foobar", new NoStackTraceTestException());
+        Log.info("io.quarkus.logging.GeneratedBean", "foobar", new NoStackTraceTestException());
+        Log.info("io.quarkus.logging.GeneratedBean", "foobar", new Object[] {}, new NoStackTraceTestException());
+        Log.infof("foobar", new Object[] {});
+        Log.infof("foobar", new Object());
+        Log.infof(new NoStackTraceTestException(), "foobar", new Object[] {});
+        Log.infof(new NoStackTraceTestException(), "foobar", new Object());
+        Log.infof("foobar", new Object(), new Object());
+        Log.infof(new NoStackTraceTestException(), "foobar", new Object(), new Object());
+        Log.infof("foobar", new Object(), new Object(), new Object());
+        Log.infof(new NoStackTraceTestException(), "foobar", new Object(), new Object(), new Object());
+        Log.infov("foobar", new Object[] {});
+        Log.infov("foobar", new Object());
+        Log.infov(new NoStackTraceTestException(), "foobar", new Object[] {});
+        Log.infov(new NoStackTraceTestException(), "foobar", new Object());
+        Log.infov("foobar", new Object(), new Object());
+        Log.infov("foobar", new Object(), new Object(), new Object());
+        Log.infov(new NoStackTraceTestException(), "foobar", new Object(), new Object());
+        Log.infov(new NoStackTraceTestException(), "foobar", new Object(), new Object(), new Object());
+        Log.isDebugEnabled();
+        Log.isEnabled(org.jboss.logging.Logger.Level.INFO);
+        Log.isInfoEnabled();
+        Log.isTraceEnabled();
+        Log.log(org.jboss.logging.Logger.Level.INFO, "foobar");
+        Log.log(org.jboss.logging.Logger.Level.INFO, "foobar", new NoStackTraceTestException());
+        Log.log(org.jboss.logging.Logger.Level.INFO, "io.quarkus.logging.GeneratedBean", "foobar",
+                new NoStackTraceTestException());
+        Log.log("io.quarkus.logging.GeneratedBean", org.jboss.logging.Logger.Level.INFO, "foobar", new Object[] {},
+                new NoStackTraceTestException());
+        Log.logf(org.jboss.logging.Logger.Level.INFO, "foobar", new Object());
+        Log.logf(org.jboss.logging.Logger.Level.INFO, "foobar", new Object[] {});
+        Log.logf(org.jboss.logging.Logger.Level.INFO, "foobar", new Object(), new Object());
+        Log.logf(org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(), "foobar", new Object[] {});
+        Log.logf(org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(), "foobar", new Object());
+        Log.logf(org.jboss.logging.Logger.Level.INFO, "foobar", new Object(), new Object(), new Object());
+        Log.logf("io.quarkus.logging.GeneratedBean", org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(),
+                "foobar", new Object());
+        Log.logf("io.quarkus.logging.GeneratedBean", org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(),
+                "foobar", new Object[] {});
+        Log.logf(org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(), "foobar", new Object(), new Object());
+        Log.logf("io.quarkus.logging.GeneratedBean", org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(),
+                "foobar", new Object(), new Object());
+        Log.logf(org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(), "foobar", new Object(), new Object(),
+                new Object());
+        Log.logf("io.quarkus.logging.GeneratedBean", org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(),
+                "foobar", new Object(), new Object(), new Object());
+        Log.logv(org.jboss.logging.Logger.Level.INFO, "foobar", new Object());
+        Log.logv(org.jboss.logging.Logger.Level.INFO, "foobar", new Object[] {});
+        Log.logv(org.jboss.logging.Logger.Level.INFO, "foobar", new Object(), new Object());
+        Log.logv(org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(), "foobar", new Object());
+        Log.logv(org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(), "foobar", new Object[] {});
+        Log.logv(org.jboss.logging.Logger.Level.INFO, "foobar", new Object(), new Object(), new Object());
+        Log.logv("io.quarkus.logging.GeneratedBean", org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(),
+                "foobar", new Object[] {});
+        Log.logv("io.quarkus.logging.GeneratedBean", org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(),
+                "foobar", new Object());
+        Log.logv(org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(), "foobar", new Object(), new Object());
+        Log.logv(org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(), "foobar", new Object(), new Object(),
+                new Object());
+        Log.logv("io.quarkus.logging.GeneratedBean", org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(),
+                "foobar", new Object(), new Object());
+        Log.logv("io.quarkus.logging.GeneratedBean", org.jboss.logging.Logger.Level.INFO, new NoStackTraceTestException(),
+                "foobar", new Object(), new Object(), new Object());
+        Log.trace("foobar");
+        Log.trace("foobar", new NoStackTraceTestException());
+        Log.trace("io.quarkus.logging.GeneratedBean", "foobar", new NoStackTraceTestException());
+        Log.trace("io.quarkus.logging.GeneratedBean", "foobar", new Object[] {}, new NoStackTraceTestException());
+        Log.tracef("foobar", new Object[] {});
+        Log.tracef("foobar", new Object());
+        Log.tracef("foobar", 13);
+        Log.tracef("foobar", 42L);
+        Log.tracef(new NoStackTraceTestException(), "foobar", 42L);
+        Log.tracef("foobar", new Object(), new Object());
+        Log.tracef(new NoStackTraceTestException(), "foobar", new Object[] {});
+        Log.tracef(new NoStackTraceTestException(), "foobar", new Object());
+        Log.tracef("foobar", 13, new Object());
+        Log.tracef(new NoStackTraceTestException(), "foobar", 13);
+        Log.tracef("foobar", 13, 13);
+        Log.tracef("foobar", 42L, 42L);
+        Log.tracef("foobar", 42L, new Object());
+        Log.tracef(new NoStackTraceTestException(), "foobar", 42L, new Object());
+        Log.tracef(new NoStackTraceTestException(), "foobar", 42L, 42L);
+        Log.tracef("foobar", 42L, new Object(), new Object());
+        Log.tracef("foobar", new Object(), new Object(), new Object());
+        Log.tracef(new NoStackTraceTestException(), "foobar", new Object(), new Object());
+        Log.tracef("foobar", 13, new Object(), new Object());
+        Log.tracef(new NoStackTraceTestException(), "foobar", 13, 13);
+        Log.tracef("foobar", 13, 13, 13);
+        Log.tracef("foobar", 13, 13, new Object());
+        Log.tracef("foobar", 42L, 42L, 42L);
+        Log.tracef("foobar", 42L, 42L, new Object());
+        Log.tracef(new NoStackTraceTestException(), "foobar", 13, new Object());
+        Log.tracef(new NoStackTraceTestException(), "foobar", 42L, 42L, 42L);
+        Log.tracef(new NoStackTraceTestException(), "foobar", 42L, 42L, new Object());
+        Log.tracef(new NoStackTraceTestException(), "foobar", 42L, new Object(), new Object());
+        Log.tracef(new NoStackTraceTestException(), "foobar", new Object(), new Object(), new Object());
+        Log.tracef(new NoStackTraceTestException(), "foobar", 13, new Object(), new Object());
+        Log.tracef(new NoStackTraceTestException(), "foobar", 13, 13, 13);
+        Log.tracef(new NoStackTraceTestException(), "foobar", 13, 13, new Object());
+        Log.tracev("foobar", new Object());
+        Log.tracev("foobar", new Object[] {});
+        Log.tracev("foobar", new Object(), new Object());
+        Log.tracev(new NoStackTraceTestException(), "foobar", new Object());
+        Log.tracev(new NoStackTraceTestException(), "foobar", new Object[] {});
+        Log.tracev(new NoStackTraceTestException(), "foobar", new Object(), new Object());
+        Log.tracev("foobar", new Object(), new Object(), new Object());
+        Log.tracev(new NoStackTraceTestException(), "foobar", new Object(), new Object(), new Object());
+        Log.warn("foobar");
+        Log.warn("foobar", new NoStackTraceTestException());
+        Log.warn("io.quarkus.logging.GeneratedBean", "foobar", new NoStackTraceTestException());
+        Log.warn("io.quarkus.logging.GeneratedBean", "foobar", new Object[] {}, new NoStackTraceTestException());
+        Log.warnf("foobar", new Object[] {});
+        Log.warnf("foobar", new Object());
+        Log.warnf(new NoStackTraceTestException(), "foobar", new Object());
+        Log.warnf("foobar", new Object(), new Object());
+        Log.warnf(new NoStackTraceTestException(), "foobar", new Object[] {});
+        Log.warnf(new NoStackTraceTestException(), "foobar", new Object(), new Object());
+        Log.warnf("foobar", new Object(), new Object(), new Object());
+        Log.warnf(new NoStackTraceTestException(), "foobar", new Object(), new Object(), new Object());
+        Log.warnv("foobar", new Object[] {});
+        Log.warnv("foobar", new Object());
+        Log.warnv("foobar", new Object(), new Object());
+        Log.warnv(new NoStackTraceTestException(), "foobar", new Object[] {});
+        Log.warnv(new NoStackTraceTestException(), "foobar", new Object());
+        Log.warnv(new NoStackTraceTestException(), "foobar", new Object(), new Object());
+        Log.warnv("foobar", new Object(), new Object(), new Object());
+        Log.warnv(new NoStackTraceTestException(), "foobar", new Object(), new Object(), new Object());
+    }
+}
diff --git a/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingBean.java b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingBean.java
new file mode 100644
index 0000000000000..d137a47414e51
--- /dev/null
+++ b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingBean.java
@@ -0,0 +1,41 @@
+package io.quarkus.logging;
+
+import javax.annotation.PostConstruct;
+import javax.inject.Singleton;
+
+@Singleton
+public class LoggingBean {
+    // not final to prevent constant inlining
+    private static String msg = "Heya!";
+
+    static {
+        Log.info(msg);
+    }
+
+    @PostConstruct
+    public void setup() {
+        Log.tracef("%s created", LoggingBean.class.getSimpleName());
+    }
+
+    public void doSomething() {
+        if (Log.isDebugEnabled()) {
+            Log.debug("starting massive computation");
+        }
+
+        Log.debugf("one: %d", 42);
+        Log.tracef("two: %d | %d", 42, 13);
+        Log.debugf("three: %d | %d | %d", 42, 13, 1);
+
+        Log.debugv("one: {0}", "foo");
+        Log.infov("two: {0} | {1}", "foo", "bar");
+        Log.warnv("three: {0} | {1} | {2}", "foo", "bar", "baz");
+        Log.errorv("four: {0} | {1} | {2} | {3}", "foo", "bar", "baz", "quux");
+
+        Exception error = new NoStackTraceTestException();
+
+        Log.warnv(error, "{0} | {1} | {2} | {3}", "foo", "bar", "baz", "quux");
+
+        Log.error("Hello Error", error);
+    }
+
+}
diff --git a/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingEndpoint.java b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingEndpoint.java
new file mode 100644
index 0000000000000..8fe56a9d405dc
--- /dev/null
+++ b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingEndpoint.java
@@ -0,0 +1,13 @@
+package io.quarkus.logging;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+
+@Path("/logging")
+public class LoggingEndpoint {
+    @GET
+    public String hello() {
+        Log.info("hello");
+        return "hello";
+    }
+}
diff --git a/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingWithPanacheDevModeTest.java b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingWithPanacheDevModeTest.java
new file mode 100644
index 0000000000000..c382c1c259d28
--- /dev/null
+++ b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingWithPanacheDevModeTest.java
@@ -0,0 +1,47 @@
+package io.quarkus.logging;
+
+import static io.restassured.RestAssured.when;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.Matchers.is;
+
+import java.util.List;
+import java.util.logging.Formatter;
+import java.util.stream.Collectors;
+
+import org.jboss.logmanager.formatters.PatternFormatter;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.test.QuarkusDevModeTest;
+
+public class LoggingWithPanacheDevModeTest {
+    @RegisterExtension
+    static final QuarkusDevModeTest TEST = new QuarkusDevModeTest()
+            .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class).addClasses(LoggingEndpoint.class))
+            .setLogRecordPredicate(record -> "io.quarkus.logging.LoggingEndpoint".equals(record.getLoggerName()));
+
+    @Test
+    public void testRepositoryIsReloaded() {
+        Formatter formatter = new PatternFormatter("[%p] %m");
+
+        {
+            when().get("/logging").then().body(is("hello"));
+
+            List<String> lines = TEST.getLogRecords().stream().map(formatter::format).collect(Collectors.toList());
+            assertThat(lines).containsExactly("[INFO] hello");
+            TEST.clearLogRecords();
+        }
+
+        TEST.modifySourceFile("LoggingEndpoint.java", s -> s.replace("hello", "hi"));
+
+        {
+            when().get("/logging").then().body(is("hi"));
+
+            List<String> lines = TEST.getLogRecords().stream().map(formatter::format).collect(Collectors.toList());
+            assertThat(lines).containsExactly("[INFO] hi");
+            TEST.clearLogRecords();
+        }
+    }
+}
diff --git a/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingWithPanacheGeneratedTest.java b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingWithPanacheGeneratedTest.java
new file mode 100644
index 0000000000000..044257cf5fabc
--- /dev/null
+++ b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingWithPanacheGeneratedTest.java
@@ -0,0 +1,24 @@
+package io.quarkus.logging;
+
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.test.QuarkusUnitTest;
+
+public class LoggingWithPanacheGeneratedTest {
+    @RegisterExtension
+    static final QuarkusUnitTest test = new QuarkusUnitTest()
+            .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
+                    .addClasses(GeneratedBean.class, NoStackTraceTestException.class))
+            .overrideConfigKey("quarkus.log.category.\"io.quarkus.logging\".min-level", "TRACE")
+            .overrideConfigKey("quarkus.log.category.\"io.quarkus.logging\".level", "TRACE");
+
+    @Test
+    public void test() {
+        new GeneratedBean().testLogging();
+        // no asserts, this test only verifies that all Log methods can be successfully invoked
+        // (in other words, that the bytecode transformation isn't horribly broken)
+    }
+}
diff --git a/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingWithPanacheTest.java b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingWithPanacheTest.java
new file mode 100644
index 0000000000000..52b8d433aa00c
--- /dev/null
+++ b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/LoggingWithPanacheTest.java
@@ -0,0 +1,53 @@
+package io.quarkus.logging;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.List;
+import java.util.logging.Formatter;
+import java.util.stream.Collectors;
+
+import javax.inject.Inject;
+
+import org.jboss.logmanager.formatters.PatternFormatter;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.test.QuarkusUnitTest;
+
+public class LoggingWithPanacheTest {
+    @RegisterExtension
+    static final QuarkusUnitTest test = new QuarkusUnitTest()
+            .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
+                    .addClasses(LoggingBean.class, NoStackTraceTestException.class))
+            .overrideConfigKey("quarkus.log.category.\"io.quarkus.logging\".min-level", "TRACE")
+            .overrideConfigKey("quarkus.log.category.\"io.quarkus.logging\".level", "TRACE")
+            .setLogRecordPredicate(record -> "io.quarkus.logging.LoggingBean".equals(record.getLoggerName()))
+            .assertLogRecords(records -> {
+                Formatter formatter = new PatternFormatter("[%p] %m");
+                List<String> lines = records.stream().map(formatter::format).map(String::trim).collect(Collectors.toList());
+
+                assertThat(lines).containsExactly(
+                        "[INFO] Heya!",
+                        "[TRACE] LoggingBean created",
+                        "[DEBUG] starting massive computation",
+                        "[DEBUG] one: 42",
+                        "[TRACE] two: 42 | 13",
+                        "[DEBUG] three: 42 | 13 | 1",
+                        "[DEBUG] one: foo",
+                        "[INFO] two: foo | bar",
+                        "[WARN] three: foo | bar | baz",
+                        "[ERROR] four: foo | bar | baz | quux",
+                        "[WARN] foo | bar | baz | quux: io.quarkus.logging.NoStackTraceTestException",
+                        "[ERROR] Hello Error: io.quarkus.logging.NoStackTraceTestException");
+            });
+
+    @Inject
+    LoggingBean bean;
+
+    @Test
+    public void test() {
+        bean.doSomething();
+    }
+}
diff --git a/integration-tests/logging-panache/src/test/java/io/quarkus/logging/NoStackTraceTestException.java b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/NoStackTraceTestException.java
new file mode 100644
index 0000000000000..9a3cf887ea1e9
--- /dev/null
+++ b/integration-tests/logging-panache/src/test/java/io/quarkus/logging/NoStackTraceTestException.java
@@ -0,0 +1,8 @@
+package io.quarkus.logging;
+
+public class NoStackTraceTestException extends RuntimeException {
+    @Override
+    public synchronized Throwable fillInStackTrace() {
+        return this;
+    }
+}
diff --git a/integration-tests/pom.xml b/integration-tests/pom.xml
index fb683ab4e1782..c7cadd1fe67ba 100644
--- a/integration-tests/pom.xml
+++ b/integration-tests/pom.xml
@@ -273,6 +273,7 @@
                 <module>native-config-profile</module>
                 <module>logging-min-level-unset</module>
                 <module>logging-min-level-set</module>
+                <module>logging-panache</module>
                 <module>redis-devservices</module>
 
                 <!-- gRPC tests -->
diff --git a/test-framework/junit5-internal/src/main/java/io/quarkus/test/QuarkusDevModeTest.java b/test-framework/junit5-internal/src/main/java/io/quarkus/test/QuarkusDevModeTest.java
index d7c8ddabf9f88..b038d6f9b9c1c 100644
--- a/test-framework/junit5-internal/src/main/java/io/quarkus/test/QuarkusDevModeTest.java
+++ b/test-framework/junit5-internal/src/main/java/io/quarkus/test/QuarkusDevModeTest.java
@@ -159,6 +159,10 @@ public List<LogRecord> getLogRecords() {
         return inMemoryLogHandler.records;
     }
 
+    public void clearLogRecords() {
+        inMemoryLogHandler.clearRecords();
+    }
+
     public QuarkusDevModeTest setBuildSystemProperty(String name, String value) {
         buildSystemProperties.put(name, value);
         return this;