org.keycloak.saml.common

## Class DefaultPicketLinkLogger

- java.lang.Object
- - org.keycloak.saml.common.DefaultPicketLinkLogger

- All Implemented Interfaces:
    PicketLinkLogger

      public class DefaultPicketLinkLogger
      extends Object
      implements PicketLinkLogger

  Author:
    Pedro Silva

- - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `ProcessingException` | `assertionExpiredError(AssertionExpiredException aee)`
    `ProcessingException` | `assertionInvalidError()`
    `void` | `attributeManagerError(Throwable t)`
    `void` | `attributeProviderInstationError(Throwable t)`
    `ConfigurationException` | `auditAuditManagerNotFound(String location, Throwable t)`
    `void` | `auditEvent(String auditEvent)` Logs a PicketLink Audit Event.
    `IllegalStateException` | `auditNullAuditManager()` Creates a `IllegalStateException` for the case the Audit Manager is null.
    `ConfigurationException` | `auditSecurityDomainNotFound(Throwable t)`
    `LoginException` | `authAssertionValidationError(Throwable t)`
    `IllegalStateException` | `authCouldNotCreateWSTrustClient(Throwable t)`
    `LoginException` | `authCouldNotIssueSAMLToken()`
    `LoginException` | `authCouldNotLocateSecurityToken()`
    `LoginException` | `authCouldNotValidateSAMLToken(Element token)`
    `void` | `authenticationManagerError(ConfigurationException e)`
    `LoginException` | `authErrorHandlingCallback(Throwable t)`
    `LoginException` | `authFailedToCreatePrincipal(Throwable t)`
    `LoginException` | `authFailedToParseSAMLAssertion(Throwable t)`
    `LoginException` | `authInvalidSAMLAssertionBySTS()`
    `LoginException` | `authLoginError(Throwable t)`
    `LoginException` | `authNoCertificateFoundForAliasError(String alias, String name)`
    `LoginException` | `authNullKeyStoreAliasFromSecurityDomainError(String name)`
    `LoginException` | `authNullKeyStoreFromSecurityDomainError(String name)`
    `void` | `authorizationManagerError(ConfigurationException e)`
    `LoginException` | `authSAMLAssertionExpiredError()`
    `void` | `authSAMLAssertionIssuingFailed(Throwable t)`
    `RuntimeException` | `authSAMLAssertionNullOrEmpty()`
    `LoginException` | `authSAMLCredentialNotAvailable()`
    `LoginException` | `authSAMLInvalidSignatureError()`
    `LoginException` | `authSharedCredentialIsNotSAMLCredential(String className)`
    `LoginException` | `authSTSConfigFileNotFound()`
    `RuntimeException` | `authUnableToGetIdentityFromSubject()`
    `RuntimeException` | `authUnableToInstantiateHandler(String token, Throwable t)`
    `RuntimeException` | `cannotGetFreeClientPoolKey(String key)`
    `RuntimeException` | `cannotGetSTSConfigByKey(String key)`
    `RuntimeException` | `cannotGetUsedClientsByKey(String key)`
    `IllegalArgumentException` | `cannotParseParameterValue(String parameter, Throwable e)`
    `RuntimeException` | `cannotSetMaxPoolSizeToNegative(String max)`
    `ProcessingException` | `classNotLoadedError(String fqn)`
    `ConfigurationException` | `configurationError(Throwable t)`
    `RuntimeException` | `configurationFileMissing(String configFile)`
    `ProcessingException` | `couldNotCreateInstance(String fqn, Throwable t)`
    `IllegalStateException` | `couldNotLoadProperties(String configFile)`
    `void` | `couldNotObtainSecurityContext()`
    `IllegalStateException` | `datasourceIsNull()`
    `void` | `debug(String message)`
    `IllegalStateException` | `domMissingDocElementError(String element)`
    `IllegalStateException` | `domMissingElementError(String element)`
    `RuntimeException` | `encryptProcessError(Throwable t)`
    `RuntimeException` | `encryptUnknownAlgoError(String certAlgo)`
    `void` | `error(String message)`
    `void` | `error(Throwable t)`
    `RuntimeException` | `errorUnmarshallingToken(Throwable e)`
    `IllegalStateException` | `fileNotLocated(String policyConfigFileName)`
    `RuntimeException` | `freePoolAlreadyContainsGivenKey(String key)`
    `void` | `info(String message)`
    `RuntimeException` | `injectedValueMissing(String value)` Creates a `RuntimeException` for missing values.
    `IllegalArgumentException` | `invalidArgumentError(String message)`
    `boolean` | `isDebugEnabled()`
    `boolean` | `isInfoEnabled()` Indicates if the logging level is set to INFO.
    `IllegalArgumentException` | `issuerInfoMissingStatusCodeError()`
    `boolean` | `isTraceEnabled()`
    `IllegalStateException` | `jbdcInitializationError(Throwable throwable)`
    `RuntimeException` | `jbossWSAuthorizationFailed()`
    `void` | `jbossWSErrorGettingOperationName(Throwable t)`
    `void` | `jbossWSUnableToCreateBinaryToken(Throwable t)`
    `void` | `jbossWSUnableToCreateSecurityToken()`
    `RuntimeException` | `jbossWSUnableToCreateSSLSocketFactory(Throwable t)`
    `RuntimeException` | `jbossWSUnableToFindSSLSocketFactory()`
    `RuntimeException` | `jbossWSUnableToLoadJBossWSSEConfigError()`
    `void` | `jbossWSUnableToWriteSOAPMessage(Throwable t)`
    `ProcessingException` | `jbossWSUncheckedAndRolesCannotBeTogether()`
    `void` | `jceProviderCouldNotBeLoaded(String name, Throwable t)`
    `TrustKeyConfigurationException` | `keyStoreConfigurationError(Throwable t)` Creates a `TrustKeyConfigurationException` for exceptions raised during the KeyStore configuration.
    `IllegalStateException` | `keyStoreMissingDomainAlias(String domain)`
    `RuntimeException` | `keyStoreNotLocated(String keyStore)` Creates a `RuntimeException` for the case where key store are not located.
    `IllegalStateException` | `keyStoreNullAlias()` Creates a `IllegalStateException` for the case where the alias is null.
    `RuntimeException` | `keyStoreNullEncryptionKeyPass()`
    `void` | `keyStoreNullPublicKeyForAlias(String alias)` Logs a message for the cases where no public key was found for a given alias.
    `RuntimeException` | `keyStoreNullSigningKeyPass()` Creates a `RuntimeException` for the case where the signing key password is null.
    `IllegalStateException` | `keyStoreNullStore()` Creates a `IllegalStateException` for the case where the KeyStore is null.
    `TrustKeyProcessingException` | `keyStoreProcessingError(Throwable t)` Creates a `TrustKeyConfigurationException` for exceptions raised during the KeyStore processing.
    `void` | `keyStoreSetup()` Logs a message during the KeyStore setup.
    `void` | `mappingContextNull()`
    `RuntimeException` | `maximumNumberOfClientsReachedforPool(String max)`
    `RuntimeException` | `notEqualError(String first, String second)`
    `RuntimeException` | `notImplementedYet(String feature)` Creates a `RuntimeException` for not implemented methods or features.
    `IOException` | `notSerializableError(String message)`
    `IllegalArgumentException` | `nullArgumentError(String argument)` Creates an `IllegalArgumentException` for null arguments.
    `RuntimeException` | `nullValueError(String nullValue)` Creates a `RuntimeException` for null values.
    `IllegalStateException` | `optionNotSet(String option)`
    `ParsingException` | `parserError(Throwable t)`
    `ParsingException` | `parserException(Throwable t)`
    `ParsingException` | `parserExpectedEndTag(String tagName)`
    `RuntimeException` | `parserExpectedTag(String tag, String foundElementTag)`
    `ParsingException` | `parserExpectedTextValue(String string)`
    `RuntimeException` | `parserExpectedXSI(String expectedXsi)`
    `RuntimeException` | `parserFailed(String elementName)`
    `RuntimeException` | `parserFeatureNotSupported(String feature)`
    `IllegalStateException` | `parserNullStartElement()`
    `ParsingException` | `parserRequiredAttribute(String string)`
    `ParsingException` | `parserUnableParsingNullToken()`
    `RuntimeException` | `parserUnknownEndElement(String endElementName)` Creates a `RuntimeException` for the case where parser founds a unknown end element.
    `RuntimeException` | `parserUnknownStartElement(String elementName, Location location)`
    `RuntimeException` | `parserUnknownTag(String tag, Location location)`
    `ParsingException` | `parserUnknownXSI(String xsiTypeValue)`
    `ProcessingException` | `processingError(Throwable t)` Creates an `ProcessingException` for generics processing errors.
    `RuntimeException` | `removingNonExistingClientFromUsedClientsByKey(String key)`
    `ProcessingException` | `resourceNotFound(String resource)` Creates an `ProcessingException` for resources that are not found.
    `RuntimeException` | `runtimeException(String msg, Throwable e)`
    `void` | `samlAssertion(String nodeAsString)`
    `void` | `samlAssertionExpired(String id)`
    `ProcessingException` | `samlAssertionExpiredError()`
    `ProcessingException` | `samlAssertionMarshallError(Throwable t)`
    `void` | `samlAssertionPasingFailed(Throwable t)`
    `ProcessingException` | `samlAssertionRevokedCouldNotRenew(String id)`
    `ProcessingException` | `samlAssertionUnmarshallError(Throwable t)`
    `void` | `samlAssertionWithoutExpiration(String id)`
    `ProcessingException` | `samlAssertionWrongAudience(String serviceURL)`
    `void` | `samlBase64DecodingError(Throwable t)`
    `void` | `samlErrorPageForwardError(String errorPage, Throwable t)`
    `RuntimeException` | `samlHandlerAssertionNotFound()`
    `void` | `samlHandlerAuthenticationError(Throwable t)`
    `ProcessingException` | `samlHandlerAuthnRequestIsNull()`
    `RuntimeException` | `samlHandlerChainProcessingError(Throwable t)`
    `void` | `samlHandlerConfigurationError(Throwable t)`
    `void` | `samlHandlerErrorSigningRedirectBindingMessage(Throwable t)`
    `void` | `samlHandlerErrorValidatingSignature(Throwable t)`
    `ProcessingException` | `samlHandlerFailedInResponseToVerificarionError()`
    `void` | `samlHandlerFailedInResponseToVerification(String inResponseTo, String authnRequestId)`
    `ProcessingException` | `samlHandlerIdentityServerNotFoundError()`
    `SecurityException` | `samlHandlerIDPAuthenticationFailedError()`
    `ProcessingException` | `samlHandlerInvalidSignatureError()`
    `void` | `samlHandlerKeyPairNotFound()`
    `ProcessingException` | `samlHandlerKeyPairNotFoundError()`
    `IllegalArgumentException` | `samlHandlerNoAssertionFromIDP()`
    `ProcessingException` | `samlHandlerNullEncryptedAssertion()`
    `ProcessingException` | `samlHandlerPrincipalNotFoundError()`
    `void` | `samlHandlerRoleGeneratorSetupError(Throwable t)`
    `IllegalStateException` | `samlHandlerServiceProviderConfigNotFound()`
    `ProcessingException` | `samlHandlerSignatureNotPresentError()`
    `ProcessingException` | `samlHandlerSignatureValidationError(Throwable t)`
    `SignatureValidationException` | `samlHandlerSignatureValidationFailed()`
    `RuntimeException` | `samlHandlerSigningRedirectBindingMessageError(Throwable t)`
    `ConfigurationException` | `samlHandlerTrustElementMissingError()`
    `void` | `samlIdentityServerActiveSessionCount(int activeSessionCount)`
    `void` | `samlIdentityServerSessionCreated(String id, int activeSessionCount)`
    `void` | `samlIdentityServerSessionDestroyed(String id, int activeSessionCount)`
    `RuntimeException` | `samlIDPConfigurationError(Throwable t)`
    `void` | `samlIDPHandlingSAML11Error(Throwable t)`
    `void` | `samlIDPInstallingDefaultSTSConfig()`
    `void` | `samlIDPRequestProcessingError(Throwable t)`
    `void` | `samlIDPSettingCanonicalizationMethod(String canonicalizationMethod)`
    `void` | `samlIDPUnableToSetParticipantStackUsingDefault(Throwable t)`
    `GeneralSecurityException` | `samlIDPValidationCheckFailed()`
    `IllegalArgumentException` | `samlInvalidProtocolBinding()`
    `IssueInstantMissingException` | `samlIssueInstantMissingError()`
    `IssuerNotTrustedException` | `samlIssuerNotTrustedError(String issuer)`
    `IssuerNotTrustedException` | `samlIssuerNotTrustedException(Throwable t)`
    `void` | `samlLogoutError(Throwable t)`
    `IllegalArgumentException` | `samlMetaDataFailedToCreateCacheDuration(String timeValue)`
    `void` | `samlMetaDataIdentityProviderLoadingError(Throwable t)`
    `ConfigurationException` | `samlMetaDataNoIdentityProviderDefined()`
    `ConfigurationException` | `samlMetaDataNoServiceProviderDefined()`
    `void` | `samlMetaDataServiceProviderLoadingError(Throwable t)`
    `void` | `samlParsingError(Throwable t)`
    `void` | `samlResponseFromIDPParsingFailed()`
    `void` | `samlSecurityTokenAlreadyPersisted(String id)`
    `void` | `samlSecurityTokenNotFoundInRegistry(String id)`
    `RuntimeException` | `samlSPConfigurationError(Throwable t)`
    `void` | `samlSPCouldNotDispatchToLogoutPage(String logOutPage)`
    `void` | `samlSPFallingBackToLocalFormAuthentication()`
    `void` | `samlSPHandleRequestError(Throwable t)`
    `IOException` | `samlSPProcessingExceptionError(Throwable t)`
    `RuntimeException` | `samlSPResponseNotCatalinaResponseError(Object response)`
    `void` | `samlSPSettingCanonicalizationMethod(String canonicalizationMethod)`
    `void` | `samlSPUnableToGetIDPDescriptorFromMetadata()`
    `ConfigurationException` | `securityDomainNotFound()`
    `IllegalArgumentException` | `shouldNotBeTheSameError(String string)` Creates an `IllegalArgumentException` for arguments that should not be the same.
    `void` | `signatureAssertionValidationError(Throwable t)`
    `XMLSignatureException` | `signatureError(Throwable e)` Creates a `ProcessingException` for exceptions raised during signature processing.
    `XMLSignatureException` | `signatureInvalidError(String message, Throwable t)`
    `RuntimeException` | `signatureUnknownAlgo(String algo)`
    `void` | `stsConfigurationFileLoaded(String fileName)`
    `void` | `stsConfigurationFileNotFoundClassLoader(String fileName)`
    `void` | `stsConfigurationFileNotFoundTCL(String fileName)`
    `ConfigurationException` | `stsConfigurationFileParsingError(Throwable t)`
    `WSTrustException` | `stsError(Throwable t)`
    `WSTrustException` | `stsKeyInfoTypeCreationError(Throwable t)`
    `ProcessingException` | `stsNoTokenProviderError(String configuration, String protocolContext)`
    `RuntimeException` | `stsPublicKeyCertError(Throwable t)`
    `RuntimeException` | `stsPublicKeyError(String serviceName, Throwable t)`
    `void` | `stsRevocationRegistryInstantiationError()`
    `void` | `stsRevocationRegistryInvalidType(String registryOption)`
    `void` | `stsRevocationRegistryNotSpecified()`
    `void` | `stsSecretKeyNotEncrypted()`
    `void` | `stsSecurityTokenShouldBeEncrypted()`
    `void` | `stsSecurityTokenSignatureNotVerified()`
    `RuntimeException` | `stsSigningKeyPairError(Throwable t)`
    `void` | `stsTokenRegistryInstantiationError()`
    `void` | `stsTokenRegistryInvalidType(String tokenRegistryOption)`
    `void` | `stsTokenRegistryNotSpecified()`
    `void` | `stsTokenTimeoutNotSpecified()`
    `RuntimeException` | `stsUnableToConstructKeyManagerError(Throwable t)`
    `void` | `stsUsingDefaultConfiguration(String fileName)`
    `void` | `stsWrongAttributeProviderTypeNotInstalled(String attributeProviderClassName)`
    `WebServiceException` | `stsWSConfigurationError(Throwable t)`
    `WebServiceException` | `stsWSError(Throwable t)`
    `WebServiceException` | `stsWSHandlingTokenRequestError(Throwable t)`
    `WSTrustException` | `stsWSInvalidRequestTypeError(String requestType)`
    `WebServiceException` | `stsWSInvalidTokenRequestError()`
    `WebServiceException` | `stsWSResponseWritingError(Throwable t)`
    `RuntimeException` | `systemPropertyMissingError(String property)`
    `void` | `trace(String message)`
    `void` | `trace(String message, Throwable t)`
    `void` | `trace(Throwable t)`
    `void` | `trustKeyManagerCreationError(Throwable t)`
    `TrustKeyConfigurationException` | `trustKeyManagerMissing()`
    `IOException` | `unableLocalAuthentication(Throwable t)`
    `RuntimeException` | `unableToDecodePasswordError(String password)`
    `RuntimeException` | `unknowCredentialType(String name)`
    `RuntimeException` | `unknownObjectType(Object attrValue)`
    `RuntimeException` | `unsupportedRoleType(Object attrValue)`
    `RuntimeException` | `unsupportedType(String name)` Creates an `RuntimeException` for not supported types.
    `void` | `usingLoggerImplementation(String className)` Logs the implementation being used to log messages and exceptions.
    `void` | `warn(String message)`
    `ProcessingException` | `writerInvalidKeyInfoNullContentError()`
    `ProcessingException` | `writerNullValueError(String value)`
    `RuntimeException` | `writerUnknownTypeError(String name)`
    `RuntimeException` | `writerUnsupportedAttributeValueError(String value)`
    `IllegalArgumentException` | `wrongTypeError(String message)`
    `WSTrustException` | `wsTrustClientPublicKeyError()`
    `WSTrustException` | `wsTrustCombinedSecretKeyError(Throwable t)`
    `ProcessingException` | `wsTrustNullCancelTargetError()`
    `ProcessingException` | `wsTrustNullRenewTargetError()`
    `ProcessingException` | `wsTrustNullValidationTargetError()`
    `RuntimeException` | `wsTrustUnableToGetDataTypeFactory(Throwable t)`
    `ProcessingException` | `wsTrustValidationStatusCodeMissing()`
    `RuntimeException` | `xacmlPDPMessageProcessingError(Throwable t)`
    `void` | `xmlCouldNotGetSchema(Throwable t)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### info

          public void info(String message)

      Specified by:
        `info` in interface `PicketLinkLogger`

    - #### debug

          public void debug(String message)

      Specified by:
        `debug` in interface `PicketLinkLogger`

    - #### trace

          public void trace(String message)

      Specified by:
        `trace` in interface `PicketLinkLogger`

    - #### trace

          public void trace(String message,
                            Throwable t)

      Specified by:
        `trace` in interface `PicketLinkLogger`

    - #### trace

          public void trace(Throwable t)

      Specified by:
        `trace` in interface `PicketLinkLogger`

    - #### error

          public void error(Throwable t)

      Specified by:
        `error` in interface `PicketLinkLogger`

    - #### nullArgumentError

          public IllegalArgumentException nullArgumentError(String argument)

      Description copied from interface: `PicketLinkLogger`

      Creates an `IllegalArgumentException` for null arguments.

      Specified by:
        `nullArgumentError` in interface `PicketLinkLogger`
      Returns:

    - #### shouldNotBeTheSameError

          public IllegalArgumentException shouldNotBeTheSameError(String string)

      Description copied from interface: `PicketLinkLogger`

      Creates an `IllegalArgumentException` for arguments that should not be the same.

      Specified by:
        `shouldNotBeTheSameError` in interface `PicketLinkLogger`
      Returns:

    - #### resourceNotFound

          public ProcessingException resourceNotFound(String resource)

      Description copied from interface: `PicketLinkLogger`

      Creates an `ProcessingException` for resources that are not found.

      Specified by:
        `resourceNotFound` in interface `PicketLinkLogger`
      Returns:

    - #### processingError

          public ProcessingException processingError(Throwable t)

      Description copied from interface: `PicketLinkLogger`

      Creates an `ProcessingException` for generics processing errors.

      Specified by:
        `processingError` in interface `PicketLinkLogger`
      Returns:

    - #### unsupportedType

          public RuntimeException unsupportedType(String name)

      Description copied from interface: `PicketLinkLogger`

      Creates an `RuntimeException` for not supported types.

      Specified by:
        `unsupportedType` in interface `PicketLinkLogger`
      Returns:

    - #### signatureError

          public XMLSignatureException signatureError(Throwable e)

      Description copied from interface: `PicketLinkLogger`

      Creates a `ProcessingException` for exceptions raised during signature processing.

      Specified by:
        `signatureError` in interface `PicketLinkLogger`
      Returns:

    - #### nullValueError

          public RuntimeException nullValueError(String nullValue)

      Description copied from interface: `PicketLinkLogger`

      Creates a `RuntimeException` for null values.

      Specified by:
        `nullValueError` in interface `PicketLinkLogger`
      Returns:

    - #### notImplementedYet

          public RuntimeException notImplementedYet(String feature)

      Description copied from interface: `PicketLinkLogger`

      Creates a `RuntimeException` for not implemented methods or features.

      Specified by:
        `notImplementedYet` in interface `PicketLinkLogger`
      Returns:

    - #### auditNullAuditManager

          public IllegalStateException auditNullAuditManager()

      Description copied from interface: `PicketLinkLogger`

      Creates a `IllegalStateException` for the case the Audit Manager is null.

      Specified by:
        `auditNullAuditManager` in interface `PicketLinkLogger`
      Returns:

    - #### isInfoEnabled

          public boolean isInfoEnabled()

      Description copied from interface: `PicketLinkLogger`

      Indicates if the logging level is set to INFO.

      Specified by:
        `isInfoEnabled` in interface `PicketLinkLogger`
      Returns:

    - #### auditEvent

          public void auditEvent(String auditEvent)

      Description copied from interface: `PicketLinkLogger`

      Logs a PicketLink Audit Event.

      Specified by:
        `auditEvent` in interface `PicketLinkLogger`

    - #### injectedValueMissing

          public RuntimeException injectedValueMissing(String value)

      Description copied from interface: `PicketLinkLogger`

      Creates a `RuntimeException` for missing values.

      Specified by:
        `injectedValueMissing` in interface `PicketLinkLogger`
      Returns:

    - #### keyStoreSetup

          public void keyStoreSetup()

      Description copied from interface: `PicketLinkLogger`

      Logs a message during the KeyStore setup.

      Specified by:
        `keyStoreSetup` in interface `PicketLinkLogger`

    - #### keyStoreNullStore

          public IllegalStateException keyStoreNullStore()

      Description copied from interface: `PicketLinkLogger`

      Creates a `IllegalStateException` for the case where the KeyStore is null.

      Specified by:
        `keyStoreNullStore` in interface `PicketLinkLogger`
      Returns:

    - #### keyStoreNullPublicKeyForAlias

          public void keyStoreNullPublicKeyForAlias(String alias)

      Description copied from interface: `PicketLinkLogger`

      Logs a message for the cases where no public key was found for a given alias.

      Specified by:
        `keyStoreNullPublicKeyForAlias` in interface `PicketLinkLogger`

    - #### keyStoreConfigurationError

          public TrustKeyConfigurationException keyStoreConfigurationError(Throwable t)

      Description copied from interface: `PicketLinkLogger`

      Creates a `TrustKeyConfigurationException` for exceptions raised during the KeyStore configuration.

      Specified by:
        `keyStoreConfigurationError` in interface `PicketLinkLogger`
      Returns:

    - #### keyStoreProcessingError

          public TrustKeyProcessingException keyStoreProcessingError(Throwable t)

      Description copied from interface: `PicketLinkLogger`

      Creates a `TrustKeyConfigurationException` for exceptions raised during the KeyStore processing.

      Specified by:
        `keyStoreProcessingError` in interface `PicketLinkLogger`
      Returns:

    - #### keyStoreMissingDomainAlias

          public IllegalStateException keyStoreMissingDomainAlias(String domain)

      Specified by:
        `keyStoreMissingDomainAlias` in interface `PicketLinkLogger`
      Returns:

    - #### keyStoreNullSigningKeyPass

          public RuntimeException keyStoreNullSigningKeyPass()

      Description copied from interface: `PicketLinkLogger`

      Creates a `RuntimeException` for the case where the signing key password is null.

      Specified by:
        `keyStoreNullSigningKeyPass` in interface `PicketLinkLogger`
      Returns:

    - #### keyStoreNullEncryptionKeyPass

          public RuntimeException keyStoreNullEncryptionKeyPass()

      Specified by:
        `keyStoreNullEncryptionKeyPass` in interface `PicketLinkLogger`

    - #### keyStoreNotLocated

          public RuntimeException keyStoreNotLocated(String keyStore)

      Description copied from interface: `PicketLinkLogger`

      Creates a `RuntimeException` for the case where key store are not located.

      Specified by:
        `keyStoreNotLocated` in interface `PicketLinkLogger`
      Returns:

    - #### keyStoreNullAlias

          public IllegalStateException keyStoreNullAlias()

      Description copied from interface: `PicketLinkLogger`

      Creates a `IllegalStateException` for the case where the alias is null.

      Specified by:
        `keyStoreNullAlias` in interface `PicketLinkLogger`
      Returns:

    - #### parserUnknownEndElement

          public RuntimeException parserUnknownEndElement(String endElementName)

      Description copied from interface: `PicketLinkLogger`

      Creates a `RuntimeException` for the case where parser founds a unknown end element.

      Specified by:
        `parserUnknownEndElement` in interface `PicketLinkLogger`
      Returns:

    - #### parserUnknownTag

          public RuntimeException parserUnknownTag(String tag,
                                                   Location location)

      Specified by:
        `parserUnknownTag` in interface `PicketLinkLogger`
      Returns:

    - #### parserRequiredAttribute

          public ParsingException parserRequiredAttribute(String string)

      Specified by:
        `parserRequiredAttribute` in interface `PicketLinkLogger`
      Returns:

    - #### parserUnknownStartElement

          public RuntimeException parserUnknownStartElement(String elementName,
                                                            Location location)

      Specified by:
        `parserUnknownStartElement` in interface `PicketLinkLogger`
      Returns:

    - #### parserNullStartElement

          public IllegalStateException parserNullStartElement()

      Specified by:
        `parserNullStartElement` in interface `PicketLinkLogger`
      Returns:

    - #### parserUnknownXSI

          public ParsingException parserUnknownXSI(String xsiTypeValue)

      Specified by:
        `parserUnknownXSI` in interface `PicketLinkLogger`
      Returns:

    - #### parserExpectedEndTag

          public ParsingException parserExpectedEndTag(String tagName)

      Specified by:
        `parserExpectedEndTag` in interface `PicketLinkLogger`
      Returns:

    - #### parserException

          public ParsingException parserException(Throwable t)

      Specified by:
        `parserException` in interface `PicketLinkLogger`
      Returns:

    - #### parserExpectedTextValue

          public ParsingException parserExpectedTextValue(String string)

      Specified by:
        `parserExpectedTextValue` in interface `PicketLinkLogger`
      Returns:

    - #### parserExpectedXSI

          public RuntimeException parserExpectedXSI(String expectedXsi)

      Specified by:
        `parserExpectedXSI` in interface `PicketLinkLogger`
      Returns:

    - #### parserExpectedTag

          public RuntimeException parserExpectedTag(String tag,
                                                    String foundElementTag)

      Specified by:
        `parserExpectedTag` in interface `PicketLinkLogger`
      Returns:

    - #### parserFailed

          public RuntimeException parserFailed(String elementName)

      Specified by:
        `parserFailed` in interface `PicketLinkLogger`
      Returns:

    - #### parserUnableParsingNullToken

          public ParsingException parserUnableParsingNullToken()

      Specified by:
        `parserUnableParsingNullToken` in interface `PicketLinkLogger`
      Returns:

    - #### parserError

          public ParsingException parserError(Throwable t)

      Specified by:
        `parserError` in interface `PicketLinkLogger`
      Returns:

    - #### xacmlPDPMessageProcessingError

          public RuntimeException xacmlPDPMessageProcessingError(Throwable t)

      Specified by:
        `xacmlPDPMessageProcessingError` in interface `PicketLinkLogger`
      Returns:

    - #### fileNotLocated

          public IllegalStateException fileNotLocated(String policyConfigFileName)

      Specified by:
        `fileNotLocated` in interface `PicketLinkLogger`
      Returns:

    - #### optionNotSet

          public IllegalStateException optionNotSet(String option)

      Specified by:
        `optionNotSet` in interface `PicketLinkLogger`
      Returns:

    - #### stsTokenRegistryNotSpecified

          public void stsTokenRegistryNotSpecified()

      Specified by:
        `stsTokenRegistryNotSpecified` in interface `PicketLinkLogger`

    - #### stsTokenRegistryInvalidType

          public void stsTokenRegistryInvalidType(String tokenRegistryOption)

      Specified by:
        `stsTokenRegistryInvalidType` in interface `PicketLinkLogger`

    - #### stsTokenRegistryInstantiationError

          public void stsTokenRegistryInstantiationError()

      Specified by:
        `stsTokenRegistryInstantiationError` in interface `PicketLinkLogger`

    - #### stsRevocationRegistryNotSpecified

          public void stsRevocationRegistryNotSpecified()

      Specified by:
        `stsRevocationRegistryNotSpecified` in interface `PicketLinkLogger`

    - #### stsRevocationRegistryInvalidType

          public void stsRevocationRegistryInvalidType(String registryOption)

      Specified by:
        `stsRevocationRegistryInvalidType` in interface `PicketLinkLogger`

    - #### stsRevocationRegistryInstantiationError

          public void stsRevocationRegistryInstantiationError()

      Specified by:
        `stsRevocationRegistryInstantiationError` in interface `PicketLinkLogger`

    - #### samlAssertionExpiredError

          public ProcessingException samlAssertionExpiredError()

      Specified by:
        `samlAssertionExpiredError` in interface `PicketLinkLogger`
      Returns:

    - #### assertionInvalidError

          public ProcessingException assertionInvalidError()

      Specified by:
        `assertionInvalidError` in interface `PicketLinkLogger`
      Returns:

    - #### writerUnknownTypeError

          public RuntimeException writerUnknownTypeError(String name)

      Specified by:
        `writerUnknownTypeError` in interface `PicketLinkLogger`
      Returns:

    - #### writerNullValueError

          public ProcessingException writerNullValueError(String value)

      Specified by:
        `writerNullValueError` in interface `PicketLinkLogger`
      Returns:

    - #### writerUnsupportedAttributeValueError

          public RuntimeException writerUnsupportedAttributeValueError(String value)

      Specified by:
        `writerUnsupportedAttributeValueError` in interface `PicketLinkLogger`
      Returns:

    - #### issuerInfoMissingStatusCodeError

          public IllegalArgumentException issuerInfoMissingStatusCodeError()

      Specified by:
        `issuerInfoMissingStatusCodeError` in interface `PicketLinkLogger`
      Returns:

    - #### classNotLoadedError

          public ProcessingException classNotLoadedError(String fqn)

      Specified by:
        `classNotLoadedError` in interface `PicketLinkLogger`
      Returns:

    - #### couldNotCreateInstance

          public ProcessingException couldNotCreateInstance(String fqn,
                                                            Throwable t)

      Specified by:
        `couldNotCreateInstance` in interface `PicketLinkLogger`
      Returns:

    - #### systemPropertyMissingError

          public RuntimeException systemPropertyMissingError(String property)

      Specified by:
        `systemPropertyMissingError` in interface `PicketLinkLogger`
      Returns:

    - #### samlMetaDataIdentityProviderLoadingError

          public void samlMetaDataIdentityProviderLoadingError(Throwable t)

      Specified by:
        `samlMetaDataIdentityProviderLoadingError` in interface `PicketLinkLogger`

    - #### samlMetaDataServiceProviderLoadingError

          public void samlMetaDataServiceProviderLoadingError(Throwable t)

      Specified by:
        `samlMetaDataServiceProviderLoadingError` in interface `PicketLinkLogger`

    - #### signatureAssertionValidationError

          public void signatureAssertionValidationError(Throwable t)

      Specified by:
        `signatureAssertionValidationError` in interface `PicketLinkLogger`

    - #### samlAssertionExpired

          public void samlAssertionExpired(String id)

      Specified by:
        `samlAssertionExpired` in interface `PicketLinkLogger`

    - #### unknownObjectType

          public RuntimeException unknownObjectType(Object attrValue)

      Specified by:
        `unknownObjectType` in interface `PicketLinkLogger`
      Returns:

    - #### configurationError

          public ConfigurationException configurationError(Throwable t)

      Specified by:
        `configurationError` in interface `PicketLinkLogger`
      Returns:

    - #### signatureUnknownAlgo

          public RuntimeException signatureUnknownAlgo(String algo)

      Specified by:
        `signatureUnknownAlgo` in interface `PicketLinkLogger`
      Returns:

    - #### invalidArgumentError

          public IllegalArgumentException invalidArgumentError(String message)

      Specified by:
        `invalidArgumentError` in interface `PicketLinkLogger`
      Returns:

    - #### stsNoTokenProviderError

          public ProcessingException stsNoTokenProviderError(String configuration,
                                                             String protocolContext)

      Specified by:
        `stsNoTokenProviderError` in interface `PicketLinkLogger`
      Returns:

    - #### stsConfigurationFileNotFoundTCL

          public void stsConfigurationFileNotFoundTCL(String fileName)

      Specified by:
        `stsConfigurationFileNotFoundTCL` in interface `PicketLinkLogger`

    - #### stsConfigurationFileNotFoundClassLoader

          public void stsConfigurationFileNotFoundClassLoader(String fileName)

      Specified by:
        `stsConfigurationFileNotFoundClassLoader` in interface `PicketLinkLogger`

    - #### stsUsingDefaultConfiguration

          public void stsUsingDefaultConfiguration(String fileName)

      Specified by:
        `stsUsingDefaultConfiguration` in interface `PicketLinkLogger`

    - #### stsConfigurationFileLoaded

          public void stsConfigurationFileLoaded(String fileName)

      Specified by:
        `stsConfigurationFileLoaded` in interface `PicketLinkLogger`

    - #### stsConfigurationFileParsingError

          public ConfigurationException stsConfigurationFileParsingError(Throwable t)

      Specified by:
        `stsConfigurationFileParsingError` in interface `PicketLinkLogger`
      Returns:

    - #### notSerializableError

          public IOException notSerializableError(String message)

      Specified by:
        `notSerializableError` in interface `PicketLinkLogger`
      Returns:

    - #### trustKeyManagerCreationError

          public void trustKeyManagerCreationError(Throwable t)

      Specified by:
        `trustKeyManagerCreationError` in interface `PicketLinkLogger`

    - #### error

          public void error(String message)

      Specified by:
        `error` in interface `PicketLinkLogger`

    - #### xmlCouldNotGetSchema

          public void xmlCouldNotGetSchema(Throwable t)

      Specified by:
        `xmlCouldNotGetSchema` in interface `PicketLinkLogger`

    - #### isTraceEnabled

          public boolean isTraceEnabled()

      Specified by:
        `isTraceEnabled` in interface `PicketLinkLogger`
      Returns:

    - #### isDebugEnabled

          public boolean isDebugEnabled()

      Specified by:
        `isDebugEnabled` in interface `PicketLinkLogger`
      Returns:

    - #### jceProviderCouldNotBeLoaded

          public void jceProviderCouldNotBeLoaded(String name,
                                                  Throwable t)

      Specified by:
        `jceProviderCouldNotBeLoaded` in interface `PicketLinkLogger`

    - #### writerInvalidKeyInfoNullContentError

          public ProcessingException writerInvalidKeyInfoNullContentError()

      Specified by:
        `writerInvalidKeyInfoNullContentError` in interface `PicketLinkLogger`
      Returns:

    - #### notEqualError

          public RuntimeException notEqualError(String first,
                                                String second)

      Specified by:
        `notEqualError` in interface `PicketLinkLogger`
      Returns:

    - #### wrongTypeError

          public IllegalArgumentException wrongTypeError(String message)

      Specified by:
        `wrongTypeError` in interface `PicketLinkLogger`
      Returns:

    - #### encryptUnknownAlgoError

          public RuntimeException encryptUnknownAlgoError(String certAlgo)

      Specified by:
        `encryptUnknownAlgoError` in interface `PicketLinkLogger`
      Returns:

    - #### domMissingDocElementError

          public IllegalStateException domMissingDocElementError(String element)

      Specified by:
        `domMissingDocElementError` in interface `PicketLinkLogger`
      Returns:

    - #### domMissingElementError

          public IllegalStateException domMissingElementError(String element)

      Specified by:
        `domMissingElementError` in interface `PicketLinkLogger`
      Returns:

    - #### stsWSInvalidTokenRequestError

          public WebServiceException stsWSInvalidTokenRequestError()

      Specified by:
        `stsWSInvalidTokenRequestError` in interface `PicketLinkLogger`
      Returns:

    - #### stsWSError

          public WebServiceException stsWSError(Throwable t)

      Specified by:
        `stsWSError` in interface `PicketLinkLogger`
      Returns:

    - #### stsWSConfigurationError

          public WebServiceException stsWSConfigurationError(Throwable t)

      Specified by:
        `stsWSConfigurationError` in interface `PicketLinkLogger`
      Returns:

    - #### stsWSInvalidRequestTypeError

          public WSTrustException stsWSInvalidRequestTypeError(String requestType)

      Specified by:
        `stsWSInvalidRequestTypeError` in interface `PicketLinkLogger`
      Returns:

    - #### stsWSHandlingTokenRequestError

          public WebServiceException stsWSHandlingTokenRequestError(Throwable t)

      Specified by:
        `stsWSHandlingTokenRequestError` in interface `PicketLinkLogger`
      Returns:

    - #### stsWSResponseWritingError

          public WebServiceException stsWSResponseWritingError(Throwable t)

      Specified by:
        `stsWSResponseWritingError` in interface `PicketLinkLogger`
      Returns:

    - #### stsUnableToConstructKeyManagerError

          public RuntimeException stsUnableToConstructKeyManagerError(Throwable t)

      Specified by:
        `stsUnableToConstructKeyManagerError` in interface `PicketLinkLogger`
      Returns:

    - #### stsPublicKeyError

          public RuntimeException stsPublicKeyError(String serviceName,
                                                    Throwable t)

      Specified by:
        `stsPublicKeyError` in interface `PicketLinkLogger`
      Returns:

    - #### stsSigningKeyPairError

          public RuntimeException stsSigningKeyPairError(Throwable t)

      Specified by:
        `stsSigningKeyPairError` in interface `PicketLinkLogger`
      Returns:

    - #### stsPublicKeyCertError

          public RuntimeException stsPublicKeyCertError(Throwable t)

      Specified by:
        `stsPublicKeyCertError` in interface `PicketLinkLogger`
      Returns:

    - #### stsTokenTimeoutNotSpecified

          public void stsTokenTimeoutNotSpecified()

      Specified by:
        `stsTokenTimeoutNotSpecified` in interface `PicketLinkLogger`

    - #### wsTrustCombinedSecretKeyError

          public WSTrustException wsTrustCombinedSecretKeyError(Throwable t)

      Specified by:
        `wsTrustCombinedSecretKeyError` in interface `PicketLinkLogger`
      Returns:

    - #### wsTrustClientPublicKeyError

          public WSTrustException wsTrustClientPublicKeyError()

      Specified by:
        `wsTrustClientPublicKeyError` in interface `PicketLinkLogger`
      Returns:

    - #### stsError

          public WSTrustException stsError(Throwable t)

      Specified by:
        `stsError` in interface `PicketLinkLogger`
      Returns:

    - #### signatureInvalidError

          public XMLSignatureException signatureInvalidError(String message,
                                                             Throwable t)

      Specified by:
        `signatureInvalidError` in interface `PicketLinkLogger`
      Returns:

    - #### stsSecurityTokenSignatureNotVerified

          public void stsSecurityTokenSignatureNotVerified()

      Specified by:
        `stsSecurityTokenSignatureNotVerified` in interface `PicketLinkLogger`

    - #### encryptProcessError

          public RuntimeException encryptProcessError(Throwable t)

      Specified by:
        `encryptProcessError` in interface `PicketLinkLogger`
      Returns:

    - #### stsSecurityTokenShouldBeEncrypted

          public void stsSecurityTokenShouldBeEncrypted()

      Specified by:
        `stsSecurityTokenShouldBeEncrypted` in interface `PicketLinkLogger`

    - #### unableToDecodePasswordError

          public RuntimeException unableToDecodePasswordError(String password)

      Specified by:
        `unableToDecodePasswordError` in interface `PicketLinkLogger`
      Returns:

    - #### couldNotLoadProperties

          public IllegalStateException couldNotLoadProperties(String configFile)

      Specified by:
        `couldNotLoadProperties` in interface `PicketLinkLogger`
      Returns:

    - #### stsKeyInfoTypeCreationError

          public WSTrustException stsKeyInfoTypeCreationError(Throwable t)

      Specified by:
        `stsKeyInfoTypeCreationError` in interface `PicketLinkLogger`
      Returns:

    - #### stsSecretKeyNotEncrypted

          public void stsSecretKeyNotEncrypted()

      Specified by:
        `stsSecretKeyNotEncrypted` in interface `PicketLinkLogger`

    - #### authCouldNotIssueSAMLToken

          public LoginException authCouldNotIssueSAMLToken()

      Specified by:
        `authCouldNotIssueSAMLToken` in interface `PicketLinkLogger`
      Returns:

    - #### authLoginError

          public LoginException authLoginError(Throwable t)

      Specified by:
        `authLoginError` in interface `PicketLinkLogger`
      Returns:

    - #### authCouldNotCreateWSTrustClient

          public IllegalStateException authCouldNotCreateWSTrustClient(Throwable t)

      Specified by:
        `authCouldNotCreateWSTrustClient` in interface `PicketLinkLogger`
      Returns:

    - #### samlAssertionWithoutExpiration

          public void samlAssertionWithoutExpiration(String id)

      Specified by:
        `samlAssertionWithoutExpiration` in interface `PicketLinkLogger`

    - #### authCouldNotValidateSAMLToken

          public LoginException authCouldNotValidateSAMLToken(Element token)

      Specified by:
        `authCouldNotValidateSAMLToken` in interface `PicketLinkLogger`
      Returns:

    - #### authCouldNotLocateSecurityToken

          public LoginException authCouldNotLocateSecurityToken()

      Specified by:
        `authCouldNotLocateSecurityToken` in interface `PicketLinkLogger`
      Returns:

    - #### wsTrustNullCancelTargetError

          public ProcessingException wsTrustNullCancelTargetError()

      Specified by:
        `wsTrustNullCancelTargetError` in interface `PicketLinkLogger`
      Returns:

    - #### samlAssertionMarshallError

          public ProcessingException samlAssertionMarshallError(Throwable t)

      Specified by:
        `samlAssertionMarshallError` in interface `PicketLinkLogger`
      Returns:

    - #### wsTrustNullRenewTargetError

          public ProcessingException wsTrustNullRenewTargetError()

      Specified by:
        `wsTrustNullRenewTargetError` in interface `PicketLinkLogger`
      Returns:

    - #### samlAssertionUnmarshallError

          public ProcessingException samlAssertionUnmarshallError(Throwable t)

      Specified by:
        `samlAssertionUnmarshallError` in interface `PicketLinkLogger`
      Returns:

    - #### samlAssertionRevokedCouldNotRenew

          public ProcessingException samlAssertionRevokedCouldNotRenew(String id)

      Specified by:
        `samlAssertionRevokedCouldNotRenew` in interface `PicketLinkLogger`
      Returns:

    - #### wsTrustNullValidationTargetError

          public ProcessingException wsTrustNullValidationTargetError()

      Specified by:
        `wsTrustNullValidationTargetError` in interface `PicketLinkLogger`
      Returns:

    - #### stsWrongAttributeProviderTypeNotInstalled

          public void stsWrongAttributeProviderTypeNotInstalled(String attributeProviderClassName)

      Specified by:
        `stsWrongAttributeProviderTypeNotInstalled` in interface `PicketLinkLogger`

    - #### attributeProviderInstationError

          public void attributeProviderInstationError(Throwable t)

      Specified by:
        `attributeProviderInstationError` in interface `PicketLinkLogger`

    - #### samlAssertion

          public void samlAssertion(String nodeAsString)

      Specified by:
        `samlAssertion` in interface `PicketLinkLogger`

    - #### wsTrustUnableToGetDataTypeFactory

          public RuntimeException wsTrustUnableToGetDataTypeFactory(Throwable t)

      Specified by:
        `wsTrustUnableToGetDataTypeFactory` in interface `PicketLinkLogger`
      Returns:

    - #### wsTrustValidationStatusCodeMissing

          public ProcessingException wsTrustValidationStatusCodeMissing()

      Specified by:
        `wsTrustValidationStatusCodeMissing` in interface `PicketLinkLogger`
      Returns:

    - #### samlIdentityServerActiveSessionCount

          public void samlIdentityServerActiveSessionCount(int activeSessionCount)

      Specified by:
        `samlIdentityServerActiveSessionCount` in interface `PicketLinkLogger`

    - #### samlIdentityServerSessionCreated

          public void samlIdentityServerSessionCreated(String id,
                                                       int activeSessionCount)

      Specified by:
        `samlIdentityServerSessionCreated` in interface `PicketLinkLogger`

    - #### samlIdentityServerSessionDestroyed

          public void samlIdentityServerSessionDestroyed(String id,
                                                         int activeSessionCount)

      Specified by:
        `samlIdentityServerSessionDestroyed` in interface `PicketLinkLogger`

    - #### unknowCredentialType

          public RuntimeException unknowCredentialType(String name)

      Specified by:
        `unknowCredentialType` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerRoleGeneratorSetupError

          public void samlHandlerRoleGeneratorSetupError(Throwable t)

      Specified by:
        `samlHandlerRoleGeneratorSetupError` in interface `PicketLinkLogger`

    - #### samlHandlerAssertionNotFound

          public RuntimeException samlHandlerAssertionNotFound()

      Specified by:
        `samlHandlerAssertionNotFound` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerAuthnRequestIsNull

          public ProcessingException samlHandlerAuthnRequestIsNull()

      Specified by:
        `samlHandlerAuthnRequestIsNull` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerAuthenticationError

          public void samlHandlerAuthenticationError(Throwable t)

      Specified by:
        `samlHandlerAuthenticationError` in interface `PicketLinkLogger`

    - #### samlHandlerNoAssertionFromIDP

          public IllegalArgumentException samlHandlerNoAssertionFromIDP()

      Specified by:
        `samlHandlerNoAssertionFromIDP` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerNullEncryptedAssertion

          public ProcessingException samlHandlerNullEncryptedAssertion()

      Specified by:
        `samlHandlerNullEncryptedAssertion` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerIDPAuthenticationFailedError

          public SecurityException samlHandlerIDPAuthenticationFailedError()

      Specified by:
        `samlHandlerIDPAuthenticationFailedError` in interface `PicketLinkLogger`
      Returns:

    - #### assertionExpiredError

          public ProcessingException assertionExpiredError(AssertionExpiredException aee)

      Specified by:
        `assertionExpiredError` in interface `PicketLinkLogger`
      Returns:

    - #### unsupportedRoleType

          public RuntimeException unsupportedRoleType(Object attrValue)

      Specified by:
        `unsupportedRoleType` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerFailedInResponseToVerification

          public void samlHandlerFailedInResponseToVerification(String inResponseTo,
                                                                String authnRequestId)

      Specified by:
        `samlHandlerFailedInResponseToVerification` in interface `PicketLinkLogger`

    - #### samlHandlerFailedInResponseToVerificarionError

          public ProcessingException samlHandlerFailedInResponseToVerificarionError()

      Specified by:
        `samlHandlerFailedInResponseToVerificarionError` in interface `PicketLinkLogger`
      Returns:

    - #### samlIssuerNotTrustedError

          public IssuerNotTrustedException samlIssuerNotTrustedError(String issuer)

      Specified by:
        `samlIssuerNotTrustedError` in interface `PicketLinkLogger`
      Returns:

    - #### samlIssuerNotTrustedException

          public IssuerNotTrustedException samlIssuerNotTrustedException(Throwable t)

      Specified by:
        `samlIssuerNotTrustedException` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerTrustElementMissingError

          public ConfigurationException samlHandlerTrustElementMissingError()

      Specified by:
        `samlHandlerTrustElementMissingError` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerIdentityServerNotFoundError

          public ProcessingException samlHandlerIdentityServerNotFoundError()

      Specified by:
        `samlHandlerIdentityServerNotFoundError` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerPrincipalNotFoundError

          public ProcessingException samlHandlerPrincipalNotFoundError()

      Specified by:
        `samlHandlerPrincipalNotFoundError` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerKeyPairNotFound

          public void samlHandlerKeyPairNotFound()

      Specified by:
        `samlHandlerKeyPairNotFound` in interface `PicketLinkLogger`

    - #### samlHandlerKeyPairNotFoundError

          public ProcessingException samlHandlerKeyPairNotFoundError()

      Specified by:
        `samlHandlerKeyPairNotFoundError` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerErrorSigningRedirectBindingMessage

          public void samlHandlerErrorSigningRedirectBindingMessage(Throwable t)

      Specified by:
        `samlHandlerErrorSigningRedirectBindingMessage` in interface `PicketLinkLogger`

    - #### samlHandlerSigningRedirectBindingMessageError

          public RuntimeException samlHandlerSigningRedirectBindingMessageError(Throwable t)

      Specified by:
        `samlHandlerSigningRedirectBindingMessageError` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerSignatureValidationFailed

          public SignatureValidationException samlHandlerSignatureValidationFailed()

      Specified by:
        `samlHandlerSignatureValidationFailed` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerErrorValidatingSignature

          public void samlHandlerErrorValidatingSignature(Throwable t)

      Specified by:
        `samlHandlerErrorValidatingSignature` in interface `PicketLinkLogger`

    - #### samlHandlerInvalidSignatureError

          public ProcessingException samlHandlerInvalidSignatureError()

      Specified by:
        `samlHandlerInvalidSignatureError` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerSignatureNotPresentError

          public ProcessingException samlHandlerSignatureNotPresentError()

      Specified by:
        `samlHandlerSignatureNotPresentError` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerSignatureValidationError

          public ProcessingException samlHandlerSignatureValidationError(Throwable t)

      Specified by:
        `samlHandlerSignatureValidationError` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerChainProcessingError

          public RuntimeException samlHandlerChainProcessingError(Throwable t)

      Specified by:
        `samlHandlerChainProcessingError` in interface `PicketLinkLogger`
      Returns:

    - #### trustKeyManagerMissing

          public TrustKeyConfigurationException trustKeyManagerMissing()

      Specified by:
        `trustKeyManagerMissing` in interface `PicketLinkLogger`
      Returns:

    - #### samlBase64DecodingError

          public void samlBase64DecodingError(Throwable t)

      Specified by:
        `samlBase64DecodingError` in interface `PicketLinkLogger`

    - #### samlParsingError

          public void samlParsingError(Throwable t)

      Specified by:
        `samlParsingError` in interface `PicketLinkLogger`

    - #### mappingContextNull

          public void mappingContextNull()

      Specified by:
        `mappingContextNull` in interface `PicketLinkLogger`

    - #### attributeManagerError

          public void attributeManagerError(Throwable t)

      Specified by:
        `attributeManagerError` in interface `PicketLinkLogger`

    - #### couldNotObtainSecurityContext

          public void couldNotObtainSecurityContext()

      Specified by:
        `couldNotObtainSecurityContext` in interface `PicketLinkLogger`

    - #### authFailedToCreatePrincipal

          public LoginException authFailedToCreatePrincipal(Throwable t)

      Specified by:
        `authFailedToCreatePrincipal` in interface `PicketLinkLogger`
      Returns:

    - #### authSharedCredentialIsNotSAMLCredential

          public LoginException authSharedCredentialIsNotSAMLCredential(String className)

      Specified by:
        `authSharedCredentialIsNotSAMLCredential` in interface `PicketLinkLogger`
      Returns:

    - #### authSTSConfigFileNotFound

          public LoginException authSTSConfigFileNotFound()

      Specified by:
        `authSTSConfigFileNotFound` in interface `PicketLinkLogger`
      Returns:

    - #### authErrorHandlingCallback

          public LoginException authErrorHandlingCallback(Throwable t)

      Specified by:
        `authErrorHandlingCallback` in interface `PicketLinkLogger`
      Returns:

    - #### authInvalidSAMLAssertionBySTS

          public LoginException authInvalidSAMLAssertionBySTS()

      Specified by:
        `authInvalidSAMLAssertionBySTS` in interface `PicketLinkLogger`
      Returns:

    - #### authAssertionValidationError

          public LoginException authAssertionValidationError(Throwable t)

      Specified by:
        `authAssertionValidationError` in interface `PicketLinkLogger`
      Returns:

    - #### authFailedToParseSAMLAssertion

          public LoginException authFailedToParseSAMLAssertion(Throwable t)

      Specified by:
        `authFailedToParseSAMLAssertion` in interface `PicketLinkLogger`
      Returns:

    - #### samlAssertionPasingFailed

          public void samlAssertionPasingFailed(Throwable t)

      Specified by:
        `samlAssertionPasingFailed` in interface `PicketLinkLogger`

    - #### authNullKeyStoreFromSecurityDomainError

          public LoginException authNullKeyStoreFromSecurityDomainError(String name)

      Specified by:
        `authNullKeyStoreFromSecurityDomainError` in interface `PicketLinkLogger`

    - #### authNullKeyStoreAliasFromSecurityDomainError

          public LoginException authNullKeyStoreAliasFromSecurityDomainError(String name)

      Specified by:
        `authNullKeyStoreAliasFromSecurityDomainError` in interface `PicketLinkLogger`

    - #### authNoCertificateFoundForAliasError

          public LoginException authNoCertificateFoundForAliasError(String alias,
                                                                    String name)

      Specified by:
        `authNoCertificateFoundForAliasError` in interface `PicketLinkLogger`

    - #### authSAMLInvalidSignatureError

          public LoginException authSAMLInvalidSignatureError()

      Specified by:
        `authSAMLInvalidSignatureError` in interface `PicketLinkLogger`

    - #### authSAMLAssertionExpiredError

          public LoginException authSAMLAssertionExpiredError()

      Specified by:
        `authSAMLAssertionExpiredError` in interface `PicketLinkLogger`

    - #### authSAMLAssertionIssuingFailed

          public void authSAMLAssertionIssuingFailed(Throwable t)

      Specified by:
        `authSAMLAssertionIssuingFailed` in interface `PicketLinkLogger`

    - #### jbossWSUnableToCreateBinaryToken

          public void jbossWSUnableToCreateBinaryToken(Throwable t)

      Specified by:
        `jbossWSUnableToCreateBinaryToken` in interface `PicketLinkLogger`

    - #### jbossWSUnableToCreateSecurityToken

          public void jbossWSUnableToCreateSecurityToken()

      Specified by:
        `jbossWSUnableToCreateSecurityToken` in interface `PicketLinkLogger`

    - #### jbossWSUnableToWriteSOAPMessage

          public void jbossWSUnableToWriteSOAPMessage(Throwable t)

      Specified by:
        `jbossWSUnableToWriteSOAPMessage` in interface `PicketLinkLogger`

    - #### jbossWSUnableToLoadJBossWSSEConfigError

          public RuntimeException jbossWSUnableToLoadJBossWSSEConfigError()

      Specified by:
        `jbossWSUnableToLoadJBossWSSEConfigError` in interface `PicketLinkLogger`
      Returns:

    - #### jbossWSAuthorizationFailed

          public RuntimeException jbossWSAuthorizationFailed()

      Specified by:
        `jbossWSAuthorizationFailed` in interface `PicketLinkLogger`
      Returns:

    - #### jbossWSErrorGettingOperationName

          public void jbossWSErrorGettingOperationName(Throwable t)

      Specified by:
        `jbossWSErrorGettingOperationName` in interface `PicketLinkLogger`

    - #### authSAMLCredentialNotAvailable

          public LoginException authSAMLCredentialNotAvailable()

      Specified by:
        `authSAMLCredentialNotAvailable` in interface `PicketLinkLogger`
      Returns:

    - #### authUnableToInstantiateHandler

          public RuntimeException authUnableToInstantiateHandler(String token,
                                                                 Throwable t)

      Specified by:
        `authUnableToInstantiateHandler` in interface `PicketLinkLogger`
      Returns:

    - #### jbossWSUnableToCreateSSLSocketFactory

          public RuntimeException jbossWSUnableToCreateSSLSocketFactory(Throwable t)

      Specified by:
        `jbossWSUnableToCreateSSLSocketFactory` in interface `PicketLinkLogger`
      Returns:

    - #### jbossWSUnableToFindSSLSocketFactory

          public RuntimeException jbossWSUnableToFindSSLSocketFactory()

      Specified by:
        `jbossWSUnableToFindSSLSocketFactory` in interface `PicketLinkLogger`
      Returns:

    - #### authUnableToGetIdentityFromSubject

          public RuntimeException authUnableToGetIdentityFromSubject()

      Specified by:
        `authUnableToGetIdentityFromSubject` in interface `PicketLinkLogger`
      Returns:

    - #### authSAMLAssertionNullOrEmpty

          public RuntimeException authSAMLAssertionNullOrEmpty()

      Specified by:
        `authSAMLAssertionNullOrEmpty` in interface `PicketLinkLogger`
      Returns:

    - #### jbossWSUncheckedAndRolesCannotBeTogether

          public ProcessingException jbossWSUncheckedAndRolesCannotBeTogether()

      Specified by:
        `jbossWSUncheckedAndRolesCannotBeTogether` in interface `PicketLinkLogger`
      Returns:

    - #### samlIDPHandlingSAML11Error

          public void samlIDPHandlingSAML11Error(Throwable t)

      Specified by:
        `samlIDPHandlingSAML11Error` in interface `PicketLinkLogger`

    - #### samlIDPValidationCheckFailed

          public GeneralSecurityException samlIDPValidationCheckFailed()

      Specified by:
        `samlIDPValidationCheckFailed` in interface `PicketLinkLogger`
      Returns:

    - #### samlIDPRequestProcessingError

          public void samlIDPRequestProcessingError(Throwable t)

      Specified by:
        `samlIDPRequestProcessingError` in interface `PicketLinkLogger`

    - #### samlIDPUnableToSetParticipantStackUsingDefault

          public void samlIDPUnableToSetParticipantStackUsingDefault(Throwable t)

      Specified by:
        `samlIDPUnableToSetParticipantStackUsingDefault` in interface `PicketLinkLogger`

    - #### samlHandlerConfigurationError

          public void samlHandlerConfigurationError(Throwable t)

      Specified by:
        `samlHandlerConfigurationError` in interface `PicketLinkLogger`

    - #### samlIDPSettingCanonicalizationMethod

          public void samlIDPSettingCanonicalizationMethod(String canonicalizationMethod)

      Specified by:
        `samlIDPSettingCanonicalizationMethod` in interface `PicketLinkLogger`

    - #### samlIDPConfigurationError

          public RuntimeException samlIDPConfigurationError(Throwable t)

      Specified by:
        `samlIDPConfigurationError` in interface `PicketLinkLogger`
      Returns:

    - #### configurationFileMissing

          public RuntimeException configurationFileMissing(String configFile)

      Specified by:
        `configurationFileMissing` in interface `PicketLinkLogger`
      Returns:

    - #### samlIDPInstallingDefaultSTSConfig

          public void samlIDPInstallingDefaultSTSConfig()

      Specified by:
        `samlIDPInstallingDefaultSTSConfig` in interface `PicketLinkLogger`

    - #### warn

          public void warn(String message)

      Specified by:
        `warn` in interface `PicketLinkLogger`

    - #### samlSPFallingBackToLocalFormAuthentication

          public void samlSPFallingBackToLocalFormAuthentication()

      Specified by:
        `samlSPFallingBackToLocalFormAuthentication` in interface `PicketLinkLogger`

    - #### unableLocalAuthentication

          public IOException unableLocalAuthentication(Throwable t)

      Specified by:
        `unableLocalAuthentication` in interface `PicketLinkLogger`
      Returns:

    - #### samlSPUnableToGetIDPDescriptorFromMetadata

          public void samlSPUnableToGetIDPDescriptorFromMetadata()

      Specified by:
        `samlSPUnableToGetIDPDescriptorFromMetadata` in interface `PicketLinkLogger`

    - #### samlSPConfigurationError

          public RuntimeException samlSPConfigurationError(Throwable t)

      Specified by:
        `samlSPConfigurationError` in interface `PicketLinkLogger`
      Returns:

    - #### samlSPSettingCanonicalizationMethod

          public void samlSPSettingCanonicalizationMethod(String canonicalizationMethod)

      Specified by:
        `samlSPSettingCanonicalizationMethod` in interface `PicketLinkLogger`

    - #### samlSPCouldNotDispatchToLogoutPage

          public void samlSPCouldNotDispatchToLogoutPage(String logOutPage)

      Specified by:
        `samlSPCouldNotDispatchToLogoutPage` in interface `PicketLinkLogger`

    - #### usingLoggerImplementation

          public void usingLoggerImplementation(String className)

      Description copied from interface: `PicketLinkLogger`

      Logs the implementation being used to log messages and exceptions.

      Specified by:
        `usingLoggerImplementation` in interface `PicketLinkLogger`

    - #### samlResponseFromIDPParsingFailed

          public void samlResponseFromIDPParsingFailed()

      Specified by:
        `samlResponseFromIDPParsingFailed` in interface `PicketLinkLogger`

    - #### auditSecurityDomainNotFound

          public ConfigurationException auditSecurityDomainNotFound(Throwable t)

      Specified by:
        `auditSecurityDomainNotFound` in interface `PicketLinkLogger`
      Returns:

    - #### auditAuditManagerNotFound

          public ConfigurationException auditAuditManagerNotFound(String location,
                                                                  Throwable t)

      Specified by:
        `auditAuditManagerNotFound` in interface `PicketLinkLogger`
      Returns:

    - #### samlIssueInstantMissingError

          public IssueInstantMissingException samlIssueInstantMissingError()

      Specified by:
        `samlIssueInstantMissingError` in interface `PicketLinkLogger`
      Returns:

    - #### samlSPResponseNotCatalinaResponseError

          public RuntimeException samlSPResponseNotCatalinaResponseError(Object response)

      Specified by:
        `samlSPResponseNotCatalinaResponseError` in interface `PicketLinkLogger`
      Returns:

    - #### samlLogoutError

          public void samlLogoutError(Throwable t)

      Specified by:
        `samlLogoutError` in interface `PicketLinkLogger`

    - #### samlErrorPageForwardError

          public void samlErrorPageForwardError(String errorPage,
                                                Throwable t)

      Specified by:
        `samlErrorPageForwardError` in interface `PicketLinkLogger`

    - #### samlSPHandleRequestError

          public void samlSPHandleRequestError(Throwable t)

      Specified by:
        `samlSPHandleRequestError` in interface `PicketLinkLogger`

    - #### samlSPProcessingExceptionError

          public IOException samlSPProcessingExceptionError(Throwable t)

      Specified by:
        `samlSPProcessingExceptionError` in interface `PicketLinkLogger`
      Returns:

    - #### samlInvalidProtocolBinding

          public IllegalArgumentException samlInvalidProtocolBinding()

      Specified by:
        `samlInvalidProtocolBinding` in interface `PicketLinkLogger`
      Returns:

    - #### samlHandlerServiceProviderConfigNotFound

          public IllegalStateException samlHandlerServiceProviderConfigNotFound()

      Specified by:
        `samlHandlerServiceProviderConfigNotFound` in interface `PicketLinkLogger`
      Returns:

    - #### samlSecurityTokenAlreadyPersisted

          public void samlSecurityTokenAlreadyPersisted(String id)

      Specified by:
        `samlSecurityTokenAlreadyPersisted` in interface `PicketLinkLogger`

    - #### samlSecurityTokenNotFoundInRegistry

          public void samlSecurityTokenNotFoundInRegistry(String id)

      Specified by:
        `samlSecurityTokenNotFoundInRegistry` in interface `PicketLinkLogger`

    - #### samlMetaDataFailedToCreateCacheDuration

          public IllegalArgumentException samlMetaDataFailedToCreateCacheDuration(String timeValue)

      Specified by:
        `samlMetaDataFailedToCreateCacheDuration` in interface `PicketLinkLogger`

    - #### samlMetaDataNoIdentityProviderDefined

          public ConfigurationException samlMetaDataNoIdentityProviderDefined()

      Specified by:
        `samlMetaDataNoIdentityProviderDefined` in interface `PicketLinkLogger`

    - #### samlMetaDataNoServiceProviderDefined

          public ConfigurationException samlMetaDataNoServiceProviderDefined()

      Specified by:
        `samlMetaDataNoServiceProviderDefined` in interface `PicketLinkLogger`

    - #### securityDomainNotFound

          public ConfigurationException securityDomainNotFound()

      Specified by:
        `securityDomainNotFound` in interface `PicketLinkLogger`

    - #### authenticationManagerError

          public void authenticationManagerError(ConfigurationException e)

      Specified by:
        `authenticationManagerError` in interface `PicketLinkLogger`

    - #### authorizationManagerError

          public void authorizationManagerError(ConfigurationException e)

      Specified by:
        `authorizationManagerError` in interface `PicketLinkLogger`

    - #### jbdcInitializationError

          public IllegalStateException jbdcInitializationError(Throwable throwable)

      Specified by:
        `jbdcInitializationError` in interface `PicketLinkLogger`

    - #### errorUnmarshallingToken

          public RuntimeException errorUnmarshallingToken(Throwable e)

      Specified by:
        `errorUnmarshallingToken` in interface `PicketLinkLogger`

    - #### runtimeException

          public RuntimeException runtimeException(String msg,
                                                   Throwable e)

      Specified by:
        `runtimeException` in interface `PicketLinkLogger`

    - #### datasourceIsNull

          public IllegalStateException datasourceIsNull()

      Specified by:
        `datasourceIsNull` in interface `PicketLinkLogger`

    - #### cannotParseParameterValue

          public IllegalArgumentException cannotParseParameterValue(String parameter,
                                                                    Throwable e)

      Specified by:
        `cannotParseParameterValue` in interface `PicketLinkLogger`

    - #### cannotGetFreeClientPoolKey

          public RuntimeException cannotGetFreeClientPoolKey(String key)

      Specified by:
        `cannotGetFreeClientPoolKey` in interface `PicketLinkLogger`

    - #### cannotGetSTSConfigByKey

          public RuntimeException cannotGetSTSConfigByKey(String key)

      Specified by:
        `cannotGetSTSConfigByKey` in interface `PicketLinkLogger`

    - #### cannotGetUsedClientsByKey

          public RuntimeException cannotGetUsedClientsByKey(String key)

      Specified by:
        `cannotGetUsedClientsByKey` in interface `PicketLinkLogger`

    - #### removingNonExistingClientFromUsedClientsByKey

          public RuntimeException removingNonExistingClientFromUsedClientsByKey(String key)

      Specified by:
        `removingNonExistingClientFromUsedClientsByKey` in interface `PicketLinkLogger`

    - #### freePoolAlreadyContainsGivenKey

          public RuntimeException freePoolAlreadyContainsGivenKey(String key)

      Specified by:
        `freePoolAlreadyContainsGivenKey` in interface `PicketLinkLogger`

    - #### maximumNumberOfClientsReachedforPool

          public RuntimeException maximumNumberOfClientsReachedforPool(String max)

      Specified by:
        `maximumNumberOfClientsReachedforPool` in interface `PicketLinkLogger`

    - #### cannotSetMaxPoolSizeToNegative

          public RuntimeException cannotSetMaxPoolSizeToNegative(String max)

      Specified by:
        `cannotSetMaxPoolSizeToNegative` in interface `PicketLinkLogger`

    - #### parserFeatureNotSupported

          public RuntimeException parserFeatureNotSupported(String feature)

      Specified by:
        `parserFeatureNotSupported` in interface `PicketLinkLogger`

    - #### samlAssertionWrongAudience

          public ProcessingException samlAssertionWrongAudience(String serviceURL)

      Specified by:
        `samlAssertionWrongAudience` in interface `PicketLinkLogger`

Copyright © 2016 JBoss by Red Hat. All rights reserved.