管控平台 v5.2.3.0. - a.java 源代码

package b.a;

import b.a.j.b.f;
import b.a.j.b.h;
import io.sentry.connection.g;
import io.sentry.connection.i;
import io.sentry.connection.j;
import io.sentry.connection.k;
import io.sentry.connection.l;
import io.sentry.event.interfaces.DebugMetaInterface;
import io.sentry.event.interfaces.ExceptionInterface;
import io.sentry.event.interfaces.HttpInterface;
import io.sentry.event.interfaces.MessageInterface;
import io.sentry.event.interfaces.StackTraceInterface;
import io.sentry.event.interfaces.UserInterface;
import java.io.File;
import java.net.Authenticator;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import net.sqlcipher.BuildConfig;

public class a extends d {

    public static final int f60b = (int) TimeUnit.SECONDS.toMillis(1);

    public static final long f61c = TimeUnit.SECONDS.toMillis(1);
    public static final long d = TimeUnit.SECONDS.toMillis(1);
    private static final org.slf4j.b e = org.slf4j.c.i(a.class);
    private static final String f = Boolean.FALSE.toString();
    private static final Map<String, RejectedExecutionHandler> g;

    protected static final class b implements ThreadFactory {
        private static final AtomicInteger e = new AtomicInteger(1);

        private final ThreadGroup f62a;

        private final AtomicInteger f63b;

        private final String f64c;
        private final int d;

        @Override
        public Thread newThread(Runnable runnable) {
            Thread thread = new Thread(this.f62a, runnable, this.f64c + this.f63b.getAndIncrement(), 0L);
            if (!thread.isDaemon()) {
                thread.setDaemon(true);
            }
            int priority = thread.getPriority();
            int i = this.d;
            if (priority != i) {
                thread.setPriority(i);
            }
            return thread;
        }

        private b(int i) {
            this.f63b = new AtomicInteger(1);
            SecurityManager securityManager = System.getSecurityManager();
            this.f62a = securityManager != null ? securityManager.getThreadGroup() : Thread.currentThread().getThreadGroup();
            this.f64c = "sentry-pool-" + e.getAndIncrement() + "-thread-";
            this.d = i;
        }
    }

    static {
        HashMap hashMap = new HashMap();
        g = hashMap;
        hashMap.put("sync", new ThreadPoolExecutor.CallerRunsPolicy());
        g.put("discardnew", new ThreadPoolExecutor.DiscardPolicy());
        g.put("discardold", new ThreadPoolExecutor.DiscardOldestPolicy());
    }

    protected String A(io.sentry.dsn.a aVar) {
        return b.a.g.b.d("environment", aVar);
    }

    protected Map<String, String> B(io.sentry.dsn.a aVar) {
        return io.sentry.util.a.d(b.a.g.b.d("extra", aVar));
    }

    protected boolean C(io.sentry.dsn.a aVar) {
        return !f.equalsIgnoreCase(b.a.g.b.d("stacktrace.hidecommon", aVar));
    }

    protected Collection<String> D(io.sentry.dsn.a aVar) {
        String d2 = b.a.g.b.d("stacktrace.app.packages", aVar);
        if (io.sentry.util.a.a(d2)) {
            if (d2 == null) {
                e.warn("No 'stacktrace.app.packages' was configured, this option is highly recommended as it affects stacktrace grouping and display on Sentry. See documentation: https://docs.sentry.io/clients/java/config/#in-application-stack-frames");
            }
            return Collections.emptyList();
        }
        ArrayList arrayList = new ArrayList();
        for (String str : d2.split(com.igexin.push.core.b.ak)) {
            if (!str.trim().equals(BuildConfig.FLAVOR)) {
                arrayList.add(str);
            }
        }
        return arrayList;
    }

    protected int E(io.sentry.dsn.a aVar) {
        return io.sentry.util.a.e(b.a.g.b.d("maxmessagelength", aVar), 1000).intValue();
    }

    protected Set<String> F(io.sentry.dsn.a aVar) {
        String d2 = b.a.g.b.d("mdctags", aVar);
        if (io.sentry.util.a.a(d2)) {
            d2 = b.a.g.b.d("extratags", aVar);
            if (!io.sentry.util.a.a(d2)) {
                e.warn("The 'extratags' option is deprecated, please use the 'mdctags' option instead.");
            }
        }
        return io.sentry.util.a.g(d2);
    }

    protected String G(io.sentry.dsn.a aVar) {
        return b.a.g.b.d("http.proxy.host", aVar);
    }

    protected String H(io.sentry.dsn.a aVar) {
        return b.a.g.b.d("http.proxy.password", aVar);
    }

    protected int I(io.sentry.dsn.a aVar) {
        return io.sentry.util.a.e(b.a.g.b.d("http.proxy.port", aVar), 80).intValue();
    }

    protected String J(io.sentry.dsn.a aVar) {
        return b.a.g.b.d("http.proxy.user", aVar);
    }

    protected RejectedExecutionHandler K(io.sentry.dsn.a aVar) {
        String d2 = b.a.g.b.d("async.queue.overflow", aVar);
        String lowerCase = !io.sentry.util.a.a(d2) ? d2.toLowerCase() : "discardold";
        RejectedExecutionHandler rejectedExecutionHandler = g.get(lowerCase);
        if (rejectedExecutionHandler != null) {
            return rejectedExecutionHandler;
        }
        throw new RuntimeException("RejectedExecutionHandler not found: '" + lowerCase + "', valid choices are: " + Arrays.toString(g.keySet().toArray()));
    }

    protected String L(io.sentry.dsn.a aVar) {
        return b.a.g.b.d("release", aVar);
    }

    protected Double M(io.sentry.dsn.a aVar) {
        return io.sentry.util.a.c(b.a.g.b.d("sample.rate", aVar), null);
    }

    protected String N(io.sentry.dsn.a aVar) {
        return b.a.g.b.d("servername", aVar);
    }

    protected Map<String, String> O(io.sentry.dsn.a aVar) {
        return io.sentry.util.a.h(b.a.g.b.d("tags", aVar));
    }

    protected int P(io.sentry.dsn.a aVar) {
        return io.sentry.util.a.e(b.a.g.b.d("timeout", aVar), Integer.valueOf(f60b)).intValue();
    }

    protected boolean Q(io.sentry.dsn.a aVar) {
        return !f.equalsIgnoreCase(b.a.g.b.d("uncaught.handler.enabled", aVar));
    }

    @Override
    public c a(io.sentry.dsn.a aVar) {
        try {
            c cVar = new c(f(aVar), y(aVar));
            try {
                Class.forName("javax.servlet.ServletRequestListener", false, getClass().getClassLoader());
                cVar.a(new io.sentry.event.b.d());
            } catch (ClassNotFoundException unused) {
                e.debug("The current environment doesn't provide access to servlets, or provides an unsupported version.");
            }
            cVar.a(new io.sentry.event.b.b(cVar));
            d(cVar, aVar);
            return cVar;
        } catch (Exception e2) {
            e.error("Failed to initialize sentry, falling back to no-op client", (Throwable) e2);
            return new c(new i(), new io.sentry.context.c());
        }
    }

    protected c d(c cVar, io.sentry.dsn.a aVar) {
        String L = L(aVar);
        if (L != null) {
            cVar.l(L);
        }
        String z = z(aVar);
        if (z != null) {
            cVar.j(z);
        }
        String A = A(aVar);
        if (A != null) {
            cVar.k(A);
        }
        String N = N(aVar);
        if (N != null) {
            cVar.m(N);
        }
        Map<String, String> O = O(aVar);
        if (!O.isEmpty()) {
            for (Map.Entry<String, String> entry : O.entrySet()) {
                cVar.d(entry.getKey(), entry.getValue());
            }
        }
        Set<String> F = F(aVar);
        if (!F.isEmpty()) {
            Iterator<String> it = F.iterator();
            while (it.hasNext()) {
                cVar.c(it.next());
            }
        }
        Map<String, String> B = B(aVar);
        if (!B.isEmpty()) {
            for (Map.Entry<String, String> entry2 : B.entrySet()) {
                cVar.b(entry2.getKey(), entry2.getValue());
            }
        }
        if (Q(aVar)) {
            cVar.n();
        }
        Iterator<String> it2 = D(aVar).iterator();
        while (it2.hasNext()) {
            b.a.i.b.a(it2.next());
        }
        return cVar;
    }

    protected io.sentry.connection.d e(io.sentry.dsn.a aVar, io.sentry.connection.d dVar) {
        int p = p(aVar);
        int m = m(aVar);
        int n = n(aVar);
        return new io.sentry.connection.b(dVar, new ThreadPoolExecutor(p, p, 0L, TimeUnit.MILLISECONDS, n == -1 ? new LinkedBlockingDeque() : new LinkedBlockingDeque(n), new b(m), K(aVar)), l(aVar), o(aVar));
    }

    protected io.sentry.connection.d f(io.sentry.dsn.a aVar) {
        io.sentry.connection.d g2;
        b.a.f.a q;
        String i = aVar.i();
        if (i.equalsIgnoreCase("http") || i.equalsIgnoreCase("https")) {
            e.debug("Using an {} connection to Sentry.", i.toUpperCase());
            g2 = g(aVar);
        } else if (i.equalsIgnoreCase("out")) {
            e.debug("Using StdOut to send events.");
            g2 = j(aVar);
        } else {
            if (!i.equalsIgnoreCase("noop")) {
                throw new IllegalStateException("Couldn't create a connection for the protocol '" + i + "'");
            }
            e.debug("Using noop to send events.");
            g2 = new i();
        }
        io.sentry.connection.d dVar = g2;
        io.sentry.connection.c cVar = null;
        if (r(aVar) && (q = q(aVar)) != null) {
            cVar = new io.sentry.connection.c(dVar, q, s(aVar), u(aVar), Long.valueOf(v(aVar)).longValue());
            dVar = cVar;
        }
        if (k(aVar)) {
            dVar = e(aVar, dVar);
        }
        return cVar != null ? cVar.A(dVar) : dVar;
    }

    protected io.sentry.connection.d g(io.sentry.dsn.a aVar) {
        Proxy proxy;
        URL H = g.H(aVar.m(), aVar.h());
        String G = G(aVar);
        String J = J(aVar);
        String H2 = H(aVar);
        int I = I(aVar);
        if (G != null) {
            Proxy proxy2 = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(G, I));
            if (J != null && H2 != null) {
                Authenticator.setDefault(new k(J, H2));
            }
            proxy = proxy2;
        } else {
            proxy = null;
        }
        Double M = M(aVar);
        g gVar = new g(H, aVar.k(), aVar.l(), proxy, M != null ? new l(M.doubleValue()) : null);
        gVar.K(i(aVar));
        gVar.J(P(aVar));
        gVar.I(w(aVar));
        return gVar;
    }

    protected b.a.j.b.e h(int i) {
        return new b.a.j.b.e(i);
    }

    protected b.a.j.a i(io.sentry.dsn.a aVar) {
        int E = E(aVar);
        b.a.j.b.e h = h(E);
        h hVar = new h();
        hVar.e(C(aVar));
        hVar.d(D(aVar));
        h.d(StackTraceInterface.class, hVar);
        h.d(ExceptionInterface.class, new b.a.j.b.b(hVar));
        h.d(MessageInterface.class, new f(E));
        h.d(UserInterface.class, new b.a.j.b.i());
        h.d(DebugMetaInterface.class, new b.a.j.b.a());
        h.d(HttpInterface.class, new b.a.j.b.c());
        h.j(x(aVar));
        return h;
    }

    protected io.sentry.connection.d j(io.sentry.dsn.a aVar) {
        j jVar = new j(System.out);
        jVar.m(i(aVar));
        return jVar;
    }

    protected boolean k(io.sentry.dsn.a aVar) {
        return !f.equalsIgnoreCase(b.a.g.b.d("async", aVar));
    }

    protected boolean l(io.sentry.dsn.a aVar) {
        return !f.equalsIgnoreCase(b.a.g.b.d("async.gracefulshutdown", aVar));
    }

    protected int m(io.sentry.dsn.a aVar) {
        return io.sentry.util.a.e(b.a.g.b.d("async.priority", aVar), 1).intValue();
    }

    protected int n(io.sentry.dsn.a aVar) {
        return io.sentry.util.a.e(b.a.g.b.d("async.queuesize", aVar), 50).intValue();
    }

    protected long o(io.sentry.dsn.a aVar) {
        return io.sentry.util.a.f(b.a.g.b.d("async.shutdowntimeout", aVar), Long.valueOf(d)).longValue();
    }

    protected int p(io.sentry.dsn.a aVar) {
        return io.sentry.util.a.e(b.a.g.b.d("async.threads", aVar), Integer.valueOf(Runtime.getRuntime().availableProcessors())).intValue();
    }

    protected b.a.f.a q(io.sentry.dsn.a aVar) {
        String d2 = b.a.g.b.d("buffer.dir", aVar);
        if (d2 != null) {
            return new b.a.f.b(new File(d2), t(aVar));
        }
        return null;
    }

    protected boolean r(io.sentry.dsn.a aVar) {
        String d2 = b.a.g.b.d("buffer.enabled", aVar);
        if (d2 != null) {
            return Boolean.parseBoolean(d2);
        }
        return true;
    }

    protected long s(io.sentry.dsn.a aVar) {
        return io.sentry.util.a.f(b.a.g.b.d("buffer.flushtime", aVar), 60000L).longValue();
    }

    protected int t(io.sentry.dsn.a aVar) {
        return io.sentry.util.a.e(b.a.g.b.d("buffer.size", aVar), 10).intValue();
    }

    protected boolean u(io.sentry.dsn.a aVar) {
        return !f.equalsIgnoreCase(b.a.g.b.d("buffer.gracefulshutdown", aVar));
    }

    protected long v(io.sentry.dsn.a aVar) {
        return io.sentry.util.a.f(b.a.g.b.d("buffer.shutdowntimeout", aVar), Long.valueOf(f61c)).longValue();
    }

    protected boolean w(io.sentry.dsn.a aVar) {
        return aVar.j().contains("naive");
    }

    protected boolean x(io.sentry.dsn.a aVar) {
        return !f.equalsIgnoreCase(b.a.g.b.d("compression", aVar));
    }

    protected io.sentry.context.a y(io.sentry.dsn.a aVar) {
        return new io.sentry.context.c();
    }

    protected String z(io.sentry.dsn.a aVar) {
        return b.a.g.b.d("dist", aVar);
    }
}