Addressing your second point first because it is shorter; If you are handling the null values correctly then your program flow will take care of working even though you had a null. An unanticipated NPE will lead to crashes.

By "extracting to util methods" I don't mean anything fancy.
Imaging the following pseudo code

```java
Event event = memoryImprint.getEvent()
if ( event != null) {
    Provider prov = event.getProvider();
    if (prov != null) {
        String serverName = prov.getName();
        if (serverName != null) {
            //Do a lot of stuff using serverName and even more nested ifs
        } else {
            logger.warning("Could not find the Gerrit Server name from the provider {}", prov);
        }
    } else {
        logger.warning("Could not get the Provider from event {}", event);
    }
}
```
_I feel a bit dirty already_
First we could shorten it to look a tiny bit better
```java
if (memoryImprint.getEvent() != null && memoryImprint.getEvent().getProvider() != null && memoryImprint.getEvent().getProvider().getName() != null) {
    String serverName = memoryImprint.getEvent().getProvider().getName();
    //Do a lot of stuff using serverName and even more nested ifs
} else {
    logger.warning("Could not find the Gerrit Server name from event in memory {}", memoryImprint);
}
```
But here we loose a bit of detail in the logging and that would be a pain to debug via the log later on.
So you could take the first approach and put it in a private method in the class and call it something like `String getServerNameFrom(MemoryImprint memory)` and there it would be just one check to see that that string isn't null.

```java
    private String getServerName() {
        Event event = memoryImprint.getEvent()
        if (event != null) {
            Provider prov = event.getProvider();
            if (prov != null) {
                String serverName = prov.getName();
                if (serverName != null) {
                    return serverName;
                } else {
                    logger.warning("Could not find the Gerrit Server name from the provider {}", prov);
                }
            } else {
                logger.warning("Could not get the Provider from event {}", event);
            }
        } else {
            logger.error("The provider contains no name {}", provider);
        }
        return null;
    }
```

Another thing I thought of just now would be to use the [Preconditions](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/base/Preconditions.html) class in guava, start the logic by checking your values and then move on, catching any exceptions and putting them in the log below.
But `Preconditions.checkNotNull(value, message)` throws a `NullPointerexception` with your message if the value is null. The judge and jury for the code camp might be lenient in those cases if you choose to catch them ;)