View Javadoc

    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one or more
    3    * contributor license agreements. See the NOTICE file distributed with
    4    * this work for additional information regarding copyright ownership.
    5    * The ASF licenses this file to You under the Apache license, Version 2.0
    6    * (the "License"); you may not use this file except in compliance with
    7    * the License. You may obtain a copy of the License at
    8    *
    9    *      http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the license for the specific language governing permissions and
    15   * limitations under the license.
    16   */
    17  package org.apache.logging.log4j.core.appender.db.jpa;
    18
    19  import java.util.Map;
    20
    21  import javax.persistence.Basic;
    22  import javax.persistence.Convert;
    23  import javax.persistence.MappedSuperclass;
    24  import javax.persistence.Transient;
    25
    26  import org.apache.logging.log4j.Level;
    27  import org.apache.logging.log4j.Marker;
    28  import org.apache.logging.log4j.ThreadContext;
    29  import org.apache.logging.log4j.core.LogEvent;
    30  import org.apache.logging.log4j.core.appender.db.jpa.converter.ContextMapAttributeConverter;
    31  import org.apache.logging.log4j.core.appender.db.jpa.converter.ContextStackAttributeConverter;
    32  import org.apache.logging.log4j.core.appender.db.jpa.converter.LevelAttributeConverter;
    33  import org.apache.logging.log4j.core.appender.db.jpa.converter.MarkerAttributeConverter;
    34  import org.apache.logging.log4j.core.appender.db.jpa.converter.MessageAttributeConverter;
    35  import org.apache.logging.log4j.core.appender.db.jpa.converter.StackTraceElementAttributeConverter;
    36  import org.apache.logging.log4j.core.appender.db.jpa.converter.ThrowableAttributeConverter;
    37  import org.apache.logging.log4j.core.impl.ThrowableProxy;
    38  import org.apache.logging.log4j.message.Message;
    39
    40  /**
    41   * Users of the JPA appender may want to extend this class instead of {@link AbstractLogEventWrapperEntity}. This class
    42   * implements all of the required mutator methods but does not implement a mutable entity ID property. In order to
    43   * create an entity based on this class, you need only create two constructors matching this class's
    44   * constructors, annotate the class {@link javax.persistence.Entity @Entity} and {@link javax.persistence.Table @Table},
    45   * and implement the fully mutable entity ID property annotated with {@link javax.persistence.Id @Id} and
    46   * {@link javax.persistence.GeneratedValue @GeneratedValue} to tell the JPA provider how to calculate an ID for new
    47   * events.<br>
    48   * <br>
    49   * The attributes in this entity use the default column names (which, according to the JPA spec, are the property names
    50   * minus the "get" and "set" from the accessors/mutators). If you want to use different column names for one or more
    51   * columns, override the necessary accessor methods defined in this class with the same annotations plus the
    52   * {@link javax.persistence.Column @Column} annotation to specify the column name.<br>
    53   * <br>
    54   * The {@link #getContextMap()} and {@link #getContextStack()} attributes in this entity use the
    55   * {@link ContextMapAttributeConverter} and {@link ContextStackAttributeConverter}, respectively. These convert the
    56   * properties to simple strings that cannot be converted back to the properties. If you wish to instead convert these to
    57   * a reversible JSON string, override these attributes with the same annotations but use the
    58   * {@link org.apache.logging.log4j.core.appender.db.jpa.converter.ContextMapJsonAttributeConverter} and
    59   * {@link org.apache.logging.log4j.core.appender.db.jpa.converter.ContextStackJsonAttributeConverter} instead.<br>
    60   * <br>
    61   * All other attributes in this entity use reversible converters that can be used for both persistence and retrieval. If
    62   * there are any attributes you do not want persistent, you should override their accessor methods and annotate with
    63   * {@link javax.persistence.Transient @Transient}.
    64   *
    65   * @see AbstractLogEventWrapperEntity
    66   */
    67  @MappedSuperclass
    68  public abstract class BasicLogEventEntity extends AbstractLogEventWrapperEntity {
    69      private static final long serialVersionUID = 1L;
    70
    71      /**
    72       * Instantiates this base class. All concrete implementations must have a constructor matching this constructor's
    73       * signature. The no-argument constructor is required for a standards-compliant JPA provider to accept this as an
    74       * entity.
    75       */
    76      @SuppressWarnings("unused")
    77      public BasicLogEventEntity() {
    78          super();
    79      }
    80
    81      /**
    82       * Instantiates this base class. All concrete implementations must have a constructor matching this constructor's
    83       * signature. This constructor is used for wrapping this entity around a logged event.
    84       *
    85       * @param wrappedEvent The underlying event from which information is obtained.
    86       */
    87      public BasicLogEventEntity(final LogEvent wrappedEvent) {
    88          super(wrappedEvent);
    89      }
    90
    91      /**
    92       * Gets the level. Annotated with {@code @Basic} and {@code @Enumerated(EnumType.STRING)}.
    93       *
    94       * @return the level.
    95       */
    96      @Override
    97      @Convert(converter = LevelAttributeConverter.class)
    98      public Level getLevel() {
    99          return this.getWrappedEvent().getLevel();
    100     }
    101
    102     /**
    103      * Gets the logger name. Annotated with {@code @Basic}.
    104      *
    105      * @return the logger name.
    106      */
    107     @Override
    108     @Basic
    109     public String getLoggerName() {
    110         return this.getWrappedEvent().getLoggerName();
    111     }
    112
    113     /**
    114      * Gets the source location information. Annotated with
    115      * {@code @Convert(converter = StackTraceElementAttributeConverter.class)}.
    116      *
    117      * @return the source location information.
    118      * @see StackTraceElementAttributeConverter
    119      */
    120     @Override
    121     @Convert(converter = StackTraceElementAttributeConverter.class)
    122     public StackTraceElement getSource() {
    123         return this.getWrappedEvent().getSource();
    124     }
    125
    126     /**
    127      * Gets the message. Annotated with {@code @Convert(converter = MessageAttributeConverter.class)}.
    128      *
    129      * @return the message.
    130      * @see MessageAttributeConverter
    131      */
    132     @Override
    133     @Convert(converter = MessageAttributeConverter.class)
    134     public Message getMessage() {
    135         return this.getWrappedEvent().getMessage();
    136     }
    137
    138     /**
    139      * Gets the marker. Annotated with {@code @Convert(converter = MarkerAttributeConverter.class)}.
    140      *
    141      * @return the marker.
    142      * @see MarkerAttributeConverter
    143      */
    144     @Override
    145     @Convert(converter = MarkerAttributeConverter.class)
    146     public Marker getMarker() {
    147         return this.getWrappedEvent().getMarker();
    148     }
    149
    150     /**
    151      * Gets the thread name. Annotated with {@code @Basic}.
    152      *
    153      * @return the thread name.
    154      */
    155     @Override
    156     @Basic
    157     public String getThreadName() {
    158         return this.getWrappedEvent().getThreadName();
    159     }
    160
    161     /**
    162      * Gets the number of milliseconds since JVM launch. Annotated with {@code @Basic}.
    163      *
    164      * @return the number of milliseconds since JVM launch.
    165      */
    166     @Override
    167     @Basic
    168     public long getTimeMillis() {
    169         return this.getWrappedEvent().getTimeMillis();
    170     }
    171
    172     /**
    173      * Gets the exception logged. Annotated with {@code @Convert(converter = ThrowableAttributeConverter.class)}.
    174      *
    175      * @return the exception logged.
    176      * @see ThrowableAttributeConverter
    177      */
    178     @Override
    179     @Convert(converter = ThrowableAttributeConverter.class)
    180     public Throwable getThrown() {
    181         return this.getWrappedEvent().getThrown();
    182     }
    183
    184     /**
    185      * Gets the exception logged. Annotated with {@code @Convert(converter = ThrowableAttributeConverter.class)}.
    186      *
    187      * @return the exception logged.
    188      * @see ThrowableAttributeConverter
    189      */
    190     @Override
    191     @Transient
    192     public ThrowableProxy getThrownProxy() {
    193         return this.getWrappedEvent().getThrownProxy();
    194     }
    195
    196     /**
    197      * Gets the context map. Annotated with {@code @Convert(converter = ContextMapAttributeConverter.class)}.
    198      *
    199      * @return the context map.
    200      * @see ContextMapAttributeConverter
    201      * @see org.apache.logging.log4j.core.appender.db.jpa.converter.ContextMapJsonAttributeConverter
    202      */
    203     @Override
    204     @Convert(converter = ContextMapAttributeConverter.class)
    205     public Map<String, String> getContextMap() {
    206         return this.getWrappedEvent().getContextMap();
    207     }
    208
    209     /**
    210      * Gets the context stack. Annotated with {@code @Convert(converter = ContextStackAttributeConverter.class)}.
    211      *
    212      * @return the context stack.
    213      * @see ContextStackAttributeConverter
    214      * @see org.apache.logging.log4j.core.appender.db.jpa.converter.ContextStackJsonAttributeConverter
    215      */
    216     @Override
    217     @Convert(converter = ContextStackAttributeConverter.class)
    218     public ThreadContext.ContextStack getContextStack() {
    219         return this.getWrappedEvent().getContextStack();
    220     }
    221
    222     /**
    223      * Gets the fully qualified class name of the caller of the logger API. Annotated with {@code @Basic}.
    224      *
    225      * @return the fully qualified class name of the caller of the logger API.
    226      */
    227     @Override
    228     @Basic
    229     public String getLoggerFqcn() {
    230         return this.getWrappedEvent().getLoggerFqcn();
    231     }
    232 }