import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
private GelfConfiguration getGelfConfiguration(Configuration config) {
    final Integer queueCapacity = config.getInt("graylog2.appender.queue-size", 512);
    final Long reconnectInterval = config.getMilliseconds("graylog2.appender.reconnect-interval", 500L);
    final Long connectTimeout = config.getMilliseconds("graylog2.appender.connect-timeout", 1000L);
    final Boolean isTcpNoDelay = config.getBoolean("graylog2.appender.tcp-nodelay", false);
    final String hostString = config.getString("graylog2.appender.host", "127.0.0.1:12201");
    final String protocol = config.getString("graylog2.appender.protocol", "udp");

    final HostAndPort hostAndPort = HostAndPort.fromString(hostString);

    GelfTransports gelfTransport = GelfTransports.valueOf(protocol.toUpperCase());

    final Integer sendBufferSize = config.getInt("graylog2.appender.sendbuffersize", 0); // causes the socket default to be used

    return new GelfConfiguration(hostAndPort.getHost(), hostAndPort.getPort())
            .transport(gelfTransport)
            .reconnectDelay(reconnectInterval.intValue())
            .queueSize(queueCapacity)
            .connectTimeout(connectTimeout.intValue())
            .tcpNoDelay(isTcpNoDelay)
            .sendBufferSize(sendBufferSize);
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
/**
 * Construct a new GelfWriter instance.
 *
 * @param server                 the hostname of the GELF-compatible server
 * @param port                   the port of the GELF-compatible server
 * @param transport              the transport protocol to use
 * @param hostname               the hostname of the application
 * @param requiredLogEntryValues additional information for log messages, see {@link LogEntryValue}
 * @param staticFields           additional static fields for the GELF messages
 * @param queueSize              the size of the internal queue the GELF client is using
 * @param connectTimeout         the connection timeout for TCP connections in milliseconds
 * @param reconnectDelay         the time to wait between reconnects in milliseconds
 * @param sendBufferSize         the size of the socket send buffer in bytes; a value of {@code -1}
 *                               deactivates the socket send buffer.
 * @param tcpNoDelay             {@code true} if Nagle's algorithm should used for TCP connections,
 *                               {@code false} otherwise
 */
public GelfWriter(final String server,
                  final int port,
                  final GelfTransports transport,
                  final String hostname,
                  final Set<LogEntryValue> requiredLogEntryValues,
                  final Map<String, Object> staticFields,
                  final int queueSize,
                  final int connectTimeout,
                  final int reconnectDelay,
                  final int sendBufferSize,
                  final boolean tcpNoDelay) {
    this.server = server;
    this.port = port;
    this.transport = transport;
    this.hostname = buildHostName(hostname);
    this.requiredLogEntryValues = buildRequiredLogEntryValues(requiredLogEntryValues);
    this.staticFields = staticFields;
    this.queueSize = queueSize;
    this.connectTimeout = connectTimeout;
    this.reconnectDelay = reconnectDelay;
    this.sendBufferSize = sendBufferSize;
    this.tcpNoDelay = tcpNoDelay;
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void init(Configuration configuration) throws Exception {
    final InetSocketAddress remoteAddress = new InetSocketAddress(server, port);
    final GelfConfiguration gelfConfiguration = new GelfConfiguration(remoteAddress)
            .transport(transport)
            .queueSize(queueSize)
            .connectTimeout(connectTimeout)
            .reconnectDelay(reconnectDelay)
            .sendBufferSize(sendBufferSize)
            .tcpNoDelay(tcpNoDelay);

    client = GelfTransports.create(gelfConfiguration);

    VMShutdownHook.register(this);
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
@Override
protected void doStart() {
    final GelfConfiguration clientConfig = new GelfConfiguration(configuration.getHost(), configuration.getPort());

    switch (configuration.getProtocol()) {
        case UDP:
            clientConfig
                    .transport(GelfTransports.UDP)
                    .queueSize(configuration.getClientQueueSize())
                    .sendBufferSize(configuration.getClientSendBufferSize());
        case TCP:
            clientConfig
                    .transport(GelfTransports.TCP)
                    .queueSize(configuration.getClientQueueSize())
                    .connectTimeout(configuration.getClientConnectTimeout())
                    .reconnectDelay(configuration.getClientReconnectDelay())
                    .tcpNoDelay(configuration.isClientTcpNoDelay())
                    .sendBufferSize(configuration.getClientSendBufferSize());

            if (configuration.isClientTls()) {
                clientConfig.enableTls();
                clientConfig.tlsTrustCertChainFile(configuration.getClientTlsCertChainFile());

                if (configuration.isClientTlsVerifyCert()) {
                    clientConfig.enableTlsCertVerification();
                } else {
                    clientConfig.disableTlsCertVerification();
                }
            }
            break;
    }

    LOG.info("Starting GELF transport: {}", clientConfig);
    this.transport = GelfTransports.create(clientConfig);

    transportInitialized.countDown();

    notifyStarted();
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
@Inject
public Graylog2Impl(Configuration config) {
    String canonicalHostName;
    try {
        canonicalHostName = config.getString(
                "graylog2.appender.sourcehost",
                InetAddress.getLocalHost().getCanonicalHostName()
        );
    } catch (UnknownHostException e) {
        canonicalHostName = "unknown";
    }

    accessLogEnabled = config.getBoolean("graylog2.appender.access-log", false);

    final GelfConfiguration gelfConfiguration = getGelfConfiguration(config);

    GelfTransport transport = GelfTransports.create(gelfConfiguration);

    final LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    final Logger rootLogger = lc.getLogger(Logger.ROOT_LOGGER_NAME);

    gelfClientAppender = new GelfClientAppender(transport, canonicalHostName);

    gelfClientAppender.setContext(lc);

    gelfClientAppender.start();

    rootLogger.addAppender(gelfClientAppender);
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
private GelfConfiguration getGelfConfiguration() {

        final InetSocketAddress serverAddress = new InetSocketAddress(server, port);
        final GelfTransports gelfProtocol = GelfTransports.valueOf(protocol().toUpperCase());

        return new GelfConfiguration(serverAddress).transport(gelfProtocol)
            .queueSize(queueSize)
            .connectTimeout(connectTimeout)
            .reconnectDelay(reconnectDelay)
            .sendBufferSize(sendBufferSize)
            .tcpNoDelay(tcpNoDelay)
            .tcpKeepAlive(tcpKeepAlive);
    }
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
@Override
public GelfTransports convertFrom(String value) {
    try {
        return GelfTransports.valueOf(Strings.nullToEmpty(value).toUpperCase(Locale.ENGLISH));
    } catch (IllegalArgumentException e) {
        throw new ParameterException("Couldn't convert value \"" + value + "\" to GELF transport.", e);
    }
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
@Override
public String convertTo(GelfTransports value) {
    if (value == null) {
        throw new ParameterException("Couldn't convert \"null\" to string.");
    }
    return value.name();
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
public GraylogUplink(String hostname, int port, String nzymeId, String networkInterfaceName) {
    this.nzymeId = nzymeId;
    this.networkInterfaceName = networkInterfaceName;

    this.gelfTransport = GelfTransports.create(new GelfConfiguration(new InetSocketAddress(hostname, port))
            .transport(GelfTransports.TCP)
            .queueSize(512)
            .connectTimeout(5000)
            .reconnectDelay(1000)
            .tcpNoDelay(true)
            .sendBufferSize(32768));
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
@Test
public void getRequiredLogEntryValuesIncludesAdditionalFields() {
    final Writer gelfWriter = new GelfWriter("localhost", 12201, GelfTransports.UDP, "localhost",
            EnumSet.of(LogEntryValue.EXCEPTION, LogEntryValue.PROCESS_ID), Collections.<String, Object>emptyMap(),
            512, 1000, 500, -1, false);

    assertThat(gelfWriter.getRequiredLogEntryValues(), hasItems(
            LogEntryValue.DATE, LogEntryValue.LEVEL, LogEntryValue.RENDERED_LOG_ENTRY,
            LogEntryValue.EXCEPTION, LogEntryValue.PROCESS_ID));
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
public Graylog2Plugin(Application app) {
    final Configuration config = app.configuration();

    accessLogEnabled = config.getBoolean("graylog2.appender.send-access-log", false);
    queueCapacity = config.getInt("graylog2.appender.queue-size", 512);
    reconnectInterval = config.getMilliseconds("graylog2.appender.reconnect-interval", 500L);
    connectTimeout = config.getMilliseconds("graylog2.appender.connect-timeout", 1000L);
    isTcpNoDelay = config.getBoolean("graylog2.appender.tcp-nodelay", false);
    sendBufferSize = config.getInt("graylog2.appender.sendbuffersize", 0); // causes the socket default to be used
    try {
        canonicalHostName = config.getString("graylog2.appender.sourcehost", InetAddress.getLocalHost().getCanonicalHostName());
    } catch (UnknownHostException e) {
        canonicalHostName = "localhost";
        log.error("Unable to resolve canonical localhost name. " +
                "Please set it manually via graylog2.appender.sourcehost or fix your lookup service, falling back to {}", canonicalHostName);
    }
    // TODO make this a list and dynamically accessible from the application
    final String hostString = config.getString("graylog2.appender.host", "127.0.0.1:12201");
    final String protocol = config.getString("graylog2.appender.protocol", "tcp");

    final HostAndPort hostAndPort = HostAndPort.fromString(hostString);

    final GelfTransports gelfTransport = GelfTransports.valueOf(protocol.toUpperCase());

    final GelfConfiguration gelfConfiguration = new GelfConfiguration(hostAndPort.getHostText(), hostAndPort.getPort())
            .transport(gelfTransport)
            .reconnectDelay(reconnectInterval.intValue())
            .queueSize(queueCapacity)
            .connectTimeout(connectTimeout.intValue())
            .tcpNoDelay(isTcpNoDelay)
            .sendBufferSize(sendBufferSize);

    this.transport = GelfTransports.create(gelfConfiguration);

    final LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    rootLogger = lc.getLogger(Logger.ROOT_LOGGER_NAME);

    gelfAppender = new GelfclientAppender(transport, getLocalHostName());
    gelfAppender.setContext(lc);
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
@Inject
public GelfOutputConfiguration(@Assisted String id,
                               @Assisted Config config,
                               GelfOutput.Factory outputFactory) {
    super(id, config);
    this.outputFactory = outputFactory;

    if (config.hasPath("protocol")) {
        switch (config.getString("protocol").toUpperCase(Locale.ENGLISH)) {
            case "UDP":
                this.protocol = GelfTransports.UDP;
                break;
            case "TCP":
            default:
                this.protocol = GelfTransports.TCP;
                break;
        }
    }
    if (config.hasPath("host")) {
        this.host = config.getString("host");
    }
    if (config.hasPath("port")) {
        this.port = config.getInt("port");
    }
    if (config.hasPath("client-tls")) {
        this.clientTls = config.getBoolean("client-tls");
    }
    if (config.hasPath("client-tls-cert-chain-file")) {
        this.clientTlsCertChainFile = new File(config.getString("client-tls-cert-chain-file"));
    }
    if (config.hasPath("client-tls-verify-cert")) {
        this.clientTlsVerifyCert = config.getBoolean("client-tls-verify-cert");
    }
    if (config.hasPath("client-queue-size")) {
        this.clientQueueSize = config.getInt("client-queue-size");
    }
    if (config.hasPath("client-connect-timeout")) {
        this.clientConnectTimeout = config.getInt("client-connect-timeout");
    }
    if (config.hasPath("client-reconnect-delay")) {
        this.clientReconnectDelay = config.getInt("client-reconnect-delay");
    }
    if (config.hasPath("client-tcp-no-delay")) {
        this.clientTcpNoDelay = config.getBoolean("client-tcp-no-delay");
    }
    if (config.hasPath("client-send-buffer-size")) {
        this.clientSendBufferSize = config.getInt("client-send-buffer-size");
    }
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
public GelfTransports getProtocol() {
    return protocol;
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
public GelfTransports getTransport() {
    return transport;
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
@Test
public void convertFromValidString() throws Exception {
    Assert.assertEquals(GelfTransports.UDP, new GelfTransportsConverter().convertFrom("UDP"));
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
@Test
public void convertFromValidLowerCaseString() throws Exception {
    assertEquals(GelfTransports.TCP, new GelfTransportsConverter().convertFrom("tcp"));
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
@Test
public void convertTo() throws Exception {
    assertEquals("UDP", new GelfTransportsConverter().convertTo(GelfTransports.UDP));
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
@Override
public void start() {
    super.start();
    client = GelfTransports.create(gelfConfiguration);
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
@Test
public void testWrite() throws Exception {
    final GelfTransport client = mock(GelfTransport.class);
    final GelfWriter gelfWriter = new GelfWriter("localhost", 12201, GelfTransports.UDP, "myHostName",
            EnumSet.of(LogEntryValue.EXCEPTION, LogEntryValue.PROCESS_ID),
            Collections.<String, Object>singletonMap("staticField", "TEST"), 512, 1000, 500, -1, false);

    @SuppressWarnings("all")
    final RuntimeException exception = new RuntimeException("BOOM!");
    exception.fillInStackTrace();
    final Date now = new Date();
    final ThreadGroup threadGroup = new ThreadGroup("TEST-threadGroup");
    final Thread thread = new Thread(threadGroup, "TEST-thread");
    thread.setPriority(1);

    final LogEntry logEntry = new LogEntry(now, "TEST-processId", thread,
            "TEST-ClassName", "TEST-MethodName", "TEST-FileName", 42, Level.INFO,
            "Test 123", exception);

    gelfWriter.write(client, logEntry);

    final ArgumentCaptor<GelfMessage> argumentCaptor = ArgumentCaptor.forClass(GelfMessage.class);
    verify(client).send(argumentCaptor.capture());

    final GelfMessage message = argumentCaptor.getValue();
    assertThat(message.getHost(), equalTo("myHostName"));
    assertThat(message.getMessage(), equalTo("Test 123"));
    assertThat(message.getLevel(), equalTo(GelfMessageLevel.INFO));
    assertThat(new Date((long) (message.getTimestamp() * 1000l)), equalTo(now));
    assertThat(message.getFullMessage(), startsWith(message.getMessage()));

    final Map<String, Object> additionalFields = message.getAdditionalFields();
    assertThat(additionalFields.isEmpty(), is(false));
    assertThat((String) additionalFields.get("processId"), equalTo("TEST-processId"));
    assertThat((String) additionalFields.get("threadName"), equalTo("TEST-thread"));
    assertThat((Integer) additionalFields.get("threadPriority"), equalTo(1));
    assertThat((String) additionalFields.get("threadGroup"), equalTo("TEST-threadGroup"));
    assertThat((String) additionalFields.get("sourceClassName"), equalTo("TEST-ClassName"));
    assertThat((String) additionalFields.get("sourceMethodName"), equalTo("TEST-MethodName"));
    assertThat((String) additionalFields.get("sourceFileName"), equalTo("TEST-FileName"));
    assertThat((Integer) additionalFields.get("sourceLineNumber"), equalTo(42));
    assertThat((String) additionalFields.get("exceptionMessage"), equalTo("BOOM!"));
    assertThat((String) additionalFields.get("exceptionClass"), equalTo(RuntimeException.class.getCanonicalName()));
    assertThat((String) additionalFields.get("exceptionStackTrace"), startsWith(this.getClass().getCanonicalName()));
}
 

import org.graylog2.gelfclient.GelfTransports; //导入依赖的package包/类
private void createGelfClient() {

        client = GelfTransports.create(getGelfConfiguration());
    }