You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@logging.apache.org by GitBox <gi...@apache.org> on 2021/07/01 16:25:54 UTC
[GitHub] [logging-log4j2] sman-81 opened a new pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
sman-81 opened a new pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542
Hi, I've a specialized abbreviator named `DynamicWordAbbreviator` to address the specific requirement of this feature request. Javadoc added and JUnit test updated to cover the new feature.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] sman-81 commented on pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
sman-81 commented on pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542#issuecomment-1028625847
@carterkozak
I'm a volunteer just like you.
My pull request is from July 1st, thus seven months old by now!
The last comment from anyone other than me was August 12, 2021.
Such discourages people from contributing to the project.
> I asked you twice to avoid string.split in favor of indexOf/lastIndexOf, but it's still used.
And you are wrong. `String#split` does not create a Pattern object for certain one-character patterns such as here, as I have pointed out to you (see comment on August 5, 2021).
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] carterkozak commented on a change in pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
carterkozak commented on a change in pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542#discussion_r682718072
##########
File path: log4j-core/src/main/java/org/apache/logging/log4j/core/pattern/NameAbbreviator.java
##########
@@ -365,4 +372,51 @@ public void abbreviate(final String original, final StringBuilder destination) {
}
}
}
+
+ /**
+ * <p>Specialized abbreviator that shortens all words to the first char except the indicated number of rightmost words.
+ * To select this abbreviator, use pattern <code>1.n*</code> where n (> 0) is the number of rightmost words to leave unchanged.</p>
+ *
+ * By example for input <code>org.apache.logging.log4j.core.pattern.NameAbbreviator</code>:
+ * <pre>
+ * 1.1* => o.a.l.l.c.p.NameAbbreviator
+ * 1.2* => o.a.l.l.c.pattern.NameAbbreviator
+ * 1.3* => o.a.l.l.core.pattern.NameAbbreviator
+ * ..
+ * 1.999* => org.apache.logging.log4j.core.pattern.NameAbbreviator
+ * </pre>
+ * @since 2.x
+ */
+ static class DynamicWordAbbreviator extends NameAbbreviator {
+
+ /** Right-most number of words (at least one) that will not be abbreviated. */
+ private final int rightWordCount;
+
+ static DynamicWordAbbreviator create(String pattern) {
+ if (pattern != null) {
+ Matcher matcher = Pattern.compile("1\\.([1-9][0-9]*)\\*").matcher(pattern);
+ if (matcher.matches()) {
+ return new DynamicWordAbbreviator(Integer.parseInt(matcher.group(1)));
+ }
+ }
+ return null;
+ }
+
+ private DynamicWordAbbreviator(int rightWordCount) {
+ this.rightWordCount = rightWordCount;
+ }
+
+ @Override
+ public void abbreviate(String original, StringBuilder destination) {
+ if (original != null && destination != null) {
+ String[] words = original.split("\\.");
+ for (int i = 0; i < words.length - rightWordCount; i++) {
+ words[i] = words[i].substring(0, 1);
+ }
+ destination.append(String.join(".", words));
Review comment:
This looks very expensive. String.split uses regex and allocates a new string for each segment. Substring allocates another string per abbreviated segment, and the final String.join creates a string representation of the data that's added to the StringBuilder. I think allocation can be entirely avoided here by tacking indexes, and writing directly to the Destination buffer.
It could be interesting to run the benchmarks comparing `1.1*` to the existing `1.`
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] carterkozak commented on pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
carterkozak commented on pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542#issuecomment-1029134939
The point is that `string.split` is inefficient, regardless of internal details because it's allocating several new strings unnecessarily.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] sman-81 commented on pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
sman-81 commented on pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542#issuecomment-914959246
@carterkozak Here's another small update to my pull request.
Can you merge it into the release branch please?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] sman-81 closed pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
sman-81 closed pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] carterkozak commented on pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
carterkozak commented on pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542#issuecomment-897285253
When I have some time to tinker, I think this feature could be added to the existing abbreviator. All existing patterns effectively use `rightWordCount=1`, however we could make that configurable and allow existing options to work with this.
Something along the lines of
```java
int limit = input.length();
for (int i = 0; I < rightWordCount; I++) {
limit = input.lastIndexOf('.', limit);
if (limit < 0) {
return input;
}
}
// call into standard abbreviator.
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] carterkozak commented on a change in pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
carterkozak commented on a change in pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542#discussion_r682718072
##########
File path: log4j-core/src/main/java/org/apache/logging/log4j/core/pattern/NameAbbreviator.java
##########
@@ -365,4 +372,51 @@ public void abbreviate(final String original, final StringBuilder destination) {
}
}
}
+
+ /**
+ * <p>Specialized abbreviator that shortens all words to the first char except the indicated number of rightmost words.
+ * To select this abbreviator, use pattern <code>1.n*</code> where n (> 0) is the number of rightmost words to leave unchanged.</p>
+ *
+ * By example for input <code>org.apache.logging.log4j.core.pattern.NameAbbreviator</code>:
+ * <pre>
+ * 1.1* => o.a.l.l.c.p.NameAbbreviator
+ * 1.2* => o.a.l.l.c.pattern.NameAbbreviator
+ * 1.3* => o.a.l.l.core.pattern.NameAbbreviator
+ * ..
+ * 1.999* => org.apache.logging.log4j.core.pattern.NameAbbreviator
+ * </pre>
+ * @since 2.x
+ */
+ static class DynamicWordAbbreviator extends NameAbbreviator {
+
+ /** Right-most number of words (at least one) that will not be abbreviated. */
+ private final int rightWordCount;
+
+ static DynamicWordAbbreviator create(String pattern) {
+ if (pattern != null) {
+ Matcher matcher = Pattern.compile("1\\.([1-9][0-9]*)\\*").matcher(pattern);
+ if (matcher.matches()) {
+ return new DynamicWordAbbreviator(Integer.parseInt(matcher.group(1)));
+ }
+ }
+ return null;
+ }
+
+ private DynamicWordAbbreviator(int rightWordCount) {
+ this.rightWordCount = rightWordCount;
+ }
+
+ @Override
+ public void abbreviate(String original, StringBuilder destination) {
+ if (original != null && destination != null) {
+ String[] words = original.split("\\.");
+ for (int i = 0; i < words.length - rightWordCount; i++) {
+ words[i] = words[i].substring(0, 1);
+ }
+ destination.append(String.join(".", words));
Review comment:
This looks very expensive. String.split uses regex and allocates a new string for each segment. Substring allocates another string per abbreviated segment, and the final String.join creates a string representation of the data that's added to the StringBuilder. I think allocation can be entirely avoided here by tacking indexes, and writing directly to the Destination buffer.
It could be interesting to run the benchmarks comparing `1.1*` to the existing `1.`
##########
File path: log4j-core/src/main/java/org/apache/logging/log4j/core/pattern/NameAbbreviator.java
##########
@@ -365,4 +372,51 @@ public void abbreviate(final String original, final StringBuilder destination) {
}
}
}
+
+ /**
+ * <p>Specialized abbreviator that shortens all words to the first char except the indicated number of rightmost words.
+ * To select this abbreviator, use pattern <code>1.n*</code> where n (> 0) is the number of rightmost words to leave unchanged.</p>
+ *
+ * By example for input <code>org.apache.logging.log4j.core.pattern.NameAbbreviator</code>:
+ * <pre>
+ * 1.1* => o.a.l.l.c.p.NameAbbreviator
+ * 1.2* => o.a.l.l.c.pattern.NameAbbreviator
+ * 1.3* => o.a.l.l.core.pattern.NameAbbreviator
+ * ..
+ * 1.999* => org.apache.logging.log4j.core.pattern.NameAbbreviator
+ * </pre>
+ * @since 2.x
+ */
+ static class DynamicWordAbbreviator extends NameAbbreviator {
+
+ /** Right-most number of words (at least one) that will not be abbreviated. */
+ private final int rightWordCount;
+
+ static DynamicWordAbbreviator create(String pattern) {
+ if (pattern != null) {
+ Matcher matcher = Pattern.compile("1\\.([1-9][0-9]*)\\*").matcher(pattern);
+ if (matcher.matches()) {
+ return new DynamicWordAbbreviator(Integer.parseInt(matcher.group(1)));
+ }
+ }
+ return null;
+ }
+
+ private DynamicWordAbbreviator(int rightWordCount) {
+ this.rightWordCount = rightWordCount;
+ }
+
+ @Override
+ public void abbreviate(String original, StringBuilder destination) {
+ if (original != null && destination != null) {
+ String[] words = original.split("\\.");
+ for (int i = 0; i < words.length - rightWordCount; i++) {
+ words[i] = words[i].substring(0, 1);
Review comment:
Probably worthwhile to add test coverage for an input string along the lines of `org..example.Name` with two periods in a row, I think this substring will throw an IndexOutOfBoundsException in that case.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] carterkozak commented on a change in pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
carterkozak commented on a change in pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542#discussion_r682720416
##########
File path: log4j-core/src/main/java/org/apache/logging/log4j/core/pattern/NameAbbreviator.java
##########
@@ -365,4 +372,51 @@ public void abbreviate(final String original, final StringBuilder destination) {
}
}
}
+
+ /**
+ * <p>Specialized abbreviator that shortens all words to the first char except the indicated number of rightmost words.
+ * To select this abbreviator, use pattern <code>1.n*</code> where n (> 0) is the number of rightmost words to leave unchanged.</p>
+ *
+ * By example for input <code>org.apache.logging.log4j.core.pattern.NameAbbreviator</code>:
+ * <pre>
+ * 1.1* => o.a.l.l.c.p.NameAbbreviator
+ * 1.2* => o.a.l.l.c.pattern.NameAbbreviator
+ * 1.3* => o.a.l.l.core.pattern.NameAbbreviator
+ * ..
+ * 1.999* => org.apache.logging.log4j.core.pattern.NameAbbreviator
+ * </pre>
+ * @since 2.x
+ */
+ static class DynamicWordAbbreviator extends NameAbbreviator {
+
+ /** Right-most number of words (at least one) that will not be abbreviated. */
+ private final int rightWordCount;
+
+ static DynamicWordAbbreviator create(String pattern) {
+ if (pattern != null) {
+ Matcher matcher = Pattern.compile("1\\.([1-9][0-9]*)\\*").matcher(pattern);
+ if (matcher.matches()) {
+ return new DynamicWordAbbreviator(Integer.parseInt(matcher.group(1)));
+ }
+ }
+ return null;
+ }
+
+ private DynamicWordAbbreviator(int rightWordCount) {
+ this.rightWordCount = rightWordCount;
+ }
+
+ @Override
+ public void abbreviate(String original, StringBuilder destination) {
+ if (original != null && destination != null) {
+ String[] words = original.split("\\.");
+ for (int i = 0; i < words.length - rightWordCount; i++) {
+ words[i] = words[i].substring(0, 1);
Review comment:
Probably worthwhile to add test coverage for an input string along the lines of `org..example.Name` with two periods in a row, I think this substring will throw an IndexOutOfBoundsException in that case.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] sman-81 commented on a change in pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
sman-81 commented on a change in pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542#discussion_r683418964
##########
File path: log4j-core/src/main/java/org/apache/logging/log4j/core/pattern/NameAbbreviator.java
##########
@@ -365,4 +372,51 @@ public void abbreviate(final String original, final StringBuilder destination) {
}
}
}
+
+ /**
+ * <p>Specialized abbreviator that shortens all words to the first char except the indicated number of rightmost words.
+ * To select this abbreviator, use pattern <code>1.n*</code> where n (> 0) is the number of rightmost words to leave unchanged.</p>
+ *
+ * By example for input <code>org.apache.logging.log4j.core.pattern.NameAbbreviator</code>:
+ * <pre>
+ * 1.1* => o.a.l.l.c.p.NameAbbreviator
+ * 1.2* => o.a.l.l.c.pattern.NameAbbreviator
+ * 1.3* => o.a.l.l.core.pattern.NameAbbreviator
+ * ..
+ * 1.999* => org.apache.logging.log4j.core.pattern.NameAbbreviator
+ * </pre>
+ * @since 2.x
+ */
+ static class DynamicWordAbbreviator extends NameAbbreviator {
+
+ /** Right-most number of words (at least one) that will not be abbreviated. */
+ private final int rightWordCount;
+
+ static DynamicWordAbbreviator create(String pattern) {
+ if (pattern != null) {
+ Matcher matcher = Pattern.compile("1\\.([1-9][0-9]*)\\*").matcher(pattern);
+ if (matcher.matches()) {
+ return new DynamicWordAbbreviator(Integer.parseInt(matcher.group(1)));
+ }
+ }
+ return null;
+ }
+
+ private DynamicWordAbbreviator(int rightWordCount) {
+ this.rightWordCount = rightWordCount;
+ }
+
+ @Override
+ public void abbreviate(String original, StringBuilder destination) {
+ if (original != null && destination != null) {
+ String[] words = original.split("\\.");
+ for (int i = 0; i < words.length - rightWordCount; i++) {
+ words[i] = words[i].substring(0, 1);
+ }
+ destination.append(String.join(".", words));
Review comment:
Thanks for your feedback.
Afaik `String#split` does not create a `Pattern` object for certain one-character patterns such as here.
I've rewritten the method for improved efficiency.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] sman-81 commented on pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
sman-81 commented on pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542#issuecomment-1028218237
"we love pull requests" they say
you send them prs
you listen to their criticism
you incorporate their feedback
you think you're done
then nothing happens
forever
wtf
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] sman-81 commented on pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
sman-81 commented on pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542#issuecomment-907319321
> [..] All existing patterns effectively use `rightWordCount=1`, however we could make that configurable and allow existing options to work with this.
@carterkozak
I don't think this is the case. Consider patterns such as `1.1.1.*`. The number of unmodified words at the right side depends on the length of the string to be abbreviated, not on the pattern.
`NameAbbreviator` is abstract. Implementations are `MaxElementAbbreviator` and `PatternAbbreviator`.
I don't see a good way of covering the feature request within these two implementations, and have therefore added `DynamicWordAbbreviator`.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] sman-81 edited a comment on pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
sman-81 edited a comment on pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542#issuecomment-907319321
> [..] All existing patterns effectively use `rightWordCount=1`, however we could make that configurable and allow existing options to work with this.
@carterkozak
I don't think this is the case. Consider patterns such as `1.1.1.*`. The number of unmodified words at the right side depends on the length of the string to be abbreviated, not on the pattern.
`NameAbbreviator` is abstract. Implementations are `MaxElementAbbreviator` and `PatternAbbreviator`.
I don't see a good way of covering the feature request within these two implementations, and have therefore added `DynamicWordAbbreviator`.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] sman-81 commented on a change in pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
sman-81 commented on a change in pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542#discussion_r683419578
##########
File path: log4j-core/src/main/java/org/apache/logging/log4j/core/pattern/NameAbbreviator.java
##########
@@ -365,4 +372,51 @@ public void abbreviate(final String original, final StringBuilder destination) {
}
}
}
+
+ /**
+ * <p>Specialized abbreviator that shortens all words to the first char except the indicated number of rightmost words.
+ * To select this abbreviator, use pattern <code>1.n*</code> where n (> 0) is the number of rightmost words to leave unchanged.</p>
+ *
+ * By example for input <code>org.apache.logging.log4j.core.pattern.NameAbbreviator</code>:
+ * <pre>
+ * 1.1* => o.a.l.l.c.p.NameAbbreviator
+ * 1.2* => o.a.l.l.c.pattern.NameAbbreviator
+ * 1.3* => o.a.l.l.core.pattern.NameAbbreviator
+ * ..
+ * 1.999* => org.apache.logging.log4j.core.pattern.NameAbbreviator
+ * </pre>
+ * @since 2.x
+ */
+ static class DynamicWordAbbreviator extends NameAbbreviator {
+
+ /** Right-most number of words (at least one) that will not be abbreviated. */
+ private final int rightWordCount;
+
+ static DynamicWordAbbreviator create(String pattern) {
+ if (pattern != null) {
+ Matcher matcher = Pattern.compile("1\\.([1-9][0-9]*)\\*").matcher(pattern);
+ if (matcher.matches()) {
+ return new DynamicWordAbbreviator(Integer.parseInt(matcher.group(1)));
+ }
+ }
+ return null;
+ }
+
+ private DynamicWordAbbreviator(int rightWordCount) {
+ this.rightWordCount = rightWordCount;
+ }
+
+ @Override
+ public void abbreviate(String original, StringBuilder destination) {
+ if (original != null && destination != null) {
+ String[] words = original.split("\\.");
+ for (int i = 0; i < words.length - rightWordCount; i++) {
+ words[i] = words[i].substring(0, 1);
Review comment:
Thanks, you're right. I've fixed this and improved test coverage.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] carterkozak commented on pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
carterkozak commented on pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542#issuecomment-1028513533
@sman-81 we are all volunteers and have limited time to devote to review. Your most recent comment comes across as entitled and rude. Please work on that. In your position, I might have replied on the PR with "Is there anything I can do to get this into a mergable state?"
> you listen to their criticism
> you incorporate their feedback
I asked you twice to avoid `string.split` in favor of `indexOf`/`lastIndexOf`, but it's still used.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [logging-log4j2] sman-81 commented on pull request #542: LOG4J2-2785: Added support for pattern Layout to abbreviate logger or class names except n rightmost words
Posted by GitBox <gi...@apache.org>.
sman-81 commented on pull request #542:
URL: https://github.com/apache/logging-log4j2/pull/542#issuecomment-1029773783
Hi there @carterkozak now `String#split` is gone. I have also squashed commits into one. Please take a look.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@logging.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org