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 }