1 // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
2 package org.rocksdb;
3 
4 import org.junit.ClassRule;
5 import org.junit.Rule;
6 import org.junit.Test;
7 import org.junit.rules.TemporaryFolder;
8 
9 import java.util.ArrayList;
10 import java.util.Arrays;
11 import java.util.List;
12 import java.util.concurrent.atomic.AtomicInteger;
13 
14 import static org.assertj.core.api.Assertions.assertThat;
15 
16 public class LoggerTest {
17   @ClassRule
18   public static final RocksNativeLibraryResource ROCKS_NATIVE_LIBRARY_RESOURCE =
19       new RocksNativeLibraryResource();
20 
21   @Rule
22   public TemporaryFolder dbFolder = new TemporaryFolder();
23 
24   @Test
customLogger()25   public void customLogger() throws RocksDBException {
26     final AtomicInteger logMessageCounter = new AtomicInteger();
27     try (final Options options = new Options().
28         setInfoLogLevel(InfoLogLevel.DEBUG_LEVEL).
29         setCreateIfMissing(true);
30          final Logger logger = new Logger(options) {
31            // Create new logger with max log level passed by options
32            @Override
33            protected void log(InfoLogLevel infoLogLevel, String logMsg) {
34              assertThat(logMsg).isNotNull();
35              assertThat(logMsg.length()).isGreaterThan(0);
36              logMessageCounter.incrementAndGet();
37            }
38          }
39     ) {
40       // Set custom logger to options
41       options.setLogger(logger);
42 
43       try (final RocksDB db = RocksDB.open(options,
44           dbFolder.getRoot().getAbsolutePath())) {
45         // there should be more than zero received log messages in
46         // debug level.
47         assertThat(logMessageCounter.get()).isGreaterThan(0);
48       }
49     }
50   }
51 
52   @Test
warnLogger()53   public void warnLogger() throws RocksDBException {
54     final AtomicInteger logMessageCounter = new AtomicInteger();
55     try (final Options options = new Options().
56         setInfoLogLevel(InfoLogLevel.WARN_LEVEL).
57         setCreateIfMissing(true);
58 
59          final Logger logger = new Logger(options) {
60            // Create new logger with max log level passed by options
61            @Override
62            protected void log(InfoLogLevel infoLogLevel, String logMsg) {
63              assertThat(logMsg).isNotNull();
64              assertThat(logMsg.length()).isGreaterThan(0);
65              logMessageCounter.incrementAndGet();
66            }
67          }
68     ) {
69 
70       // Set custom logger to options
71       options.setLogger(logger);
72 
73       try (final RocksDB db = RocksDB.open(options,
74           dbFolder.getRoot().getAbsolutePath())) {
75         // there should be zero messages
76         // using warn level as log level.
77         assertThat(logMessageCounter.get()).isEqualTo(0);
78       }
79     }
80   }
81 
82 
83   @Test
fatalLogger()84   public void fatalLogger() throws RocksDBException {
85     final AtomicInteger logMessageCounter = new AtomicInteger();
86     try (final Options options = new Options().
87         setInfoLogLevel(InfoLogLevel.FATAL_LEVEL).
88         setCreateIfMissing(true);
89 
90          final Logger logger = new Logger(options) {
91            // Create new logger with max log level passed by options
92            @Override
93            protected void log(InfoLogLevel infoLogLevel, String logMsg) {
94              assertThat(logMsg).isNotNull();
95              assertThat(logMsg.length()).isGreaterThan(0);
96              logMessageCounter.incrementAndGet();
97            }
98          }
99     ) {
100 
101       // Set custom logger to options
102       options.setLogger(logger);
103 
104       try (final RocksDB db = RocksDB.open(options,
105           dbFolder.getRoot().getAbsolutePath())) {
106         // there should be zero messages
107         // using fatal level as log level.
108         assertThat(logMessageCounter.get()).isEqualTo(0);
109       }
110     }
111   }
112 
113   @Test
dbOptionsLogger()114   public void dbOptionsLogger() throws RocksDBException {
115     final AtomicInteger logMessageCounter = new AtomicInteger();
116     try (final DBOptions options = new DBOptions().
117         setInfoLogLevel(InfoLogLevel.FATAL_LEVEL).
118         setCreateIfMissing(true);
119          final Logger logger = new Logger(options) {
120            // Create new logger with max log level passed by options
121            @Override
122            protected void log(InfoLogLevel infoLogLevel, String logMsg) {
123              assertThat(logMsg).isNotNull();
124              assertThat(logMsg.length()).isGreaterThan(0);
125              logMessageCounter.incrementAndGet();
126            }
127          }
128     ) {
129       // Set custom logger to options
130       options.setLogger(logger);
131 
132       final List<ColumnFamilyDescriptor> cfDescriptors =
133           Arrays.asList(
134               new ColumnFamilyDescriptor(RocksDB.DEFAULT_COLUMN_FAMILY));
135       final List<ColumnFamilyHandle> cfHandles = new ArrayList<>();
136 
137       try (final RocksDB db = RocksDB.open(options,
138           dbFolder.getRoot().getAbsolutePath(),
139           cfDescriptors, cfHandles)) {
140         try {
141           // there should be zero messages
142           // using fatal level as log level.
143           assertThat(logMessageCounter.get()).isEqualTo(0);
144         } finally {
145           for (final ColumnFamilyHandle columnFamilyHandle : cfHandles) {
146             columnFamilyHandle.close();
147           }
148         }
149       }
150     }
151   }
152 
153   @Test
setWarnLogLevel()154   public void setWarnLogLevel() {
155     final AtomicInteger logMessageCounter = new AtomicInteger();
156     try (final Options options = new Options().
157         setInfoLogLevel(InfoLogLevel.FATAL_LEVEL).
158         setCreateIfMissing(true);
159          final Logger logger = new Logger(options) {
160            // Create new logger with max log level passed by options
161            @Override
162            protected void log(InfoLogLevel infoLogLevel, String logMsg) {
163              assertThat(logMsg).isNotNull();
164              assertThat(logMsg.length()).isGreaterThan(0);
165              logMessageCounter.incrementAndGet();
166            }
167          }
168     ) {
169       assertThat(logger.infoLogLevel()).
170           isEqualTo(InfoLogLevel.FATAL_LEVEL);
171       logger.setInfoLogLevel(InfoLogLevel.WARN_LEVEL);
172       assertThat(logger.infoLogLevel()).
173           isEqualTo(InfoLogLevel.WARN_LEVEL);
174     }
175   }
176 
177   @Test
setInfoLogLevel()178   public void setInfoLogLevel() {
179     final AtomicInteger logMessageCounter = new AtomicInteger();
180     try (final Options options = new Options().
181         setInfoLogLevel(InfoLogLevel.FATAL_LEVEL).
182         setCreateIfMissing(true);
183          final Logger logger = new Logger(options) {
184            // Create new logger with max log level passed by options
185            @Override
186            protected void log(InfoLogLevel infoLogLevel, String logMsg) {
187              assertThat(logMsg).isNotNull();
188              assertThat(logMsg.length()).isGreaterThan(0);
189              logMessageCounter.incrementAndGet();
190            }
191          }
192     ) {
193       assertThat(logger.infoLogLevel()).
194           isEqualTo(InfoLogLevel.FATAL_LEVEL);
195       logger.setInfoLogLevel(InfoLogLevel.DEBUG_LEVEL);
196       assertThat(logger.infoLogLevel()).
197           isEqualTo(InfoLogLevel.DEBUG_LEVEL);
198     }
199   }
200 
201   @Test
changeLogLevelAtRuntime()202   public void changeLogLevelAtRuntime() throws RocksDBException {
203     final AtomicInteger logMessageCounter = new AtomicInteger();
204     try (final Options options = new Options().
205         setInfoLogLevel(InfoLogLevel.FATAL_LEVEL).
206         setCreateIfMissing(true);
207 
208          // Create new logger with max log level passed by options
209          final Logger logger = new Logger(options) {
210            @Override
211            protected void log(InfoLogLevel infoLogLevel, String logMsg) {
212              assertThat(logMsg).isNotNull();
213              assertThat(logMsg.length()).isGreaterThan(0);
214              logMessageCounter.incrementAndGet();
215            }
216          }
217     ) {
218       // Set custom logger to options
219       options.setLogger(logger);
220 
221       try (final RocksDB db = RocksDB.open(options,
222           dbFolder.getRoot().getAbsolutePath())) {
223 
224         // there should be zero messages
225         // using fatal level as log level.
226         assertThat(logMessageCounter.get()).isEqualTo(0);
227 
228         // change log level to debug level
229         logger.setInfoLogLevel(InfoLogLevel.DEBUG_LEVEL);
230 
231         db.put("key".getBytes(), "value".getBytes());
232         db.flush(new FlushOptions().setWaitForFlush(true));
233 
234         // messages shall be received due to previous actions.
235         assertThat(logMessageCounter.get()).isNotEqualTo(0);
236       }
237     }
238   }
239 }
240