Q:

Creating logger with value that implements certain traits

Below is my non-compiling code to see my situation.
I want to create a logger with a type that implements Debug and Clone. This is because I first want to log the error (I think I need to clone the value) on the machine, and then send it to the database. 
I want to initialize/use my type with either:

&str
String
Some type that implements Debug + Clone

Notes:

I don't want specialized methods for each of the above types. I have a lot of methods and I don't want to keep repeating the generics.
I don't want calling my type with a generic.
I don't care about some extra allocation, a.k.a using a Box for example.
I will never assign the result of an instance of Logger to a variable (maybe this enables the type to be unsized?), I just log a few things.

Trying to Box around the Debug and Clone requirement gives me this error...

only auto traits can be used as additional traits in a trait object

... when using something like this:
pub fn new<D: Clone + Debug>(con: &'a DBCon, err: D) -> Logger

Code
struct DBCon;

struct Logger<'a> {
    con: &'a DBCon,
    err: ?? // Some type implementing Debug + Clone
}

impl<'a> Logger<'a> {
    pub fn new(con: &'a DBCon, err: ??) -> Logger {
        Logger { con, err }
    }

    pub fn log(self) {
        eprintln!("{:?}", self.err.clone())

        // Send self.err to database
    }

    // Additional log methods
}

fn main() {
    Logger::new(con: some_con, "err").log();

    Logger::new(con: some_con, "err".to_owned()).log();

    Logger::new(con: some_con, some_other_value_that_impl_Debug_and_Clone).log();
}

A:

You can make your Logger generic without needing to specify the generic parameters at the call sites:
use std::fmt::Debug;

struct DBCon;

struct Logger<'a, T: Debug + Clone> {
    con: &'a DBCon,
    err: T,
}

impl<'a, T: Debug + Clone> Logger<'a, T> {
    pub fn new (con: &'a DBCon, err: T) -> Self {
        Logger { con, err }
    }

    pub fn log (self) {
        eprintln!("{:?}", self.err.clone())
        // Send self.err to database
    }
    // Additional log methods
}

fn main() {
    let con = DBCon;

    Logger::new (&con, "err").log();
    Logger::new (&con, "err".to_owned()).log();
    // Logger::new (&con, some_other_value_that_impl_Debug_and_Clone).log();
}

Playground
At the call sites (in the main function in the example), the compiler is able to guess the types automagically, so your users don't need to type them.
Note also that I used Self as the return type for the Logger::new method. This is equivalent to the full type that I am currently implementing, so in this case Self is an alias for Logger<'a, T>. I could as well have written: pub fn new (con: &'a DBCon, err: T) -> Logger<'a, T> but not pub fn new (con: &'a DBCon, err: T) -> Logger because Logger on its own is an incomplete type, lacking the generic parameters, and the compiler won't infer types in function prototypes.

