Examples with ManagedBacklogDebugger org.apache.camel.management.mbean.ManagedBacklogDebugger used on opensource projects

Example 1 with ManagedBacklogDebugger

use of org.apache.camel.management.mbean.ManagedBacklogDebugger in project camel by apache.

the class ManagedManagementStrategy method getManagedObjectName.

public <T> T getManagedObjectName(Object managedObject, String customName, Class<T> nameType) throws Exception {
    if (managedObject == null) {
        return null;
    }
    ObjectName objectName = null;
    if (managedObject instanceof ManagedCamelContext) {
        ManagedCamelContext mcc = (ManagedCamelContext) managedObject;
        objectName = getManagementNamingStrategy().getObjectNameForCamelContext(mcc.getContext());
    } else if (managedObject instanceof ManagedComponent) {
        ManagedComponent mc = (ManagedComponent) managedObject;
        objectName = getManagementNamingStrategy().getObjectNameForComponent(mc.getComponent(), mc.getComponentName());
    } else if (managedObject instanceof ManagedDataFormat) {
        ManagedDataFormat md = (ManagedDataFormat) managedObject;
        objectName = getManagementNamingStrategy().getObjectNameForDataFormat(md.getContext(), md.getDataFormat());
    } else if (managedObject instanceof ManagedEndpoint) {
        ManagedEndpoint me = (ManagedEndpoint) managedObject;
        objectName = getManagementNamingStrategy().getObjectNameForEndpoint(me.getEndpoint());
    } else if (managedObject instanceof Endpoint) {
        objectName = getManagementNamingStrategy().getObjectNameForEndpoint((Endpoint) managedObject);
    } else if (managedObject instanceof ManagedRoute) {
        ManagedRoute mr = (ManagedRoute) managedObject;
        objectName = getManagementNamingStrategy().getObjectNameForRoute(mr.getRoute());
    } else if (managedObject instanceof ManagedErrorHandler) {
        ManagedErrorHandler meh = (ManagedErrorHandler) managedObject;
        objectName = getManagementNamingStrategy().getObjectNameForErrorHandler(meh.getRouteContext(), meh.getErrorHandler(), meh.getErrorHandlerBuilder());
    } else if (managedObject instanceof ManagedProcessor) {
        ManagedProcessor mp = (ManagedProcessor) managedObject;
        objectName = getManagementNamingStrategy().getObjectNameForProcessor(mp.getContext(), mp.getProcessor(), mp.getDefinition());
    } else if (managedObject instanceof ManagedConsumer) {
        ManagedConsumer ms = (ManagedConsumer) managedObject;
        objectName = getManagementNamingStrategy().getObjectNameForConsumer(ms.getContext(), ms.getConsumer());
    } else if (managedObject instanceof ManagedProducer) {
        ManagedProducer ms = (ManagedProducer) managedObject;
        objectName = getManagementNamingStrategy().getObjectNameForProducer(ms.getContext(), ms.getProducer());
    } else if (managedObject instanceof ManagedTracer) {
        ManagedTracer mt = (ManagedTracer) managedObject;
        objectName = getManagementNamingStrategy().getObjectNameForTracer(mt.getContext(), mt.getTracer());
    } else if (managedObject instanceof ManagedBacklogTracer) {
        ManagedBacklogTracer mt = (ManagedBacklogTracer) managedObject;
        objectName = getManagementNamingStrategy().getObjectNameForTracer(mt.getContext(), mt.getBacklogTracer());
    } else if (managedObject instanceof ManagedBacklogDebugger) {
        ManagedBacklogDebugger md = (ManagedBacklogDebugger) managedObject;
        objectName = getManagementNamingStrategy().getObjectNameForTracer(md.getContext(), md.getBacklogDebugger());
    } else if (managedObject instanceof ManagedEventNotifier) {
        ManagedEventNotifier men = (ManagedEventNotifier) managedObject;
        objectName = getManagementNamingStrategy().getObjectNameForEventNotifier(men.getContext(), men.getEventNotifier());
    } else if (managedObject instanceof ManagedThreadPool) {
        ManagedThreadPool mes = (ManagedThreadPool) managedObject;
        objectName = getManagementNamingStrategy().getObjectNameForThreadPool(mes.getContext(), mes.getThreadPool(), mes.getId(), mes.getSourceId());
    } else if (managedObject instanceof ManagedService) {
        // check for managed service should be last
        ManagedService ms = (ManagedService) managedObject;
        // skip endpoints as they are already managed
        if (ms.getService() instanceof Endpoint) {
            return null;
        }
        objectName = getManagementNamingStrategy().getObjectNameForService(ms.getContext(), ms.getService());
    }
    return nameType.cast(objectName);
}

Example 2 with ManagedBacklogDebugger

use of org.apache.camel.management.mbean.ManagedBacklogDebugger in project camel by apache.

the class DefaultManagementLifecycleStrategy method getManagedObjectForService.

@SuppressWarnings("unchecked")
private Object getManagedObjectForService(CamelContext context, Service service, Route route) {
    // skip channel, UoW and dont double wrap instrumentation
    if (service instanceof Channel || service instanceof UnitOfWork || service instanceof InstrumentationProcessor) {
        return null;
    }
    // skip non managed services
    if (service instanceof NonManagedService) {
        return null;
    }
    Object answer = null;
    if (service instanceof ManagementAware) {
        return ((ManagementAware<Service>) service).getManagedObject(service);
    } else if (service instanceof Tracer) {
        // special for tracer
        Tracer tracer = (Tracer) service;
        ManagedTracer mt = managedTracers.get(tracer);
        if (mt == null) {
            mt = new ManagedTracer(context, tracer);
            mt.init(getManagementStrategy());
            managedTracers.put(tracer, mt);
        }
        return mt;
    } else if (service instanceof BacklogTracer) {
        // special for backlog tracer
        BacklogTracer backlogTracer = (BacklogTracer) service;
        ManagedBacklogTracer mt = managedBacklogTracers.get(backlogTracer);
        if (mt == null) {
            mt = new ManagedBacklogTracer(context, backlogTracer);
            mt.init(getManagementStrategy());
            managedBacklogTracers.put(backlogTracer, mt);
        }
        return mt;
    } else if (service instanceof BacklogDebugger) {
        // special for backlog debugger
        BacklogDebugger backlogDebugger = (BacklogDebugger) service;
        ManagedBacklogDebugger md = managedBacklogDebuggers.get(backlogDebugger);
        if (md == null) {
            md = new ManagedBacklogDebugger(context, backlogDebugger);
            md.init(getManagementStrategy());
            managedBacklogDebuggers.put(backlogDebugger, md);
        }
        return md;
    } else if (service instanceof DataFormat) {
        answer = getManagementObjectStrategy().getManagedObjectForDataFormat(context, (DataFormat) service);
    } else if (service instanceof Producer) {
        answer = getManagementObjectStrategy().getManagedObjectForProducer(context, (Producer) service);
    } else if (service instanceof Consumer) {
        answer = getManagementObjectStrategy().getManagedObjectForConsumer(context, (Consumer) service);
    } else if (service instanceof Processor) {
        // special for processors as we need to do some extra work
        return getManagedObjectForProcessor(context, (Processor) service, route);
    } else if (service instanceof ThrottlingInflightRoutePolicy) {
        answer = new ManagedThrottlingInflightRoutePolicy(context, (ThrottlingInflightRoutePolicy) service);
    } else if (service instanceof ThrottlingExceptionRoutePolicy) {
        answer = new ManagedThrottlingExceptionRoutePolicy(context, (ThrottlingExceptionRoutePolicy) service);
    } else if (service instanceof ConsumerCache) {
        answer = new ManagedConsumerCache(context, (ConsumerCache) service);
    } else if (service instanceof ProducerCache) {
        answer = new ManagedProducerCache(context, (ProducerCache) service);
    } else if (service instanceof DefaultEndpointRegistry) {
        answer = new ManagedEndpointRegistry(context, (DefaultEndpointRegistry) service);
    } else if (service instanceof TypeConverterRegistry) {
        answer = new ManagedTypeConverterRegistry(context, (TypeConverterRegistry) service);
    } else if (service instanceof RestRegistry) {
        answer = new ManagedRestRegistry(context, (RestRegistry) service);
    } else if (service instanceof InflightRepository) {
        answer = new ManagedInflightRepository(context, (InflightRepository) service);
    } else if (service instanceof AsyncProcessorAwaitManager) {
        answer = new ManagedAsyncProcessorAwaitManager(context, (AsyncProcessorAwaitManager) service);
    } else if (service instanceof RuntimeEndpointRegistry) {
        answer = new ManagedRuntimeEndpointRegistry(context, (RuntimeEndpointRegistry) service);
    } else if (service instanceof StreamCachingStrategy) {
        answer = new ManagedStreamCachingStrategy(context, (StreamCachingStrategy) service);
    } else if (service instanceof EventNotifier) {
        answer = getManagementObjectStrategy().getManagedObjectForEventNotifier(context, (EventNotifier) service);
    } else if (service instanceof TransformerRegistry) {
        answer = new ManagedTransformerRegistry(context, (TransformerRegistry) service);
    } else if (service instanceof ValidatorRegistry) {
        answer = new ManagedValidatorRegistry(context, (ValidatorRegistry) service);
    } else if (service instanceof RuntimeCamelCatalog) {
        answer = new ManagedRuntimeCamelCatalog(context, (RuntimeCamelCatalog) service);
    } else if (service != null) {
        // fallback as generic service
        answer = getManagementObjectStrategy().getManagedObjectForService(context, service);
    }
    if (answer != null && answer instanceof ManagedService) {
        ManagedService ms = (ManagedService) answer;
        ms.setRoute(route);
        ms.init(getManagementStrategy());
    }
    return answer;
}