diff --git a/src/main/java/org/openrewrite/java/logging/jboss/LoggerLevelArgumentToMethod.java b/src/main/java/org/openrewrite/java/logging/jboss/LoggerLevelArgumentToMethod.java
new file mode 100644
index 00000000..9d614429
--- /dev/null
+++ b/src/main/java/org/openrewrite/java/logging/jboss/LoggerLevelArgumentToMethod.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.java.logging.jboss;
+
+import org.jspecify.annotations.Nullable;
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.Preconditions;
+import org.openrewrite.Recipe;
+import org.openrewrite.TreeVisitor;
+import org.openrewrite.internal.ListUtils;
+import org.openrewrite.java.JavaIsoVisitor;
+import org.openrewrite.java.MethodMatcher;
+import org.openrewrite.java.search.UsesMethod;
+import org.openrewrite.java.search.UsesType;
+import org.openrewrite.java.tree.Expression;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaType;
+import org.openrewrite.java.tree.TypeUtils;
+
+import java.util.List;
+
+import static java.util.Objects.requireNonNull;
+
+public class LoggerLevelArgumentToMethod extends Recipe {
+    private static final MethodMatcher LOG_MATCHER = new MethodMatcher("org.jboss.logging.Logger log(*,*,..)", true);
+    private static final MethodMatcher LOGF_MATCHER = new MethodMatcher("org.jboss.logging.Logger logf(*,*,..)", true);
+    private static final MethodMatcher LOGV_MATCHER = new MethodMatcher("org.jboss.logging.Logger logv(*,*,..)", true);
+
+    @Override
+    public String getDisplayName() {
+        return "Replace JBoss Logging Level arguments with the corresponding eponymous level method calls";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Replace calls to `Logger.log(Level, ...)` with the corresponding eponymous level method calls. For example `Logger.log(Level.INFO, ...)` to `Logger.info(...)`.";
+    }
+
+    @Override
+    public TreeVisitor<?, ExecutionContext> getVisitor() {
+        TreeVisitor<?, ExecutionContext> preconditions = Preconditions.and(
+                new UsesType<>("org.jboss.logging.Logger", true),
+                new UsesType<>("org.jboss.logging.Logger.Level", true),
+                Preconditions.or(
+                        new UsesMethod<>(LOG_MATCHER),
+                        new UsesMethod<>(LOGF_MATCHER),
+                        new UsesMethod<>(LOGV_MATCHER)
+                )
+        );
+        return Preconditions.check(preconditions, new JavaIsoVisitor<ExecutionContext>() {
+                    @Override
+                    public J.MethodInvocation visitMethodInvocation(J.MethodInvocation mi, ExecutionContext ctx) {
+                        J.MethodInvocation m = super.visitMethodInvocation(mi, ctx);
+                        if (!(LOG_MATCHER.matches(m) || LOGF_MATCHER.matches(m) || LOGV_MATCHER.matches(m))) {
+                            return m;
+                        }
+                        List<Expression> args = m.getArguments();
+                        Expression firstArgument = args.get(0);
+                        Expression secondArgument = args.get(1);
+
+                        String logLevelName;
+                        List<Expression> updatedArguments;
+                        if (TypeUtils.isAssignableTo("org.jboss.logging.Logger.Level", firstArgument.getType())) {
+                            String suffix = "";
+                            if (LOGF_MATCHER.matches(m)) {
+                                suffix = "f";
+                            } else if (LOGV_MATCHER.matches(m)) {
+                                suffix = "v";
+                            }
+                            logLevelName = extractLogLevelName(firstArgument);
+                            if (logLevelName != null) {
+                                logLevelName += suffix;
+                            }
+                            updatedArguments = ListUtils.concat(
+                                    (Expression) secondArgument.withPrefix(secondArgument.getPrefix()
+                                            .withWhitespace(firstArgument.getPrefix().getWhitespace())),
+                                    args.subList(2, args.size()));
+                        } else if (TypeUtils.isAssignableTo("java.lang.String", firstArgument.getType()) &&
+                                TypeUtils.isAssignableTo("org.jboss.logging.Logger.Level", secondArgument.getType()) &&
+                                LOG_MATCHER.matches(m)) { // `logf(String, ..)` and `logv(String, ..)` don't have a logger.level() equivalent
+                            logLevelName = extractLogLevelName(secondArgument);
+                            updatedArguments = ListUtils.filter(args, it -> it != secondArgument);
+                        } else {
+                            return m;
+                        }
+
+                        // If we can't extract a log level name, we don't change the method call
+                        if (logLevelName == null) {
+                            return m;
+                        }
+
+                        JavaType.Method updatedMethodType = requireNonNull(m.getMethodType())
+                                .withParameterTypes(ListUtils.filter(m.getMethodType().getParameterTypes(), it -> !TypeUtils.isAssignableTo("org.jboss.logging.Logger.Level", it)))
+                                .withParameterNames(ListUtils.filter(m.getMethodType().getParameterNames(), it -> !"level".equals(it)))
+                                .withName(logLevelName.toLowerCase());
+
+                        return m
+                                .withArguments(updatedArguments)
+                                .withMethodType(updatedMethodType)
+                                .withName(m.getName().withSimpleName(logLevelName.toLowerCase()));
+                    }
+
+                    @Nullable
+                    String extractLogLevelName(Expression expression) {
+                        if (expression instanceof J.Identifier) {
+                            J.Identifier identifier = (J.Identifier) expression;
+                            if (identifier.getFieldType() != null &&
+                                    identifier.getFieldType().getOwner() instanceof JavaType.Class) {
+                                return identifier.getSimpleName();
+                            }
+                        } else if (expression instanceof J.FieldAccess) {
+                            return ((J.FieldAccess) expression).getSimpleName();
+                        }
+                        return null;
+                    }
+                }
+        );
+    }
+}
diff --git a/src/main/java/org/openrewrite/java/logging/jboss/package-info.java b/src/main/java/org/openrewrite/java/logging/jboss/package-info.java
new file mode 100644
index 00000000..0ff56098
--- /dev/null
+++ b/src/main/java/org/openrewrite/java/logging/jboss/package-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2024 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@NullMarked
+@NonNullFields
+package org.openrewrite.java.logging.jboss;
+
+import org.jspecify.annotations.NullMarked;
+import org.openrewrite.internal.lang.NonNullFields;
diff --git a/src/main/resources/META-INF/rewrite/examples.yml b/src/main/resources/META-INF/rewrite/examples.yml
index 6dae746a..cc42276d 100644
--- a/src/main/resources/META-INF/rewrite/examples.yml
+++ b/src/main/resources/META-INF/rewrite/examples.yml
@@ -359,6 +359,29 @@ examples:
     language: java
 ---
 type: specs.openrewrite.org/v1beta/example
+recipeName: org.openrewrite.java.logging.jboss.LoggerLevelArgumentToMethod
+examples:
+- description: ''
+  sources:
+  - before: |
+      import org.jboss.logging.Logger;
+
+      class Test {
+          void test(Logger logger, String msg) {
+              logger.log(Logger.Level.INFO, msg);
+          }
+      }
+    after: |
+      import org.jboss.logging.Logger;
+
+      class Test {
+          void test(Logger logger, String msg) {
+              logger.info(msg);
+          }
+      }
+    language: java
+---
+type: specs.openrewrite.org/v1beta/example
 recipeName: org.openrewrite.java.logging.jul.LoggerLevelArgumentToMethodRecipes
 examples:
 - description: ''
diff --git a/src/main/resources/META-INF/rewrite/jboss.yml b/src/main/resources/META-INF/rewrite/jboss.yml
index e3f0c929..dc750cce 100644
--- a/src/main/resources/META-INF/rewrite/jboss.yml
+++ b/src/main/resources/META-INF/rewrite/jboss.yml
@@ -24,5 +24,6 @@ tags:
   - logging
   - jboss
 recipeList:
+  - org.openrewrite.java.logging.jboss.LoggerLevelArgumentToMethod
   - org.openrewrite.java.logging.jboss.FormattedArgumentsToVMethodRecipes
   - org.openrewrite.java.logging.ArgumentArrayToVarargs
diff --git a/src/test/java/org/openrewrite/java/logging/jboss/LoggerLevelArgumentToMethodTest.java b/src/test/java/org/openrewrite/java/logging/jboss/LoggerLevelArgumentToMethodTest.java
new file mode 100644
index 00000000..0a5f83f0
--- /dev/null
+++ b/src/test/java/org/openrewrite/java/logging/jboss/LoggerLevelArgumentToMethodTest.java
@@ -0,0 +1,228 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.java.logging.jboss;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.openrewrite.DocumentExample;
+import org.openrewrite.test.RecipeSpec;
+import org.openrewrite.test.RewriteTest;
+
+import static org.openrewrite.java.Assertions.java;
+
+class LoggerLevelArgumentToMethodTest implements RewriteTest {
+
+    @Override
+    public void defaults(RecipeSpec spec) {
+        spec.recipe(new LoggerLevelArgumentToMethod());
+    }
+
+    @DocumentExample
+    @Test
+    void replaceLevelArguments() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              import org.jboss.logging.Logger;
+
+              class Test {
+                  void test(Logger logger, String msg) {
+                      logger.log(Logger.Level.INFO, msg);
+                  }
+              }
+              """,
+            """
+              import org.jboss.logging.Logger;
+
+              class Test {
+                  void test(Logger logger, String msg) {
+                      logger.info(msg);
+                  }
+              }
+              """
+          )
+        );
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"trace", "debug", "info", "warn", "error", "fatal"})
+    void replaceLevelArguments(String level) {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              import org.jboss.logging.Logger;
+
+              import static org.jboss.logging.Logger.Level.%1$S;
+
+              class Test {
+                  void test(Logger logger, Object msg, Throwable t, String fqcn) {
+                      logger.log(Logger.Level.%1$S, msg);
+                      logger.log(%1$S, msg);
+                      logger.log(Logger.Level.%1$S, msg, t);
+                      logger.log(Logger.Level.%1$S, fqcn, msg, t);
+                      logger.log(Logger.Level.%1$S, msg, new String[]{"msg"});
+                      logger.log(Logger.Level.%1$S, msg, new String[]{"msg"}, t);
+                      logger.log(fqcn, Logger.Level.%1$S, msg, new String[]{"msg"}, t);
+                  }
+              }
+              """.formatted(level),
+            """
+              import org.jboss.logging.Logger;
+
+              import static org.jboss.logging.Logger.Level.%1$S;
+
+              class Test {
+                  void test(Logger logger, Object msg, Throwable t, String fqcn) {
+                      logger.%1$s(msg);
+                      logger.%1$s(msg);
+                      logger.%1$s(msg, t);
+                      logger.%1$s(fqcn, msg, t);
+                      logger.%1$s(msg, new String[]{"msg"});
+                      logger.%1$s(msg, new String[]{"msg"}, t);
+                      logger.%1$s(fqcn, msg, new String[]{"msg"}, t);
+                  }
+              }
+              """.formatted(level)
+          )
+        );
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"trace", "debug", "info", "warn", "error", "fatal"})
+    void replaceLevelArgumentsFormatF(String level) {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              import org.jboss.logging.Logger;
+
+              import static org.jboss.logging.Logger.Level.%1$S;
+
+              class Test {
+                  void test(Logger logger, String msg, Throwable t, String fqcn, Object[] p) {
+                      logger.logf(Logger.Level.%1$S, msg, p[0]);
+                      logger.logf(Logger.Level.%1$S, msg, p[0], p[1]);
+                      logger.logf(Logger.Level.%1$S, msg, p[0], p[2], p[3]);
+                      logger.logf(Logger.Level.%1$S, msg, p[0], p[2], p[3], p[4]);
+
+                      logger.logf(Logger.Level.%1$S, t, msg, p[0]);
+                      logger.logf(Logger.Level.%1$S, t, msg, p[0], p[1]);
+                      logger.logf(Logger.Level.%1$S, t, msg, p[0], p[2], p[3]);
+                      logger.logf(Logger.Level.%1$S, t, msg, p[0], p[2], p[3], p[4]);
+
+                      logger.logf(fqcn, Logger.Level.%1$S, t, msg, p[0]);
+                  }
+              }
+              """.formatted(level),
+            """
+              import org.jboss.logging.Logger;
+
+              import static org.jboss.logging.Logger.Level.%1$S;
+
+              class Test {
+                  void test(Logger logger, String msg, Throwable t, String fqcn, Object[] p) {
+                      logger.%1$sf(msg, p[0]);
+                      logger.%1$sf(msg, p[0], p[1]);
+                      logger.%1$sf(msg, p[0], p[2], p[3]);
+                      logger.%1$sf(msg, p[0], p[2], p[3], p[4]);
+
+                      logger.%1$sf(t, msg, p[0]);
+                      logger.%1$sf(t, msg, p[0], p[1]);
+                      logger.%1$sf(t, msg, p[0], p[2], p[3]);
+                      logger.%1$sf(t, msg, p[0], p[2], p[3], p[4]);
+
+                      logger.logf(fqcn, Logger.Level.%1$S, t, msg, p[0]);
+                  }
+              }
+              """.formatted(level)
+          )
+        );
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"trace", "debug", "info", "warn", "error", "fatal"})
+    void replaceLevelArgumentsFormatV(String level) {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              import org.jboss.logging.Logger;
+
+              import static org.jboss.logging.Logger.Level.%1$S;
+
+              class Test {
+                  void test(Logger logger, String msg, Throwable t, String fqcn, Object[] p) {
+                      logger.logv(Logger.Level.%1$S, msg, p[0]);
+                      logger.logv(Logger.Level.%1$S, msg, p[0], p[1]);
+                      logger.logv(Logger.Level.%1$S, msg, p[0], p[2], p[3]);
+                      logger.logv(Logger.Level.%1$S, msg, p[0], p[2], p[3], p[4]);
+
+                      logger.logv(Logger.Level.%1$S, t, msg, p[0]);
+                      logger.logv(Logger.Level.%1$S, t, msg, p[0], p[1]);
+                      logger.logv(Logger.Level.%1$S, t, msg, p[0], p[2], p[3]);
+                      logger.logv(Logger.Level.%1$S, t, msg, p[0], p[2], p[3], p[4]);
+
+                      logger.logv(fqcn, Logger.Level.%1$S, t, msg, p[0]);
+                  }
+              }
+              """.formatted(level),
+            """
+              import org.jboss.logging.Logger;
+
+              import static org.jboss.logging.Logger.Level.%1$S;
+
+              class Test {
+                  void test(Logger logger, String msg, Throwable t, String fqcn, Object[] p) {
+                      logger.%1$sv(msg, p[0]);
+                      logger.%1$sv(msg, p[0], p[1]);
+                      logger.%1$sv(msg, p[0], p[2], p[3]);
+                      logger.%1$sv(msg, p[0], p[2], p[3], p[4]);
+
+                      logger.%1$sv(t, msg, p[0]);
+                      logger.%1$sv(t, msg, p[0], p[1]);
+                      logger.%1$sv(t, msg, p[0], p[2], p[3]);
+                      logger.%1$sv(t, msg, p[0], p[2], p[3], p[4]);
+
+                      logger.logv(fqcn, Logger.Level.%1$S, t, msg, p[0]);
+                  }
+              }
+              """.formatted(level)
+          )
+        );
+    }
+
+
+    @Test
+    void noChangeIfLevelUnknown() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              import org.jboss.logging.Logger;
+
+              class Test {
+                  void test(Logger logger, Logger.Level level, String msg) {
+                      logger.log(level, msg);
+                  }
+              }
+              """
+          )
+        );
+    }
+}