org.apache.camel.support.MessageHelper Maven / Gradle / Ivy
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* 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.apache.camel.support;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.lang.reflect.Array;
import java.nio.file.Path;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.apache.camel.Exchange;
import org.apache.camel.ExchangePropertyKey;
import org.apache.camel.Message;
import org.apache.camel.MessageHistory;
import org.apache.camel.Route;
import org.apache.camel.StreamCache;
import org.apache.camel.WrappedFile;
import org.apache.camel.spi.DataTypeAware;
import org.apache.camel.spi.ExchangeFormatter;
import org.apache.camel.spi.HeaderFilterStrategy;
import org.apache.camel.trait.message.MessageTrait;
import org.apache.camel.util.ObjectHelper;
import org.apache.camel.util.StringHelper;
import org.apache.camel.util.URISupport;
import org.apache.camel.util.json.JsonArray;
import org.apache.camel.util.json.JsonObject;
import org.apache.camel.util.json.Jsoner;
/**
* Some helper methods when working with {@link org.apache.camel.Message}.
*/
public final class MessageHelper {
private static final String MESSAGE_HISTORY_HEADER = "%-40s %-30s %-50s %-12s";
private static final String MESSAGE_HISTORY_OUTPUT = "%-40.40s %-30.30s %-50.50s %12.12s";
/**
* Utility classes should not have a public constructor.
*/
private MessageHelper() {
}
/**
* Extracts the given body and returns it as a String, that can be used for logging etc.
*
* Will handle stream based bodies wrapped in StreamCache.
*
* @param message the message with the body
* @return the body as String, can return null if no body
*/
public static String extractBodyAsString(Message message) {
if (message == null) {
return null;
}
// optimize if the body is a String type already
Object body = message.getBody();
if (body instanceof String string) {
return string;
}
// we need to favor using stream cache so the body can be re-read later
StreamCache newBody = message.getExchange().getContext().getTypeConverter().tryConvertTo(StreamCache.class,
message.getExchange(), body);
if (newBody != null) {
message.setBody(newBody);
}
Object answer = message.getBody(String.class);
if (answer == null) {
answer = message.getBody();
}
if (newBody != null) {
// Reset the InputStreamCache
newBody.reset();
}
return answer != null ? answer.toString() : null;
}
/**
* Gets the given body class type name as a String.
*
* Will skip java.lang. for the build in Java types.
*
* @param message the message with the body
* @return the body type name as String, can return null if no body
*/
public static String getBodyTypeName(Message message) {
if (message == null) {
return null;
}
String answer = ObjectHelper.classCanonicalName(message.getBody());
if (answer != null && answer.startsWith("java.lang.")) {
return answer.substring(10);
}
return answer;
}
/**
* If the message body contains a {@link StreamCache} instance, reset the cache to enable reading from it again.
*
* @param message the message for which to reset the body
*/
public static void resetStreamCache(Message message) {
if (message == null) {
return;
}
Object body = null;
try {
body = message.getBody();
} catch (Exception e) {
// ignore
}
if (body instanceof StreamCache streamCache) {
streamCache.reset();
}
}
/**
* Returns the MIME content type on the message or null if none defined
*/
public static String getContentType(Message message) {
return message.getHeader(Exchange.CONTENT_TYPE, String.class);
}
/**
* Returns the MIME content encoding on the message or null if none defined
*/
public static String getContentEncoding(Message message) {
return message.getHeader(Exchange.CONTENT_ENCODING, String.class);
}
/**
* Extracts the body for logging purpose.
*
* Will clip the body if its too big for logging. Will prepend the message with Message:
*
* @param message the message
* @return the logging message
* @see org.apache.camel.Exchange#LOG_DEBUG_BODY_STREAMS
* @see org.apache.camel.Exchange#LOG_DEBUG_BODY_MAX_CHARS
*/
public static String extractBodyForLogging(Message message) {
return extractBodyForLogging(message, "Message: ");
}
/**
* Extracts the value for logging purpose.
*
* Will clip the value if its too big for logging.
*
* @param value the value
* @param message the message
* @return the logging message
* @see org.apache.camel.Exchange#LOG_DEBUG_BODY_STREAMS
* @see org.apache.camel.Exchange#LOG_DEBUG_BODY_MAX_CHARS
*/
public static String extractValueForLogging(Object value, Message message) {
boolean streams = isStreams(message);
// default to 1000 chars
int maxChars = 1000;
if (message.getExchange() != null) {
String property = message.getExchange().getContext().getGlobalOption(Exchange.LOG_DEBUG_BODY_MAX_CHARS);
if (property != null) {
maxChars = message.getExchange().getContext().getTypeConverter().convertTo(Integer.class, property);
}
}
return extractValueForLogging(value, message, streams, false, maxChars);
}
private static boolean isStreams(Message message) {
boolean streams = false;
if (message.getExchange() != null) {
String globalOption = message.getExchange().getContext().getGlobalOption(Exchange.LOG_DEBUG_BODY_STREAMS);
if (globalOption != null) {
streams = message.getExchange().getContext().getTypeConverter().convertTo(Boolean.class, message.getExchange(),
globalOption);
}
}
return streams;
}
/**
* Extracts the body for logging purpose.
*
* Will clip the body if its too big for logging.
*
* @param message the message
* @param prepend a message to prepend
* @return the logging message
* @see org.apache.camel.Exchange#LOG_DEBUG_BODY_STREAMS
* @see org.apache.camel.Exchange#LOG_DEBUG_BODY_MAX_CHARS
*/
public static String extractBodyForLogging(Message message, String prepend) {
boolean streams = isStreams(message);
return extractBodyForLogging(message, prepend, streams, false);
}
/**
* Extracts the body for logging purpose.
*
* Will clip the body if its too big for logging.
*
* @param message the message
* @param prepend a message to prepend
* @param allowStreams whether or not streams is allowed
* @param allowFiles whether or not files is allowed (currently not in use)
* @return the logging message
* @see org.apache.camel.Exchange#LOG_DEBUG_BODY_STREAMS
* @see org.apache.camel.Exchange#LOG_DEBUG_BODY_MAX_CHARS
*/
public static String extractBodyForLogging(Message message, String prepend, boolean allowStreams, boolean allowFiles) {
// default to 1000 chars
int maxChars = 1000;
if (message.getExchange() != null) {
String globalOption = message.getExchange().getContext().getGlobalOption(Exchange.LOG_DEBUG_BODY_MAX_CHARS);
if (globalOption != null) {
maxChars = message.getExchange().getContext().getTypeConverter().convertTo(Integer.class, globalOption);
}
}
return extractBodyForLogging(message, prepend, allowStreams, allowFiles, maxChars);
}
/**
* Extracts the body for logging purpose.
*
* Will clip the body if its too big for logging.
*
* @param message the message
* @param prepend a message to prepend (optional)
* @param allowStreams whether or not streams is allowed
* @param allowFiles whether or not files is allowed (currently not in use)
* @param maxChars limit to maximum number of chars. Use 0 for not limit, and -1 for turning logging message
* body off.
* @return the logging message
* @see org.apache.camel.Exchange#LOG_DEBUG_BODY_MAX_CHARS
*/
public static String extractBodyForLogging(
Message message, String prepend, boolean allowStreams, boolean allowFiles, int maxChars) {
String value = extractValueForLogging(message.getBody(), message, allowStreams, allowFiles, maxChars);
if (prepend != null) {
return prepend + value;
} else {
return value;
}
}
/**
* Extracts the body for logging purpose.
*
* Will clip the body if its too big for logging.
*
* @param message the message
* @param prepend a message to prepend (optional)
* @param allowCachedStreams whether or not cached streams is allowed
* @param allowStreams whether or not streams is allowed
* @param allowFiles whether or not files is allowed (currently not in use)
* @param maxChars limit to maximum number of chars. Use 0 for not limit, and -1 for turning logging
* message body off.
* @return the logging message
* @see org.apache.camel.Exchange#LOG_DEBUG_BODY_MAX_CHARS
*/
public static String extractBodyForLogging(
Message message, String prepend, boolean allowCachedStreams, boolean allowStreams, boolean allowFiles,
int maxChars) {
String value
= extractValueForLogging(message.getBody(), message, allowCachedStreams, allowStreams, allowFiles, maxChars);
if (prepend != null) {
return prepend + value;
} else {
return value;
}
}
/**
* Extracts the value for logging purpose.
*
* Will clip the value if its too big for logging.
*
* @param obj the value
* @param message the message
* @param allowStreams whether or not streams is allowed
* @param allowFiles whether or not files is allowed (currently not in use)
* @param maxChars limit to maximum number of chars. Use 0 for not limit, and -1 for turning logging message
* body off.
* @return the logging message
* @see org.apache.camel.Exchange#LOG_DEBUG_BODY_MAX_CHARS
*/
public static String extractValueForLogging(
Object obj, Message message, boolean allowStreams, boolean allowFiles, int maxChars) {
return extractValueForLogging(obj, message, allowStreams, allowStreams, allowFiles, maxChars);
}
/**
* Extracts the value for logging purpose.
*
* Will clip the value if its too big for logging.
*
* @param obj the value
* @param message the message
* @param allowCachedStreams whether or not cached streams is allowed
* @param allowStreams whether or not streams is allowed
* @param allowFiles whether or not files is allowed (currently not in use)
* @param maxChars limit to maximum number of chars. Use 0 for not limit, and -1 for turning logging
* message body off.
* @return the logging message
* @see org.apache.camel.Exchange#LOG_DEBUG_BODY_MAX_CHARS
*/
public static String extractValueForLogging(
Object obj, Message message, boolean allowCachedStreams, boolean allowStreams, boolean allowFiles, int maxChars) {
if (maxChars < 0) {
return "[Body is not logged]";
}
if (obj == null) {
return "[Body is null]";
}
if (!allowFiles) {
if (obj instanceof WrappedFile || obj instanceof File || obj instanceof Path) {
return "[Body is file based: " + obj + "]";
}
}
if (!allowStreams) {
boolean allow = allowCachedStreams && obj instanceof StreamCache;
if (!allow) {
if (obj instanceof StreamCache) {
return "[Body is instance of org.apache.camel.StreamCache]";
} else if (obj instanceof InputStream) {
return "[Body is instance of java.io.InputStream]";
} else if (obj instanceof OutputStream) {
return "[Body is instance of java.io.OutputStream]";
} else if (obj instanceof Reader) {
return "[Body is instance of java.io.Reader]";
} else if (obj instanceof Writer) {
return "[Body is instance of java.io.Writer]";
} else if (obj.getClass().getName().equals("javax.xml.transform.stax.StAXSource")) {
// StAX source is streaming based
return "[Body is instance of javax.xml.transform.Source]";
}
}
}
// is the body a stream cache or input stream
StreamCache cache = null;
InputStream is = null;
if (obj instanceof StreamCache streamCache) {
cache = streamCache;
} else if (obj instanceof InputStream inputStream) {
is = inputStream;
}
// grab the message body as a string
String body = null;
if (message.getExchange() != null) {
try {
body = message.getExchange().getContext().getTypeConverter().tryConvertTo(String.class, message.getExchange(),
obj);
} catch (Exception e) {
// ignore as the body is for logging purpose
}
}
if (body == null) {
try {
body = obj.toString();
} catch (Exception e) {
// ignore as the body is for logging purpose
}
}
// reset stream cache after use
if (cache != null) {
cache.reset();
} else if (is != null && is.markSupported()) {
try {
is.reset();
} catch (IOException e) {
// ignore
}
}
if (body == null) {
return "[Body is null]";
}
// clip body if length enabled and the body is too big
if (maxChars > 0 && body.length() > maxChars) {
body = body.substring(0, maxChars) + "... [Body clipped after " + maxChars + " chars, total length is "
+ body.length() + "]";
}
return body;
}
/**
* Dumps the message as a generic XML structure.
*
* @param message the message
* @return the XML
*/
public static String dumpAsXml(Message message) {
return dumpAsXml(message, true);
}
/**
* Dumps the message as a generic XML structure.
*
* @param message the message
* @param includeBody whether or not to include the message body
* @return the XML
*/
public static String dumpAsXml(Message message, boolean includeBody) {
return dumpAsXml(message, includeBody, 0);
}
/**
* Dumps the message as a generic XML structure.
*
* @param message the message
* @param includeBody whether or not to include the message body
* @param indent number of spaces to indent
* @return the XML
*/
public static String dumpAsXml(Message message, boolean includeBody, int indent) {
return dumpAsXml(message, includeBody, indent, false, true, 128 * 1024);
}
/**
* Dumps the message as a generic XML structure.
*
* @param message the message
* @param includeBody whether or not to include the message body
* @param indent number of spaces to indent
* @param allowStreams whether to include message body if they are stream based
* @param allowFiles whether to include message body if they are file based
* @param maxChars clip body after maximum chars (to avoid very big messages). Use 0 or negative value to not
* limit at all.
* @return the XML
*/
public static String dumpAsXml(
Message message, boolean includeBody, int indent, boolean allowStreams, boolean allowFiles, int maxChars) {
return dumpAsXml(message, false, false, includeBody, indent, allowStreams, allowStreams, allowFiles, maxChars);
}
/**
* Dumps the message as a generic XML structure.
*
* @param message the message
* @param includeExchangeProperties whether or not to include exchange properties
* @param includeExchangeVariables whether or not to include exchange variables
* @param includeBody whether or not to include the message body
* @param indent number of spaces to indent
* @param allowCachedStreams whether to include message body if they are stream cache based
* @param allowStreams whether to include message body if they are stream based
* @param allowFiles whether to include message body if they are file based
* @param maxChars clip body after maximum chars (to avoid very big messages). Use 0 or negative
* value to not limit at all.
* @return the XML
*/
public static String dumpAsXml(
Message message, boolean includeExchangeProperties, boolean includeExchangeVariables,
boolean includeBody, int indent, boolean allowCachedStreams, boolean allowStreams,
boolean allowFiles, int maxChars) {
StringBuilder sb = new StringBuilder(1024);
final String prefix = " ".repeat(indent);
// include exchangeId/exchangePattern/type as attribute on the tag
sb.append(prefix);
String messageType = ObjectHelper.classCanonicalName(message);
String exchangeType = ObjectHelper.classCanonicalName(message.getExchange());
sb.append("\n");
// exchange variables
if (includeExchangeVariables && message.getExchange().hasVariables()) {
sb.append(prefix);
sb.append(" \n");
// sort the exchange variables so they are listed A..Z
Map variables = new TreeMap<>(message.getExchange().getVariables());
for (Map.Entry entry : variables.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
String type = ObjectHelper.classCanonicalName(value);
sb.append(prefix);
sb.append(" ");
// dump value as XML, use Camel type converter to convert to String
if (value != null) {
try {
String xml = extractValueForLogging(value, message, allowCachedStreams, allowStreams, allowFiles,
maxChars);
if (xml != null) {
// must always xml encode
sb.append(StringHelper.xmlEncode(xml));
}
} catch (Exception e) {
// ignore as the body is for logging purpose
}
}
sb.append(" \n");
}
sb.append(prefix);
sb.append(" \n");
}
// exchange properties
if (includeExchangeProperties) {
sb.append(prefix);
sb.append(" \n");
// sort the exchange properties so they are listed A..Z
Map properties = new TreeMap<>(message.getExchange().getAllProperties());
for (Map.Entry entry : properties.entrySet()) {
String key = entry.getKey();
// skip some special that are too big
if (Exchange.MESSAGE_HISTORY.equals(key) || Exchange.GROUPED_EXCHANGE.equals(key)
|| Exchange.FILE_EXCHANGE_FILE.equals(key)) {
continue;
}
Object value = entry.getValue();
String type = ObjectHelper.classCanonicalName(value);
sb.append(prefix);
sb.append(" ");
// dump value as XML, use Camel type converter to convert to String
if (value != null) {
try {
String xml = extractValueForLogging(value, message, allowCachedStreams, allowStreams, allowFiles,
maxChars);
if (xml != null) {
// must always xml encode
sb.append(StringHelper.xmlEncode(xml));
}
} catch (Exception e) {
// ignore as the body is for logging purpose
}
}
sb.append(" \n");
}
sb.append(prefix);
sb.append(" \n");
}
// headers
if (message.hasHeaders()) {
sb.append(prefix);
sb.append(" \n");
// sort the headers so they are listed A..Z
Map headers = new TreeMap<>(message.getHeaders());
for (Map.Entry entry : headers.entrySet()) {
Object value = entry.getValue();
String type = ObjectHelper.classCanonicalName(value);
sb.append(prefix);
sb.append(" ");
// dump value as XML, use Camel type converter to convert to String
if (value != null) {
try {
String xml = extractValueForLogging(value, message, allowCachedStreams, allowStreams, allowFiles,
maxChars);
if (xml != null) {
// must always xml encode
sb.append(StringHelper.xmlEncode(xml));
}
} catch (Exception e) {
// ignore as the body is for logging purpose
}
}
sb.append(" \n");
}
sb.append(prefix);
sb.append(" \n");
}
if (includeBody) {
sb.append(prefix);
sb.append(" ) body).size();
sb.append(" size=\"").append(size).append("\"");
}
if (body != null && body.getClass().isArray()) {
int size = Array.getLength(body);
sb.append(" size=\"").append(size).append("\"");
}
if (body instanceof StreamCache streamCache) {
long pos = streamCache.position();
if (pos != -1) {
sb.append(" position=\"").append(pos).append("\"");
}
}
sb.append(">");
String xml = extractBodyForLogging(message, null, allowCachedStreams, allowStreams, allowFiles, maxChars);
if (xml != null) {
// must always xml encode
sb.append(StringHelper.xmlEncode(xml));
}
sb.append("