Q:

I created my own logger in Java. Is it a bad idea?

I'm developing a web crawler using Java and XPages. I have had a lot of compatibility issues between log libraries like SLF4J, Log4J, java.util.logging, etc. and Lotus Notes.
So, I developed my own very simple logger class.
import java.io.PrintWriter;
import java.util.Calendar;

import org.apache.commons.lang3.exception.ExceptionUtils;

public class Logger {
    private static final Calendar calendar = Calendar.getInstance();

    public enum Level {NONE, ERROR, WARNING, INFO, DEBUG, TRACE}

    private Level level = Level.NONE; 
    private PrintWriter stream = null;

    public void setLevel(Level l) {
        level = l;
    }

    public void setPrintWriter(PrintWriter f) {
        stream = f;
    }

    public void error(String m) {
        if (Level.ERROR.compareTo(level) <= 0) {
            format("ERROR", m);
        }
    }

    public void error(String m, Throwable e) {
        if (Level.ERROR.compareTo(level) <= 0) {
            StringBuilder sb = new StringBuilder(1024);
            sb.append(m);
            sb.append(ExceptionUtils.getStackTrace(e));

            format("ERROR", sb.toString());
        }
    }

    public void warn(String m) {
        if (Level.WARNING.compareTo(level) <= 0) {
            format("WARNING", m);
        }
    }

    public void warn(String m, Throwable e) {
        if (Level.WARNING.compareTo(level) <= 0) {
            StringBuilder sb = new StringBuilder(1024);
            sb.append(m);
            sb.append(ExceptionUtils.getStackTrace(e));

            format("WARNING", sb.toString());
        }
    }

    public void debug(String m) {
        if (Level.DEBUG.compareTo(level) <= 0) {
            format("DEBUG", m);
        }
    }

    public void info(String m) {
        if (Level.INFO.compareTo(level) <= 0) {
            format("INFO", m);
        }
    }

    public void trace(String m) {
        if (Level.TRACE.compareTo(level) <= 0) {
            format("TRACE", m);
        }
    }

    public void format(String type, String m) {
        StringBuilder sb = new StringBuilder(1024);
        sb.append("[");
        sb.append(type);
        sb.append("] ");
        sb.append(calendar.getTime().toString());
        sb.append(" - ");
        sb.append(m);

        String line = sb.toString();
        System.out.println(line);

        if (stream != null) {
            stream.println(line);
            stream.flush();
        } 
    }
}

My questions:

Is it a bad idea to write a logger? Do I have to insist in make it works one of the existent log libraries?
If I decide to use always this logger, what features I will miss from the log libraries like SLF4J, Log4J, java.util.logging, etc.?

Edit: Thanks to your answers, this would be the recommendation so far:

If I can avoid to write a custom logger, perfect. If I have a good reason to do it, I will hope that no one will kill me. 
There are a lot of features that I would miss when the application be pushed live. 
So far, the Chain-of-responsibility pattern looks like a good idea to implement in short time and give me more control over the output.
Anyway, I'm going to check again the code just in case I miss something and I can make it work with a well-known log library. It's worth trying.

A:

I had have lot of compatibility problems between the log libraries like SLF4J, Log4J, java.util.logging, etc. and Lotus Notes.

Without knowing what those issues were, it is difficult to advise you.  There may have been a simple fix or work-around.

Is it a bad idea to write a logger? 

Reinventing the wheel is a bad idea.  Unless you really need a different kind of wheel.

Do I have to insist in make it works one of the existent log libraries?

Your choice.

If I decide to use always this logger, what features I will miss from the log libraries like SLF4J, Log4J, java.util.logging, etc.?

Hard to say what you will miss, because it depends on what you need.
However, some of the things that are missing from your attempted solution include:

Logging to multiple files, file rotation, etcetera.
Logging to a variety of kinds of event handling systems.
Coarse / fine-grain configurability of logging ... without changing code.
Compatibility; e.g. if you need to integrate with 3rd party software that uses a standard logging framework.

And then there is the revulsion that other Java programmers are liable to express if they need to maintain your code.

