Package com.unboundid.ldap.sdk.unboundidds.logs.v2.syntax

Class CommaDelimitedStringListLogFieldSyntax

java.lang.Object
com.unboundid.ldap.sdk.unboundidds.logs.v2.syntax.LogFieldSyntax<Collection<? extends CharSequence>>
com.unboundid.ldap.sdk.unboundidds.logs.v2.syntax.CommaDelimitedStringListLogFieldSyntax
@ThreadSafety(level=COMPLETELY_THREADSAFE) public final class CommaDelimitedStringListLogFieldSyntax extends LogFieldSyntax<Collection<? extends CharSequence>>
This class defines a log field syntax for values that are a comma-delimited list of strings. This syntax does support redacting and tokenizing the individual items in the list.
NOTE: This class, and other classes within the com.unboundid.ldap.sdk.unboundidds package structure, are only supported for use against Ping Identity, UnboundID, and Nokia/Alcatel-Lucent 8661 server products. These classes provide support for proprietary functionality or for external specifications that are not considered stable or mature enough to be guaranteed to work in an interoperable way with other types of LDAP servers.

  • Field Details

  • Constructor Details

    • CommaDelimitedStringListLogFieldSyntax

      public CommaDelimitedStringListLogFieldSyntax(int maxStringLengthCharacters)
      Creates a new instance of this log field syntax implementation.
      Parameters:
      maxStringLengthCharacters - The maximum length (in characters) to use for strings within values. Strings that are longer than this should be truncated before inclusion in the log. This value must be greater than or equal to zero.

  • Method Details

    • getSyntaxName

      @NotNull public String getSyntaxName()
      Retrieves the name for this syntax.
      Specified by:
      getSyntaxName in class LogFieldSyntax<Collection<? extends CharSequence>>
      Returns:
      The name for this syntax.

    • valueToSanitizedString

      public void valueToSanitizedString(@NotNull Collection<? extends CharSequence> value, @NotNull ByteStringBuffer buffer)
      Encodes the provided value to a sanitized string representation suitable for inclusion in a log message. The sanitized string should at least be cleaned of control characters and other non-printable characters, but depending on the syntax, it may clean other characters as well.
      Specified by:
      valueToSanitizedString in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      value - The value to be encoded. It must not be null.
      buffer - The buffer to which the string representation should be appended. It must not be null.

    • logSanitizedFieldToTextFormattedLog

      public void logSanitizedFieldToTextFormattedLog(@NotNull String fieldName, @NotNull Collection<? extends CharSequence> fieldValue, @NotNull ByteStringBuffer buffer)
      Appends a sanitized representation of the specified field (both field name and value) for a text-formatted log message to the given buffer.
      Specified by:
      logSanitizedFieldToTextFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      fieldName - The name for the field. It must not be null.
      fieldValue - The value to use for the field. It must not be null.
      buffer - The buffer to which the sanitized log field should be appended. It must not be null.

    • logSanitizedFieldToJSONFormattedLog

      public void logSanitizedFieldToJSONFormattedLog(@NotNull String fieldName, @NotNull Collection<? extends CharSequence> fieldValue, @NotNull JSONBuffer buffer)
      Appends a sanitized representation of the specified field (both field name and value) for a JSON-formatted log message to the given buffer.
      Specified by:
      logSanitizedFieldToJSONFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      fieldName - The name for the field. It must not be null.
      fieldValue - The value to use for the field. It must not be null.
      buffer - The buffer to which the sanitized log field should be appended. It must not be null.

    • logSanitizedValueToJSONFormattedLog

      public void logSanitizedValueToJSONFormattedLog(@NotNull Collection<? extends CharSequence> value, @NotNull JSONBuffer buffer)
      Appends a sanitized representation of the provided value (without a field name, as might be suitable for a value included in a JSON array) for a JSON-formatted log message to the given buffer.
      Specified by:
      logSanitizedValueToJSONFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      value - The value to be appended to the buffer. It must not be null.
      buffer - The buffer to which the sanitized value should be appended. It must not be null.

    • parseValue

      @NotNull public List<String> parseValue(@NotNull String valueString)
      Attempts to parse the provided string as a value in accordance with this syntax.
      Specified by:
      parseValue in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      valueString - The string to be parsed.
      Returns:
      The value that was parsed.

    • completelyRedactedValueConformsToSyntax

      public boolean completelyRedactedValueConformsToSyntax()
      Indicates whether values that have been completely redacted still conform to this syntax.
      Specified by:
      completelyRedactedValueConformsToSyntax in class LogFieldSyntax<Collection<? extends CharSequence>>
      Returns:
      true if values that have been completely redacted still conform to this syntax, or false if not.

    • logCompletelyRedactedFieldToTextFormattedLog

      public void logCompletelyRedactedFieldToTextFormattedLog(@NotNull String fieldName, @NotNull ByteStringBuffer buffer)
      Appends a completely redacted representation of the specified field (both field name and value) for a text-formatted log message to the given buffer.
      Specified by:
      logCompletelyRedactedFieldToTextFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      fieldName - The name for the field. It must not be null.
      buffer - The buffer to which the sanitized log field should be appended. It must not be null.

    • logCompletelyRedactedFieldToJSONFormattedLog

      public void logCompletelyRedactedFieldToJSONFormattedLog(@NotNull String fieldName, @NotNull JSONBuffer buffer)
      Appends a completely redacted representation of the specified field (both field name and value) for a JSON-formatted log message to the given buffer.
      Specified by:
      logCompletelyRedactedFieldToJSONFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      fieldName - The name for the field. It must not be null.
      buffer - The buffer to which the sanitized log field should be appended. It must not be null.

    • logCompletelyRedactedValueToJSONFormattedLog

      public void logCompletelyRedactedValueToJSONFormattedLog(@NotNull JSONBuffer buffer)
      Appends a completely redacted representation of a value (without a field name, as might be suitable for a value included in a JSON array) for a JSON-formatted log message to the given buffer.
      Specified by:
      logCompletelyRedactedValueToJSONFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      buffer - The buffer to which the redacted value should be appended. It must not be null.

    • supportsRedactedComponents

      public boolean supportsRedactedComponents()
      Indicates whether this syntax supports redacting individual components of the entire value.
      Specified by:
      supportsRedactedComponents in class LogFieldSyntax<Collection<? extends CharSequence>>
      Returns:
      true if this syntax supports redacting individual components of the entire value, or false if not.

    • valueWithRedactedComponentsConformsToSyntax

      public boolean valueWithRedactedComponentsConformsToSyntax()
      Indicates whether values with one or more redacted components still conform to this syntax.
      Specified by:
      valueWithRedactedComponentsConformsToSyntax in class LogFieldSyntax<Collection<? extends CharSequence>>
      Returns:
      true if values with one or more redacted components still conform to this syntax.

    • redactComponents

      public void redactComponents(@NotNull Collection<? extends CharSequence> value, @NotNull ByteStringBuffer buffer)
      Appends a string representation of the given value with redacted components to the provided buffer.
      Overrides:
      redactComponents in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      value - The value for which to obtain the redacted representation. It must not be null.
      buffer - The buffer to which the redacted string representation should be appended. It must not be null.

    • logRedactedComponentsFieldToTextFormattedLog

      public void logRedactedComponentsFieldToTextFormattedLog(@NotNull String fieldName, @NotNull Collection<? extends CharSequence> fieldValue, @NotNull ByteStringBuffer buffer)
      Appends a representation of the specified field (both field name and value) with redacted value components for a text-formatted log message to the given buffer. If this syntax does not support redacting components within a value, then it should redact the entire value.
      Specified by:
      logRedactedComponentsFieldToTextFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      fieldName - The name for the field. It must not be null.
      fieldValue - The value to use for the field. It must not be null.
      buffer - The buffer to which the sanitized log field should be appended. It must not be null.

    • logRedactedComponentsFieldToJSONFormattedLog

      public void logRedactedComponentsFieldToJSONFormattedLog(@NotNull String fieldName, @NotNull Collection<? extends CharSequence> fieldValue, @NotNull JSONBuffer buffer)
      Appends a representation of the specified field (both field name and value) with redacted value components for a JSON-formatted log message to the given buffer. If this syntax does not support redacting components within a value, then it should redact the entire value.
      Specified by:
      logRedactedComponentsFieldToJSONFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      fieldName - The name for the field. It must not be null.
      fieldValue - The value to use for the field. It must not be null.
      buffer - The buffer to which the sanitized log field should be appended. It must not be null.

    • logRedactedComponentsValueToJSONFormattedLog

      public void logRedactedComponentsValueToJSONFormattedLog(@NotNull Collection<? extends CharSequence> value, @NotNull JSONBuffer buffer)
      Appends a representation of the provided value (without a field name, as might be suitable for a value included in a JSON array) with redacted components for a JSON-formatted log message to the given buffer. If this syntax does not support redacting components within a value, then it should redact the entire value.
      Specified by:
      logRedactedComponentsValueToJSONFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      value - The value to be appended to the buffer in redacted form. It must not be null.
      buffer - The buffer to which the redacted value should be appended. It must not be null.

    • completelyTokenizedValueConformsToSyntax

      public boolean completelyTokenizedValueConformsToSyntax()
      Indicates whether values that have been completely tokenized still conform to this syntax.
      Specified by:
      completelyTokenizedValueConformsToSyntax in class LogFieldSyntax<Collection<? extends CharSequence>>
      Returns:
      true if values that have been completely tokenized still conform to this syntax, or false if not.

    • tokenizeEntireValue

      public void tokenizeEntireValue(@NotNull Collection<? extends CharSequence> value, @NotNull byte[] pepper, @NotNull ByteStringBuffer buffer)
      Appends a tokenized representation of the provided value to the given buffer.

      The resulting token will protect the provided value by representing it in a way that makes it at infeasible to determine what the original value was. However, tokenizing the same value with the same pepper should consistently yield the same token value, so that it will be possible to identify the same value across multiple log messages.
      Specified by:
      tokenizeEntireValue in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      value - The value for which to generate the token. It must not be null.
      pepper - A pepper used to provide brute-force protection for the resulting token. The pepper value should be kept secret so that it is not available to unauthorized users who might be able to view log information, although the same pepper value should be consistently provided when tokenizing values so that the same value will consistently yield the same token. It must not be null and should not be empty.
      buffer - The buffer to which the tokenized representation should be appended. It must not be null.

    • logCompletelyTokenizedFieldToTextFormattedLog

      public void logCompletelyTokenizedFieldToTextFormattedLog(@NotNull String fieldName, @NotNull Collection<? extends CharSequence> fieldValue, @NotNull byte[] pepper, @NotNull ByteStringBuffer buffer)
      Appends a completely tokenized representation of the specified field (both field name and value) for a text-formatted log message to the given buffer.
      Specified by:
      logCompletelyTokenizedFieldToTextFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      fieldName - The name for the field. It must not be null.
      fieldValue - The value to use for the field. It must not be null.
      pepper - A pepper used to provide brute-force protection for the resulting token. The pepper value should be kept secret so that it is not available to unauthorized users who might be able to view log information, although the same pepper value should be consistently provided when tokenizing values so that the same value will consistently yield the same token. It must not be null and should not be empty.
      buffer - The buffer to which the sanitized log field should be appended. It must not be null.

    • logCompletelyTokenizedFieldToJSONFormattedLog

      public void logCompletelyTokenizedFieldToJSONFormattedLog(@NotNull String fieldName, @NotNull Collection<? extends CharSequence> fieldValue, @NotNull byte[] pepper, @NotNull JSONBuffer buffer)
      Appends a completely tokenized representation of the specified field (both field name and value) for a JSON-formatted log message to the given buffer.
      Specified by:
      logCompletelyTokenizedFieldToJSONFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      fieldName - The name for the field. It must not be null.
      fieldValue - The value to use for the field. It must not be null.
      pepper - A pepper used to provide brute-force protection for the resulting token. The pepper value should be kept secret so that it is not available to unauthorized users who might be able to view log information, although the same pepper value should be consistently provided when tokenizing values so that the same value will consistently yield the same token. It must not be null and should not be empty.
      buffer - The buffer to which the sanitized log field should be appended. It must not be null.

    • logCompletelyTokenizedValueToJSONFormattedLog

      public void logCompletelyTokenizedValueToJSONFormattedLog(@NotNull Collection<? extends CharSequence> value, @NotNull byte[] pepper, @NotNull JSONBuffer buffer)
      Appends a completely tokenized representation of the provided value (without a field name, as might be suitable for a value included in a JSON array) for a JSON-formatted log message to the given buffer.
      Specified by:
      logCompletelyTokenizedValueToJSONFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      value - The value to be appended to the buffer in tokenized form. It must not be null.
      pepper - A pepper used to provide brute-force protection for the resulting token. The pepper value should be kept secret so that it is not available to unauthorized users who might be able to view log information, although the same pepper value should be consistently provided when tokenizing values so that the same value will consistently yield the same token. It must not be null and should not be empty.
      buffer - The buffer to which the tokenized value should be appended. It must not be null.

    • supportsTokenizedComponents

      public boolean supportsTokenizedComponents()
      Indicates whether this syntax supports tokenizing individual components of the entire value.
      Specified by:
      supportsTokenizedComponents in class LogFieldSyntax<Collection<? extends CharSequence>>
      Returns:
      true if this syntax supports tokenizing individual components of the entire value, or false if not.

    • valueWithTokenizedComponentsConformsToSyntax

      public boolean valueWithTokenizedComponentsConformsToSyntax()
      Indicates whether values with one or more tokenized components still conform to this syntax.
      Specified by:
      valueWithTokenizedComponentsConformsToSyntax in class LogFieldSyntax<Collection<? extends CharSequence>>
      Returns:
      true if values with one or more tokenized components still conform to this syntax.

    • tokenizeComponents

      public void tokenizeComponents(@NotNull Collection<? extends CharSequence> value, @NotNull byte[] pepper, @NotNull ByteStringBuffer buffer)
      Appends a string representation of the given value with zero or more of its components tokenized to the provided buffer. If this syntax does not support tokenized components, then the entire value should be tokenized.

      The resulting tokens will protect components of the provided value by representing them in a way that makes it at infeasible to determine what the original components were. However, tokenizing the same value with the same pepper should consistently yield the same token value, so that it will be possible to identify the same value across multiple log messages.
      Overrides:
      tokenizeComponents in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      value - The value whose components should be tokenized. It must not be null.
      pepper - A pepper used to provide brute-force protection for the resulting token. The pepper value should be kept secret so that it is not available to unauthorized users who might be able to view log information, although the same pepper value should be consistently provided when tokenizing values so that the same value will consistently yield the same token. It must not be null and should not be empty.
      buffer - The buffer to which the tokenized representation should be appended. It must not be null.

    • logTokenizedComponentsFieldToTextFormattedLog

      public void logTokenizedComponentsFieldToTextFormattedLog(@NotNull String fieldName, @NotNull Collection<? extends CharSequence> fieldValue, @NotNull byte[] pepper, @NotNull ByteStringBuffer buffer)
      Appends a representation of the specified field (both field name and value) with tokenized value components for a text-formatted log message to the given buffer. If this syntax does not support tokenizing components within a value, then it should tokenize the entire value.
      Specified by:
      logTokenizedComponentsFieldToTextFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      fieldName - The name for the field. It must not be null.
      fieldValue - The value to use for the field. It must not be null.
      pepper - A pepper used to provide brute-force protection for the resulting token. The pepper value should be kept secret so that it is not available to unauthorized users who might be able to view log information, although the same pepper value should be consistently provided when tokenizing values so that the same value will consistently yield the same token. It must not be null and should not be empty.
      buffer - The buffer to which the sanitized log field should be appended. It must not be null.

    • logTokenizedComponentsFieldToJSONFormattedLog

      public void logTokenizedComponentsFieldToJSONFormattedLog(@NotNull String fieldName, @NotNull Collection<? extends CharSequence> fieldValue, @NotNull byte[] pepper, @NotNull JSONBuffer buffer)
      Appends a representation of the specified field (both field name and value) with tokenized value components for a JSON-formatted log message to the given buffer. If this syntax does not support tokenizing components within a value, then it should tokenize the entire value.
      Specified by:
      logTokenizedComponentsFieldToJSONFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      fieldName - The name for the field. It must not be null.
      fieldValue - The value to use for the field. It must not be null.
      pepper - A pepper used to provide brute-force protection for the resulting token. The pepper value should be kept secret so that it is not available to unauthorized users who might be able to view log information, although the same pepper value should be consistently provided when tokenizing values so that the same value will consistently yield the same token. It must not be null and should not be empty.
      buffer - The buffer to which the sanitized log field should be appended. It must not be null.

    • logTokenizedComponentsValueToJSONFormattedLog

      public void logTokenizedComponentsValueToJSONFormattedLog(@NotNull Collection<? extends CharSequence> value, @NotNull byte[] pepper, @NotNull JSONBuffer buffer)
      Appends a representation of the provided value (without a field name, as might be suitable for a value included in a JSON array) with tokenized value components for a JSON-formatted log message to the given buffer. If this syntax does not support tokenizing components within a value, then it should tokenize the entire value.
      Specified by:
      logTokenizedComponentsValueToJSONFormattedLog in class LogFieldSyntax<Collection<? extends CharSequence>>
      Parameters:
      value - The value to be appended to the buffer in tokenized form. It must not be null.
      pepper - A pepper used to provide brute-force protection for the resulting token. The pepper value should be kept secret so that it is not available to unauthorized users who might be able to view log information, although the same pepper value should be consistently provided when tokenizing values so that the same value will consistently yield the same token. It must not be null and should not be empty.
      buffer - The buffer to which the tokenized value should be appended. It must not be null.