Reducing cyclomatic complexity
As JohnMark13 stated in the comments above, if the exceptions you want to catch share a common supertype (possibly besides the basic Exception class), then you could catch the supertype instead of all the subtypes. If you have created the SomeException and AnotherException classes yourself, then I strongly suggest that you make them extend a common custom exception type.

Also, I think that since you rethrow the exceptions (or at least most of them), then catching the general Exception is OK. Or, you could first catch all RuntimeExceptions, rethrow them directly, and then check the rest and possibly throw your WrappingException. Consider this:

public void myMethod() {
    try {
        // do something
    }
    catch (RuntimeException e) {
        // We don't need to wrap these, so we just throw the same exception again
        throw e;
    }
    catch (YourCommonSuperException e) {
        throw new WrappingException("issue when doing something " + e.getMessage(), e);
    }
    catch (Exception e) {
        // All other excpetions, such as `IOException` and stuff will be caught and wrapped and throwed here.
        throw new WrappingException("issue when doing something " + e.getMessage(), e);
    }
    // No need for any other Exceptions
}


Perhaps you get some extra cyclomatic complexity from the // do something part. If so, then you could split that part into multiple methods and possibly declaring to throw the exception from the method if needed so that it will get caught in this myMethod() (or catch within the method and throw some kind of YourCommonSuperException.

Depending on the specific // do something part, you might want to overlook which kind of exceptions that are thrown there. If you throw them yourself, it might be possible to change to IllegalArgumentException, IllegalStateException (which both extend RuntimeException) or some exception that extends YourCommonSuperException.