kazusa
/
skywalking-java
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Register graph finish.

This commit is contained in:
peng-yongsheng 2017-11-14 00:39:37 +08:00
parent d8ba62e90b
commit 5967cf4be6
85 changed files with 751 additions and 746 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
apm-collector/apm-collector-agent/collector-agent-grpc-provider/src/main/java/org/skywalking/apm/collector/agent/grpc/AgentModuleGRPCProvider.java
View File

@ -29,13 +29,10 @@ import org.skywalking.apm.collector.agent.grpc.handler.naming.AgentGRPCNamingHan
import org.skywalking.apm.collector.agent.grpc.handler.naming.AgentGRPCNamingListener;
import org.skywalking.apm.collector.agent.stream.AgentStreamSingleton;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cluster.ClusterModule;
import org.skywalking.apm.collector.cluster.service.ModuleListenerService;
import org.skywalking.apm.collector.cluster.service.ModuleRegisterService;
import org.skywalking.apm.collector.core.graph.Graph;
import org.skywalking.apm.collector.core.module.Module;
import org.skywalking.apm.collector.core.module.ModuleNotFoundException;
import org.skywalking.apm.collector.core.module.ModuleProvider;
import org.skywalking.apm.collector.core.module.ServiceNotProvidedException;
import org.skywalking.apm.collector.grpc.manager.GRPCManagerModule;
@ -45,8 +42,6 @@ import org.skywalking.apm.collector.naming.service.NamingHandlerRegisterService;
import org.skywalking.apm.collector.remote.RemoteModule;
import org.skywalking.apm.collector.server.Server;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.register.Application;
import org.skywalking.apm.collector.stream.worker.base.WorkerCreateListener;
/**
@ -74,31 +69,21 @@ public class AgentModuleGRPCProvider extends ModuleProvider {
String host = config.getProperty(HOST);
Integer port = (Integer)config.get(PORT);
try {
ModuleRegisterService moduleRegisterService = getManager().find(ClusterModule.NAME).getService(ModuleRegisterService.class);
moduleRegisterService.register(AgentModule.NAME, this.name(), new AgentModuleGRPCRegistration(host, port));
ModuleRegisterService moduleRegisterService = getManager().find(ClusterModule.NAME).getService(ModuleRegisterService.class);
moduleRegisterService.register(AgentModule.NAME, this.name(), new AgentModuleGRPCRegistration(host, port));
AgentGRPCNamingListener namingListener = new AgentGRPCNamingListener();
ModuleListenerService moduleListenerService = getManager().find(ClusterModule.NAME).getService(ModuleListenerService.class);
moduleListenerService.addListener(namingListener);
AgentGRPCNamingListener namingListener = new AgentGRPCNamingListener();
ModuleListenerService moduleListenerService = getManager().find(ClusterModule.NAME).getService(ModuleListenerService.class);
moduleListenerService.addListener(namingListener);
NamingHandlerRegisterService namingHandlerRegisterService = getManager().find(NamingModule.NAME).getService(NamingHandlerRegisterService.class);
namingHandlerRegisterService.register(new AgentGRPCNamingHandler(namingListener));
NamingHandlerRegisterService namingHandlerRegisterService = getManager().find(NamingModule.NAME).getService(NamingHandlerRegisterService.class);
namingHandlerRegisterService.register(new AgentGRPCNamingHandler(namingListener));
CacheServiceManager cacheServiceManager = new CacheServiceManager();
cacheServiceManager.init(getManager());
GRPCManagerService managerService = getManager().find(GRPCManagerModule.NAME).getService(GRPCManagerService.class);
Server gRPCServer = managerService.createIfAbsent(host, port);
DAOService daoService = getManager().find(StorageModule.NAME).getService(DAOService.class);
GRPCManagerService managerService = getManager().find(GRPCManagerModule.NAME).getService(GRPCManagerService.class);
Server gRPCServer = managerService.createIfAbsent(host, port);
AgentStreamSingleton agentStreamSingleton = AgentStreamSingleton.getInstance(getManager(), cacheServiceManager, new WorkerCreateListener());
addHandlers(daoService, gRPCServer, cacheServiceManager, agentStreamSingleton);
} catch (ModuleNotFoundException e) {
throw new ServiceNotProvidedException(e.getMessage());
}
AgentStreamSingleton.getInstance(getManager(), new WorkerCreateListener());
addHandlers(gRPCServer);
}
@Override public void notifyAfterCompleted() throws ServiceNotProvidedException {
@ -109,12 +94,10 @@ public class AgentModuleGRPCProvider extends ModuleProvider {
return new String[] {ClusterModule.NAME, NamingModule.NAME, StorageModule.NAME, GRPCManagerModule.NAME, CacheModule.NAME, RemoteModule.NAME};
}
private void addHandlers(DAOService daoService, Server gRPCServer, CacheServiceManager cacheServiceManager,
AgentStreamSingleton agentStreamSingleton) {
Graph<Application> applicationRegisterGraph = agentStreamSingleton.getApplicationRegisterGraph();
gRPCServer.addHandler(new ApplicationRegisterServiceHandler(cacheServiceManager, applicationRegisterGraph));
gRPCServer.addHandler(new InstanceDiscoveryServiceHandler(daoService, cacheServiceManager));
gRPCServer.addHandler(new ServiceNameDiscoveryServiceHandler(cacheServiceManager));
private void addHandlers(Server gRPCServer) {
gRPCServer.addHandler(new ApplicationRegisterServiceHandler(getManager()));
gRPCServer.addHandler(new InstanceDiscoveryServiceHandler(getManager()));
gRPCServer.addHandler(new ServiceNameDiscoveryServiceHandler(getManager()));
gRPCServer.addHandler(new JVMMetricsServiceHandler());
gRPCServer.addHandler(new TraceSegmentServiceHandler());
}

17
apm-collector/apm-collector-agent/collector-agent-grpc-provider/src/main/java/org/skywalking/apm/collector/agent/grpc/handler/ApplicationRegisterServiceHandler.java
View File

@ -21,8 +21,9 @@ package org.skywalking.apm.collector.agent.grpc.handler;
import com.google.protobuf.ProtocolStringList;
import io.grpc.stub.StreamObserver;
import org.skywalking.apm.collector.agent.stream.worker.register.ApplicationIDService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.graph.Graph;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.module.ModuleNotFoundException;
import org.skywalking.apm.collector.core.module.ServiceNotProvidedException;
import org.skywalking.apm.collector.server.grpc.GRPCHandler;
import org.skywalking.apm.network.proto.Application;
import org.skywalking.apm.network.proto.ApplicationMapping;
@ -40,9 +41,8 @@ public class ApplicationRegisterServiceHandler extends ApplicationRegisterServic
private final ApplicationIDService applicationIDService;
public ApplicationRegisterServiceHandler(CacheServiceManager cacheServiceManager,
Graph<org.skywalking.apm.collector.storage.table.register.Application> applicationRegisterGraph) {
applicationIDService = new ApplicationIDService(cacheServiceManager, applicationRegisterGraph);
public ApplicationRegisterServiceHandler(ModuleManager moduleManager) {
applicationIDService = new ApplicationIDService(moduleManager);
}
@Override public void register(Application request, StreamObserver<ApplicationMapping> responseObserver) {
@ -52,7 +52,12 @@ public class ApplicationRegisterServiceHandler extends ApplicationRegisterServic
ApplicationMapping.Builder builder = ApplicationMapping.newBuilder();
for (int i = 0; i < applicationCodes.size(); i++) {
String applicationCode = applicationCodes.get(i);
int applicationId = applicationIDService.getOrCreate(applicationCode);
int applicationId = 0;
try {
applicationId = applicationIDService.getOrCreate(applicationCode);
} catch (ModuleNotFoundException | ServiceNotProvidedException e) {
logger.error(e.getMessage(), e);
}
if (applicationId != 0) {
KeyWithIntegerValue value = KeyWithIntegerValue.newBuilder().setKey(applicationCode).setValue(applicationId).build();

26
apm-collector/apm-collector-agent/collector-agent-grpc-provider/src/main/java/org/skywalking/apm/collector/agent/grpc/handler/InstanceDiscoveryServiceHandler.java
View File

@ -22,10 +22,11 @@ import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import io.grpc.stub.StreamObserver;
import org.skywalking.apm.collector.agent.stream.worker.register.InstanceIDService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.module.ModuleNotFoundException;
import org.skywalking.apm.collector.core.module.ServiceNotProvidedException;
import org.skywalking.apm.collector.core.util.TimeBucketUtils;
import org.skywalking.apm.collector.server.grpc.GRPCHandler;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.network.proto.ApplicationInstance;
import org.skywalking.apm.network.proto.ApplicationInstanceMapping;
import org.skywalking.apm.network.proto.ApplicationInstanceRecover;
@ -44,14 +45,19 @@ public class InstanceDiscoveryServiceHandler extends InstanceDiscoveryServiceGrp
private final InstanceIDService instanceIDService;
public InstanceDiscoveryServiceHandler(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.instanceIDService = new InstanceIDService(daoService, cacheServiceManager);
public InstanceDiscoveryServiceHandler(ModuleManager moduleManager) {
this.instanceIDService = new InstanceIDService(moduleManager);
}
@Override
public void register(ApplicationInstance request, StreamObserver<ApplicationInstanceMapping> responseObserver) {
long timeBucket = TimeBucketUtils.INSTANCE.getSecondTimeBucket(request.getRegisterTime());
int instanceId = instanceIDService.getOrCreate(request.getApplicationId(), request.getAgentUUID(), timeBucket, buildOsInfo(request.getOsinfo()));
int instanceId = 0;
try {
instanceId = instanceIDService.getOrCreate(request.getApplicationId(), request.getAgentUUID(), timeBucket, buildOsInfo(request.getOsinfo()));
} catch (ModuleNotFoundException | ServiceNotProvidedException e) {
logger.error(e.getMessage(), e);
}
ApplicationInstanceMapping.Builder builder = ApplicationInstanceMapping.newBuilder();
builder.setApplicationId(request.getApplicationId());
builder.setApplicationInstanceId(instanceId);
@ -62,7 +68,11 @@ public class InstanceDiscoveryServiceHandler extends InstanceDiscoveryServiceGrp
@Override
public void registerRecover(ApplicationInstanceRecover request, StreamObserver<Downstream> responseObserver) {
long timeBucket = TimeBucketUtils.INSTANCE.getSecondTimeBucket(request.getRegisterTime());
instanceIDService.recover(request.getApplicationInstanceId(), request.getApplicationId(), timeBucket, buildOsInfo(request.getOsinfo()));
try {
instanceIDService.recover(request.getApplicationInstanceId(), request.getApplicationId(), timeBucket, buildOsInfo(request.getOsinfo()));
} catch (ModuleNotFoundException | ServiceNotProvidedException e) {
logger.error(e.getMessage(), e);
}
responseObserver.onNext(Downstream.newBuilder().build());
responseObserver.onCompleted();
}
@ -74,9 +84,9 @@ public class InstanceDiscoveryServiceHandler extends InstanceDiscoveryServiceGrp
osInfoJson.addProperty("processId", osinfo.getProcessNo());
JsonArray ipv4Array = new JsonArray();
osinfo.getIpv4SList().forEach(ipv4 -> {
for (String ipv4 : osinfo.getIpv4SList()) {
ipv4Array.add(ipv4);
});
}
osInfoJson.add("ipv4s", ipv4Array);
return osInfoJson.toString();
}

6
apm-collector/apm-collector-agent/collector-agent-grpc-provider/src/main/java/org/skywalking/apm/collector/agent/grpc/handler/ServiceNameDiscoveryServiceHandler.java
View File

@ -21,7 +21,7 @@ package org.skywalking.apm.collector.agent.grpc.handler;
import io.grpc.stub.StreamObserver;
import java.util.List;
import org.skywalking.apm.collector.agent.stream.worker.register.ServiceNameService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.server.grpc.GRPCHandler;
import org.skywalking.apm.network.proto.ServiceNameCollection;
import org.skywalking.apm.network.proto.ServiceNameDiscoveryServiceGrpc;
@ -40,8 +40,8 @@ public class ServiceNameDiscoveryServiceHandler extends ServiceNameDiscoveryServ
private final ServiceNameService serviceNameService;
public ServiceNameDiscoveryServiceHandler(CacheServiceManager cacheServiceManager) {
this.serviceNameService = new ServiceNameService(cacheServiceManager);
public ServiceNameDiscoveryServiceHandler(ModuleManager moduleManager) {
this.serviceNameService = new ServiceNameService(moduleManager);
}
@Override public void discovery(ServiceNameCollection request,

27
apm-collector/apm-collector-agent/collector-agent-jetty-provider/src/main/java/org/skywalking/apm/collector/agent/jetty/AgentModuleJettyProvider.java
View File

@ -28,7 +28,6 @@ import org.skywalking.apm.collector.cluster.ClusterModule;
import org.skywalking.apm.collector.cluster.service.ModuleListenerService;
import org.skywalking.apm.collector.cluster.service.ModuleRegisterService;
import org.skywalking.apm.collector.core.module.Module;
import org.skywalking.apm.collector.core.module.ModuleNotFoundException;
import org.skywalking.apm.collector.core.module.ModuleProvider;
import org.skywalking.apm.collector.core.module.ServiceNotProvidedException;
import org.skywalking.apm.collector.jetty.manager.JettyManagerModule;
@ -66,25 +65,21 @@ public class AgentModuleJettyProvider extends ModuleProvider {
Integer port = (Integer)config.get(PORT);
String contextPath = config.getProperty(CONTEXT_PATH);
try {
ModuleRegisterService moduleRegisterService = getManager().find(ClusterModule.NAME).getService(ModuleRegisterService.class);
moduleRegisterService.register(AgentModule.NAME, this.name(), new AgentModuleJettyRegistration(host, port, contextPath));
ModuleRegisterService moduleRegisterService = getManager().find(ClusterModule.NAME).getService(ModuleRegisterService.class);
moduleRegisterService.register(AgentModule.NAME, this.name(), new AgentModuleJettyRegistration(host, port, contextPath));
AgentJettyNamingListener namingListener = new AgentJettyNamingListener();
ModuleListenerService moduleListenerService = getManager().find(ClusterModule.NAME).getService(ModuleListenerService.class);
moduleListenerService.addListener(namingListener);
AgentJettyNamingListener namingListener = new AgentJettyNamingListener();
ModuleListenerService moduleListenerService = getManager().find(ClusterModule.NAME).getService(ModuleListenerService.class);
moduleListenerService.addListener(namingListener);
NamingHandlerRegisterService namingHandlerRegisterService = getManager().find(NamingModule.NAME).getService(NamingHandlerRegisterService.class);
namingHandlerRegisterService.register(new AgentJettyNamingHandler(namingListener));
NamingHandlerRegisterService namingHandlerRegisterService = getManager().find(NamingModule.NAME).getService(NamingHandlerRegisterService.class);
namingHandlerRegisterService.register(new AgentJettyNamingHandler(namingListener));
DAOService daoService = getManager().find(StorageModule.NAME).getService(DAOService.class);
DAOService daoService = getManager().find(StorageModule.NAME).getService(DAOService.class);
JettyManagerService managerService = getManager().find(JettyManagerModule.NAME).getService(JettyManagerService.class);
Server jettyServer = managerService.createIfAbsent(host, port, contextPath);
addHandlers(daoService, jettyServer);
} catch (ModuleNotFoundException e) {
throw new ServiceNotProvidedException(e.getMessage());
}
JettyManagerService managerService = getManager().find(JettyManagerModule.NAME).getService(JettyManagerService.class);
Server jettyServer = managerService.createIfAbsent(host, port, contextPath);
addHandlers(daoService, jettyServer);
}
@Override public void notifyAfterCompleted() throws ServiceNotProvidedException {

29
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/AgentStreamSingleton.java
View File

@ -19,13 +19,8 @@
package org.skywalking.apm.collector.agent.stream;
import org.skywalking.apm.collector.agent.stream.graph.RegisterStreamGraph;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.graph.Graph;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.module.ModuleNotFoundException;
import org.skywalking.apm.collector.core.module.ServiceNotProvidedException;
import org.skywalking.apm.collector.core.util.ObjectUtils;
import org.skywalking.apm.collector.storage.table.register.Application;
import org.skywalking.apm.collector.stream.worker.base.WorkerCreateListener;
/**
@ -36,15 +31,10 @@ public class AgentStreamSingleton {
private static AgentStreamSingleton INSTANCE;
private final ModuleManager moduleManager;
private final CacheServiceManager cacheServiceManager;
private final WorkerCreateListener workerCreateListener;
private Graph<Application> applicationRegisterGraph;
public AgentStreamSingleton(ModuleManager moduleManager, CacheServiceManager cacheServiceManager,
WorkerCreateListener workerCreateListener) throws ServiceNotProvidedException, ModuleNotFoundException {
public AgentStreamSingleton(ModuleManager moduleManager, WorkerCreateListener workerCreateListener) {
this.moduleManager = moduleManager;
this.cacheServiceManager = cacheServiceManager;
this.workerCreateListener = workerCreateListener;
createJVMGraph();
createRegisterGraph();
@ -52,10 +42,9 @@ public class AgentStreamSingleton {
}
public static synchronized AgentStreamSingleton getInstance(ModuleManager moduleManager,
CacheServiceManager cacheServiceManager,
WorkerCreateListener workerCreateListener) throws ServiceNotProvidedException, ModuleNotFoundException {
WorkerCreateListener workerCreateListener) {
if (ObjectUtils.isEmpty(INSTANCE)) {
INSTANCE = new AgentStreamSingleton(moduleManager, cacheServiceManager, workerCreateListener);
INSTANCE = new AgentStreamSingleton(moduleManager, workerCreateListener);
}
return INSTANCE;
}
@ -64,13 +53,11 @@ public class AgentStreamSingleton {
}
private void createRegisterGraph() throws ServiceNotProvidedException, ModuleNotFoundException {
RegisterStreamGraph registerStreamGraph = new RegisterStreamGraph(moduleManager, cacheServiceManager, workerCreateListener);
applicationRegisterGraph = registerStreamGraph.createApplicationRegisterGraph();
}
public Graph<Application> getApplicationRegisterGraph() {
return applicationRegisterGraph;
private void createRegisterGraph() {
RegisterStreamGraph registerStreamGraph = new RegisterStreamGraph(moduleManager, workerCreateListener);
registerStreamGraph.createApplicationRegisterGraph();
registerStreamGraph.createInstanceRegisterGraph();
registerStreamGraph.createServiceNameRegisterGraph();
}
private void createTraceGraph() {

50
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/graph/RegisterStreamGraph.java
View File

@ -20,12 +20,13 @@ package org.skywalking.apm.collector.agent.stream.graph;
import org.skywalking.apm.collector.agent.stream.worker.register.ApplicationRegisterRemoteWorker;
import org.skywalking.apm.collector.agent.stream.worker.register.ApplicationRegisterSerialWorker;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.agent.stream.worker.register.InstanceRegisterRemoteWorker;
import org.skywalking.apm.collector.agent.stream.worker.register.InstanceRegisterSerialWorker;
import org.skywalking.apm.collector.agent.stream.worker.register.ServiceNameRegisterRemoteWorker;
import org.skywalking.apm.collector.agent.stream.worker.register.ServiceNameRegisterSerialWorker;
import org.skywalking.apm.collector.core.graph.Graph;
import org.skywalking.apm.collector.core.graph.GraphManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.module.ModuleNotFoundException;
import org.skywalking.apm.collector.core.module.ServiceNotProvidedException;
import org.skywalking.apm.collector.queue.QueueModule;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.remote.RemoteModule;
@ -33,6 +34,8 @@ import org.skywalking.apm.collector.remote.service.RemoteSenderService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.register.Application;
import org.skywalking.apm.collector.storage.table.register.Instance;
import org.skywalking.apm.collector.storage.table.register.ServiceName;
import org.skywalking.apm.collector.stream.worker.base.WorkerCreateListener;
/**
@ -41,28 +44,53 @@ import org.skywalking.apm.collector.stream.worker.base.WorkerCreateListener;
public class RegisterStreamGraph {
public static final int APPLICATION_REGISTER_GRAPH_ID = 200;
public static final int INSTANCE_REGISTER_GRAPH_ID = 201;
public static final int SERVICE_NAME_REGISTER_GRAPH_ID = 202;
private final ModuleManager moduleManager;
private final CacheServiceManager cacheServiceManager;
private final WorkerCreateListener workerCreateListener;
public RegisterStreamGraph(ModuleManager moduleManager,
CacheServiceManager cacheServiceManager,
WorkerCreateListener workerCreateListener) {
public RegisterStreamGraph(ModuleManager moduleManager, WorkerCreateListener workerCreateListener) {
this.moduleManager = moduleManager;
this.cacheServiceManager = cacheServiceManager;
this.workerCreateListener = workerCreateListener;
}
public Graph<Application> createApplicationRegisterGraph() throws ModuleNotFoundException, ServiceNotProvidedException {
@SuppressWarnings("unchecked")
public Graph<Application> createApplicationRegisterGraph() {
DAOService daoService = moduleManager.find(StorageModule.NAME).getService(DAOService.class);
RemoteSenderService remoteSenderService = moduleManager.find(RemoteModule.NAME).getService(RemoteSenderService.class);
QueueCreatorService<Application> queueCreatorService = moduleManager.find(QueueModule.NAME).getService(QueueCreatorService.class);
Graph<Application> graph = GraphManager.INSTANCE.createIfAbsent(APPLICATION_REGISTER_GRAPH_ID, Application.class);
graph.addNode(new ApplicationRegisterRemoteWorker.Factory(daoService, cacheServiceManager, remoteSenderService, APPLICATION_REGISTER_GRAPH_ID).create(workerCreateListener))
.addNext(new ApplicationRegisterSerialWorker.Factory(daoService, cacheServiceManager, queueCreatorService).create(workerCreateListener));
graph.addNode(new ApplicationRegisterRemoteWorker.Factory(moduleManager, remoteSenderService, APPLICATION_REGISTER_GRAPH_ID).create(workerCreateListener))
.addNext(new ApplicationRegisterSerialWorker.Factory(moduleManager, queueCreatorService).create(workerCreateListener));
return graph;
}
@SuppressWarnings("unchecked")
public Graph<Instance> createInstanceRegisterGraph() {
DAOService daoService = moduleManager.find(StorageModule.NAME).getService(DAOService.class);
RemoteSenderService remoteSenderService = moduleManager.find(RemoteModule.NAME).getService(RemoteSenderService.class);
QueueCreatorService<Instance> queueCreatorService = moduleManager.find(QueueModule.NAME).getService(QueueCreatorService.class);
Graph<Instance> graph = GraphManager.INSTANCE.createIfAbsent(INSTANCE_REGISTER_GRAPH_ID, Instance.class);
graph.addNode(new InstanceRegisterRemoteWorker.Factory(moduleManager, remoteSenderService, INSTANCE_REGISTER_GRAPH_ID).create(workerCreateListener))
.addNext(new InstanceRegisterSerialWorker.Factory(moduleManager, queueCreatorService).create(workerCreateListener));
return graph;
}
@SuppressWarnings("unchecked")
public Graph<ServiceName> createServiceNameRegisterGraph() {
DAOService daoService = moduleManager.find(StorageModule.NAME).getService(DAOService.class);
RemoteSenderService remoteSenderService = moduleManager.find(RemoteModule.NAME).getService(RemoteSenderService.class);
QueueCreatorService<ServiceName> queueCreatorService = moduleManager.find(QueueModule.NAME).getService(QueueCreatorService.class);
Graph<ServiceName> graph = GraphManager.INSTANCE.createIfAbsent(SERVICE_NAME_REGISTER_GRAPH_ID, ServiceName.class);
graph.addNode(new ServiceNameRegisterRemoteWorker.Factory(moduleManager, remoteSenderService, SERVICE_NAME_REGISTER_GRAPH_ID).create(workerCreateListener))
.addNext(new ServiceNameRegisterSerialWorker.Factory(moduleManager, queueCreatorService).create(workerCreateListener));
return graph;
}
}

19
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/parser/SegmentParse.java
View File

@ -34,7 +34,7 @@ import org.skywalking.apm.collector.agent.stream.worker.trace.noderef.NodeRefere
import org.skywalking.apm.collector.agent.stream.worker.trace.segment.SegmentCostSpanListener;
import org.skywalking.apm.collector.agent.stream.worker.trace.service.ServiceEntrySpanListener;
import org.skywalking.apm.collector.agent.stream.worker.trace.serviceref.ServiceReferenceSpanListener;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.storage.table.segment.Segment;
import org.skywalking.apm.network.proto.SpanType;
import org.skywalking.apm.network.proto.TraceSegmentObject;
@ -51,18 +51,18 @@ public class SegmentParse {
private final Logger logger = LoggerFactory.getLogger(SegmentParse.class);
private final List<SpanListener> spanListeners;
private final CacheServiceManager cacheServiceManager;
private final ModuleManager moduleManager;
private String segmentId;
public SegmentParse(CacheServiceManager cacheServiceManager) {
this.cacheServiceManager = cacheServiceManager;
public SegmentParse(ModuleManager moduleManager) {
this.moduleManager = moduleManager;
this.spanListeners = new ArrayList<>();
this.spanListeners.add(new NodeComponentSpanListener());
this.spanListeners.add(new NodeMappingSpanListener());
this.spanListeners.add(new NodeReferenceSpanListener(cacheServiceManager));
this.spanListeners.add(new SegmentCostSpanListener(cacheServiceManager));
this.spanListeners.add(new NodeReferenceSpanListener(moduleManager));
this.spanListeners.add(new SegmentCostSpanListener(moduleManager));
this.spanListeners.add(new GlobalTraceSpanListener());
this.spanListeners.add(new ServiceEntrySpanListener(cacheServiceManager));
this.spanListeners.add(new ServiceEntrySpanListener(moduleManager));
this.spanListeners.add(new ServiceReferenceSpanListener());
this.spanListeners.add(new InstPerformanceSpanListener());
}
@ -73,6 +73,7 @@ public class SegmentParse {
TraceSegmentObject segmentObject = TraceSegmentObject.parseFrom(segment.getSegment());
SegmentDecorator segmentDecorator = new SegmentDecorator(segmentObject);
if (!preBuild(traceIds, segmentDecorator)) {
logger.debug("This segment id exchange not success, write to buffer file, id: {}", segmentId);
@ -114,7 +115,7 @@ public class SegmentParse {
for (int i = 0; i < segmentDecorator.getRefsCount(); i++) {
ReferenceDecorator referenceDecorator = segmentDecorator.getRefs(i);
if (!ReferenceIdExchanger.getInstance(cacheServiceManager).exchange(referenceDecorator, applicationId)) {
if (!ReferenceIdExchanger.getInstance(moduleManager).exchange(referenceDecorator, applicationId)) {
return false;
}
@ -124,7 +125,7 @@ public class SegmentParse {
for (int i = 0; i < segmentDecorator.getSpansCount(); i++) {
SpanDecorator spanDecorator = segmentDecorator.getSpans(i);
if (!SpanIdExchanger.getInstance(cacheServiceManager).exchange(spanDecorator, applicationId)) {
if (!SpanIdExchanger.getInstance(moduleManager).exchange(spanDecorator, applicationId)) {
return false;
}

27
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/parser/standardization/ReferenceIdExchanger.java
View File

@ -19,7 +19,10 @@
package org.skywalking.apm.collector.agent.stream.parser.standardization;
import org.skywalking.apm.collector.agent.stream.worker.register.ServiceNameService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.ApplicationCacheService;
import org.skywalking.apm.collector.cache.service.InstanceCacheService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.Const;
import org.skywalking.apm.collector.core.util.StringUtils;
import org.slf4j.Logger;
@ -34,23 +37,26 @@ public class ReferenceIdExchanger implements IdExchanger<ReferenceDecorator> {
private static ReferenceIdExchanger EXCHANGER;
private ServiceNameService serviceNameService;
private final CacheServiceManager cacheServiceManager;
private final InstanceCacheService instanceCacheService;
private final ApplicationCacheService applicationCacheService;
public static ReferenceIdExchanger getInstance(CacheServiceManager cacheServiceManager) {
public static ReferenceIdExchanger getInstance(ModuleManager moduleManager) {
if (EXCHANGER == null) {
EXCHANGER = new ReferenceIdExchanger(cacheServiceManager);
EXCHANGER = new ReferenceIdExchanger(moduleManager);
}
return EXCHANGER;
}
public ReferenceIdExchanger(CacheServiceManager cacheServiceManager) {
this.cacheServiceManager = cacheServiceManager;
serviceNameService = new ServiceNameService(cacheServiceManager);
private ReferenceIdExchanger(ModuleManager moduleManager) {
serviceNameService = new ServiceNameService(moduleManager);
instanceCacheService = moduleManager.find(CacheModule.NAME).getService(InstanceCacheService.class);
applicationCacheService = moduleManager.find(CacheModule.NAME).getService(ApplicationCacheService.class);
}
@Override public boolean exchange(ReferenceDecorator standardBuilder, int applicationId) {
if (standardBuilder.getEntryServiceId() == 0 && StringUtils.isNotEmpty(standardBuilder.getEntryServiceName())) {
int entryServiceId = serviceNameService.getOrCreate(cacheServiceManager.getInstanceCacheService().get(standardBuilder.getEntryApplicationInstanceId()), standardBuilder.getEntryServiceName());
int entryServiceId = serviceNameService.getOrCreate(instanceCacheService.get(standardBuilder.getEntryApplicationInstanceId()), standardBuilder.getEntryServiceName());
if (entryServiceId == 0) {
return false;
} else {
@ -61,7 +67,8 @@ public class ReferenceIdExchanger implements IdExchanger<ReferenceDecorator> {
}
if (standardBuilder.getParentServiceId() == 0 && StringUtils.isNotEmpty(standardBuilder.getParentServiceName())) {
int parentServiceId = serviceNameService.getOrCreate(cacheServiceManager.getInstanceCacheService().get(standardBuilder.getParentApplicationInstanceId()), standardBuilder.getParentServiceName());
int parentServiceId = serviceNameService.getOrCreate(instanceCacheService.get(standardBuilder.getParentApplicationInstanceId()), standardBuilder.getParentServiceName());
if (parentServiceId == 0) {
return false;
} else {
@ -72,7 +79,7 @@ public class ReferenceIdExchanger implements IdExchanger<ReferenceDecorator> {
}
if (standardBuilder.getNetworkAddressId() == 0 && StringUtils.isNotEmpty(standardBuilder.getNetworkAddress())) {
int networkAddressId = cacheServiceManager.getApplicationCacheService().get(standardBuilder.getNetworkAddress());
int networkAddressId = applicationCacheService.get(standardBuilder.getNetworkAddress());
if (networkAddressId == 0) {
return false;
} else {

18
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/parser/standardization/SegmentStandardizationWorker.java
View File

@ -19,9 +19,8 @@
package org.skywalking.apm.collector.agent.stream.parser.standardization;
import org.skywalking.apm.collector.agent.stream.buffer.SegmentBufferManager;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.stream.worker.base.AbstractLocalAsyncWorker;
import org.skywalking.apm.collector.stream.worker.base.AbstractLocalAsyncWorkerProvider;
import org.skywalking.apm.collector.stream.worker.base.WorkerException;
@ -36,8 +35,8 @@ public class SegmentStandardizationWorker extends AbstractLocalAsyncWorker<Upstr
private final Logger logger = LoggerFactory.getLogger(SegmentStandardizationWorker.class);
public SegmentStandardizationWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public SegmentStandardizationWorker(ModuleManager moduleManager) {
super(moduleManager);
SegmentBufferManager.INSTANCE.initialize();
}
@ -54,15 +53,12 @@ public class SegmentStandardizationWorker extends AbstractLocalAsyncWorker<Upstr
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<UpstreamSegment, UpstreamSegment, SegmentStandardizationWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<UpstreamSegment> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<UpstreamSegment> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override
public SegmentStandardizationWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new SegmentStandardizationWorker(getDaoService(), getCacheServiceManager());
@Override public SegmentStandardizationWorker workerInstance(ModuleManager moduleManager) {
return new SegmentStandardizationWorker(moduleManager);
}
@Override public int queueSize() {

23
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/parser/standardization/SpanIdExchanger.java
View File

@ -19,34 +19,40 @@
package org.skywalking.apm.collector.agent.stream.parser.standardization;
import org.skywalking.apm.collector.agent.stream.worker.register.ServiceNameService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.ApplicationCacheService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.Const;
import org.skywalking.apm.collector.core.util.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author peng-yongsheng
*/
public class SpanIdExchanger implements IdExchanger<SpanDecorator> {
private final Logger logger = LoggerFactory.getLogger(SpanIdExchanger.class);
private static SpanIdExchanger EXCHANGER;
private final ServiceNameService serviceNameService;
private final CacheServiceManager cacheServiceManager;
private final ApplicationCacheService applicationCacheService;
public static SpanIdExchanger getInstance(CacheServiceManager cacheServiceManager) {
public static SpanIdExchanger getInstance(ModuleManager moduleManager) {
if (EXCHANGER == null) {
EXCHANGER = new SpanIdExchanger(cacheServiceManager);
EXCHANGER = new SpanIdExchanger(moduleManager);
}
return EXCHANGER;
}
public SpanIdExchanger(CacheServiceManager cacheServiceManager) {
this.cacheServiceManager = cacheServiceManager;
this.serviceNameService = new ServiceNameService(cacheServiceManager);
public SpanIdExchanger(ModuleManager moduleManager) {
this.applicationCacheService = moduleManager.find(CacheModule.NAME).getService(ApplicationCacheService.class);
this.serviceNameService = new ServiceNameService(moduleManager);
}
@Override public boolean exchange(SpanDecorator standardBuilder, int applicationId) {
if (standardBuilder.getPeerId() == 0 && StringUtils.isNotEmpty(standardBuilder.getPeer())) {
int peerId = cacheServiceManager.getApplicationCacheService().get(standardBuilder.getPeer());
int peerId = applicationCacheService.get(standardBuilder.getPeer());
if (peerId == 0) {
return false;
} else {
@ -58,6 +64,7 @@ public class SpanIdExchanger implements IdExchanger<SpanDecorator> {
if (standardBuilder.getOperationNameId() == 0 && StringUtils.isNotEmpty(standardBuilder.getOperationName())) {
int operationNameId = serviceNameService.getOrCreate(applicationId, standardBuilder.getOperationName());
if (operationNameId == 0) {
return false;
} else {

20
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/jvm/CpuMetricPersistenceWorker.java
View File

@ -18,8 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.jvm;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.dao.ICpuMetricPersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -32,8 +33,8 @@ import org.skywalking.apm.collector.stream.worker.impl.PersistenceWorker;
*/
public class CpuMetricPersistenceWorker extends PersistenceWorker<CpuMetric, CpuMetric> {
public CpuMetricPersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public CpuMetricPersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override public int id() {
@ -45,20 +46,17 @@ public class CpuMetricPersistenceWorker extends PersistenceWorker<CpuMetric, Cpu
}
@Override protected IPersistenceDAO persistenceDAO() {
return getDaoService().getPersistenceDAO(ICpuMetricPersistenceDAO.class);
return getModuleManager().find(StorageModule.NAME).getService(DAOService.class).getPersistenceDAO(ICpuMetricPersistenceDAO.class);
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<CpuMetric, CpuMetric, CpuMetricPersistenceWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<CpuMetric> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<CpuMetric> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override
public CpuMetricPersistenceWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new CpuMetricPersistenceWorker(getDaoService(), getCacheServiceManager());
@Override public CpuMetricPersistenceWorker workerInstance(ModuleManager moduleManager) {
return new CpuMetricPersistenceWorker(moduleManager);
}
@Override

27
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/jvm/GCMetricPersistenceWorker.java
View File

@ -18,8 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.jvm;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.dao.IGCMetricPersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -32,12 +33,15 @@ import org.skywalking.apm.collector.stream.worker.impl.PersistenceWorker;
*/
public class GCMetricPersistenceWorker extends PersistenceWorker<GCMetric, GCMetric> {
@Override public int id() {
return 0;
private final DAOService daoService;
public GCMetricPersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
}
public GCMetricPersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
@Override public int id() {
return 0;
}
@Override protected boolean needMergeDBData() {
@ -45,20 +49,17 @@ public class GCMetricPersistenceWorker extends PersistenceWorker<GCMetric, GCMet
}
@Override protected IPersistenceDAO persistenceDAO() {
return getDaoService().getPersistenceDAO(IGCMetricPersistenceDAO.class);
return daoService.getPersistenceDAO(IGCMetricPersistenceDAO.class);
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<GCMetric, GCMetric, GCMetricPersistenceWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<GCMetric> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<GCMetric> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override
public GCMetricPersistenceWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new GCMetricPersistenceWorker(getDaoService(), getCacheServiceManager());
@Override public GCMetricPersistenceWorker workerInstance(ModuleManager moduleManager) {
return new GCMetricPersistenceWorker(moduleManager);
}
@Override

26
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/jvm/InstHeartBeatPersistenceWorker.java
View File

@ -18,8 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.jvm;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.dao.IInstanceHeartBeatPersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -32,12 +33,15 @@ import org.skywalking.apm.collector.stream.worker.impl.PersistenceWorker;
*/
public class InstHeartBeatPersistenceWorker extends PersistenceWorker<Instance, Instance> {
@Override public int id() {
return 0;
private final DAOService daoService;
public InstHeartBeatPersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
}
public InstHeartBeatPersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
@Override public int id() {
return InstHeartBeatPersistenceWorker.class.hashCode();
}
@Override protected boolean needMergeDBData() {
@ -45,19 +49,17 @@ public class InstHeartBeatPersistenceWorker extends PersistenceWorker<Instance,
}
@Override protected IPersistenceDAO persistenceDAO() {
return getDaoService().getPersistenceDAO(IInstanceHeartBeatPersistenceDAO.class);
return daoService.getPersistenceDAO(IInstanceHeartBeatPersistenceDAO.class);
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<Instance, Instance, InstHeartBeatPersistenceWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<Instance> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<Instance> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override public InstHeartBeatPersistenceWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new InstHeartBeatPersistenceWorker(getDaoService(), getCacheServiceManager());
@Override public InstHeartBeatPersistenceWorker workerInstance(ModuleManager moduleManager) {
return new InstHeartBeatPersistenceWorker(moduleManager);
}
@Override

22
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/jvm/MemoryMetricPersistenceWorker.java
View File

@ -18,8 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.jvm;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.dao.IMemoryMetricPersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -32,8 +33,11 @@ import org.skywalking.apm.collector.stream.worker.impl.PersistenceWorker;
*/
public class MemoryMetricPersistenceWorker extends PersistenceWorker<MemoryMetric, MemoryMetric> {
public MemoryMetricPersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
private final DAOService daoService;
public MemoryMetricPersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
}
@Override public int id() {
@ -45,19 +49,17 @@ public class MemoryMetricPersistenceWorker extends PersistenceWorker<MemoryMetri
}
@Override protected IPersistenceDAO persistenceDAO() {
return getDaoService().getPersistenceDAO(IMemoryMetricPersistenceDAO.class);
return daoService.getPersistenceDAO(IMemoryMetricPersistenceDAO.class);
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<MemoryMetric, MemoryMetric, MemoryMetricPersistenceWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<MemoryMetric> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<MemoryMetric> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override public MemoryMetricPersistenceWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new MemoryMetricPersistenceWorker(getDaoService(), getCacheServiceManager());
@Override public MemoryMetricPersistenceWorker workerInstance(ModuleManager moduleManager) {
return new MemoryMetricPersistenceWorker(moduleManager);
}
@Override

22
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/jvm/MemoryPoolMetricPersistenceWorker.java
View File

@ -18,8 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.jvm;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.dao.IMemoryPoolMetricPersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -36,8 +37,11 @@ public class MemoryPoolMetricPersistenceWorker extends PersistenceWorker<MemoryP
return 0;
}
public MemoryPoolMetricPersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
private final DAOService daoService;
public MemoryPoolMetricPersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
}
@Override protected boolean needMergeDBData() {
@ -45,19 +49,17 @@ public class MemoryPoolMetricPersistenceWorker extends PersistenceWorker<MemoryP
}
@Override protected IPersistenceDAO persistenceDAO() {
return getDaoService().getPersistenceDAO(IMemoryPoolMetricPersistenceDAO.class);
return daoService.getPersistenceDAO(IMemoryPoolMetricPersistenceDAO.class);
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<MemoryPoolMetric, MemoryPoolMetric, MemoryPoolMetricPersistenceWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<MemoryPoolMetric> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<MemoryPoolMetric> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override public MemoryPoolMetricPersistenceWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new MemoryPoolMetricPersistenceWorker(getDaoService(), getCacheServiceManager());
@Override public MemoryPoolMetricPersistenceWorker workerInstance(ModuleManager moduleManager) {
return new MemoryPoolMetricPersistenceWorker(moduleManager);
}
@Override

25
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/register/ApplicationIDService.java
View File

@ -18,8 +18,13 @@
package org.skywalking.apm.collector.agent.stream.worker.register;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.graph.Graph;
import org.skywalking.apm.collector.agent.stream.graph.RegisterStreamGraph;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.ApplicationCacheService;
import org.skywalking.apm.collector.core.graph.GraphManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.module.ModuleNotFoundException;
import org.skywalking.apm.collector.core.module.ServiceNotProvidedException;
import org.skywalking.apm.collector.storage.table.register.Application;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -31,23 +36,23 @@ public class ApplicationIDService {
private final Logger logger = LoggerFactory.getLogger(ApplicationIDService.class);
private final CacheServiceManager cacheServiceManager;
private final Graph<Application> applicationRegisterGraph;
private final ModuleManager moduleManager;
public ApplicationIDService(CacheServiceManager cacheServiceManager, Graph<Application> applicationRegisterGraph) {
this.cacheServiceManager = cacheServiceManager;
this.applicationRegisterGraph = applicationRegisterGraph;
public ApplicationIDService(ModuleManager moduleManager) {
this.moduleManager = moduleManager;
}
public int getOrCreate(String applicationCode) {
int applicationId = cacheServiceManager.getApplicationCacheService().get(applicationCode);
@SuppressWarnings("unchecked")
public int getOrCreate(String applicationCode) throws ModuleNotFoundException, ServiceNotProvidedException {
ApplicationCacheService service = moduleManager.find(CacheModule.NAME).getService(ApplicationCacheService.class);
int applicationId = service.get(applicationCode);
if (applicationId == 0) {
Application application = new Application(applicationCode);
application.setApplicationCode(applicationCode);
application.setApplicationId(0);
applicationRegisterGraph.start(application);
GraphManager.INSTANCE.findGraph(RegisterStreamGraph.APPLICATION_REGISTER_GRAPH_ID).start(application);
}
return applicationId;
}

17
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/register/ApplicationRegisterRemoteWorker.java
View File

@ -18,10 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.register;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.remote.service.RemoteSenderService;
import org.skywalking.apm.collector.remote.service.Selector;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.register.Application;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorker;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorkerProvider;
@ -36,8 +35,8 @@ public class ApplicationRegisterRemoteWorker extends AbstractRemoteWorker<Applic
private final Logger logger = LoggerFactory.getLogger(ApplicationRegisterRemoteWorker.class);
public ApplicationRegisterRemoteWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public ApplicationRegisterRemoteWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override public int id() {
@ -55,14 +54,12 @@ public class ApplicationRegisterRemoteWorker extends AbstractRemoteWorker<Applic
public static class Factory extends AbstractRemoteWorkerProvider<Application, Application, ApplicationRegisterRemoteWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
RemoteSenderService remoteSenderService, int graphId) {
super(daoService, cacheServiceManager, remoteSenderService, graphId);
public Factory(ModuleManager moduleManager, RemoteSenderService remoteSenderService, int graphId) {
super(moduleManager, remoteSenderService, graphId);
}
@Override public ApplicationRegisterRemoteWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new ApplicationRegisterRemoteWorker(getDaoService(), getCacheServiceManager());
@Override public ApplicationRegisterRemoteWorker workerInstance(ModuleManager moduleManager) {
return new ApplicationRegisterRemoteWorker(moduleManager);
}
}
}

28
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/register/ApplicationRegisterSerialWorker.java
View File

@ -19,9 +19,12 @@
package org.skywalking.apm.collector.agent.stream.worker.register;
import org.skywalking.apm.collector.agent.stream.IdAutoIncrement;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.ApplicationCacheService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.Const;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.dao.IApplicationStreamDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.register.Application;
@ -38,8 +41,13 @@ public class ApplicationRegisterSerialWorker extends AbstractLocalAsyncWorker<Ap
private final Logger logger = LoggerFactory.getLogger(ApplicationRegisterSerialWorker.class);
public ApplicationRegisterSerialWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
private final DAOService daoService;
private final ApplicationCacheService applicationCacheService;
public ApplicationRegisterSerialWorker(ModuleManager moduleManager) {
super(moduleManager);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
this.applicationCacheService = getModuleManager().find(CacheModule.NAME).getService(ApplicationCacheService.class);
}
@Override public int id() {
@ -48,10 +56,10 @@ public class ApplicationRegisterSerialWorker extends AbstractLocalAsyncWorker<Ap
@Override protected void onWork(Application application) throws WorkerException {
logger.debug("register application, application code: {}", application.getApplicationCode());
int applicationId = getCacheServiceManager().getApplicationCacheService().get(application.getApplicationCode());
int applicationId = applicationCacheService.get(application.getApplicationCode());
if (applicationId == 0) {
IApplicationStreamDAO dao = (IApplicationStreamDAO)getDaoService().get(IApplicationStreamDAO.class);
IApplicationStreamDAO dao = (IApplicationStreamDAO)daoService.get(IApplicationStreamDAO.class);
Application newApplication;
int min = dao.getMinApplicationId();
if (min == 0) {
@ -77,14 +85,12 @@ public class ApplicationRegisterSerialWorker extends AbstractLocalAsyncWorker<Ap
public static class Factory extends AbstractLocalAsyncWorkerProvider<Application, Application, ApplicationRegisterSerialWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<Application> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<Application> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override public ApplicationRegisterSerialWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new ApplicationRegisterSerialWorker(daoService, cacheServiceManager);
@Override public ApplicationRegisterSerialWorker workerInstance(ModuleManager moduleManager) {
return new ApplicationRegisterSerialWorker(moduleManager);
}
@Override public int queueSize() {

30
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/register/InstanceIDService.java
View File

@ -18,7 +18,14 @@
package org.skywalking.apm.collector.agent.stream.worker.register;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.agent.stream.graph.RegisterStreamGraph;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.InstanceCacheService;
import org.skywalking.apm.collector.core.graph.GraphManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.module.ModuleNotFoundException;
import org.skywalking.apm.collector.core.module.ServiceNotProvidedException;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.dao.IInstanceStreamDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.register.Instance;
@ -32,17 +39,18 @@ public class InstanceIDService {
private final Logger logger = LoggerFactory.getLogger(InstanceIDService.class);
private final DAOService daoService;
private final CacheServiceManager cacheServiceManager;
private final ModuleManager moduleManager;
public InstanceIDService(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.daoService = daoService;
this.cacheServiceManager = cacheServiceManager;
public InstanceIDService(ModuleManager moduleManager) {
this.moduleManager = moduleManager;
}
public int getOrCreate(int applicationId, String agentUUID, long registerTime, String osInfo) {
@SuppressWarnings("unchecked")
public int getOrCreate(int applicationId, String agentUUID, long registerTime,
String osInfo) throws ModuleNotFoundException, ServiceNotProvidedException {
logger.debug("get or create instance id, application id: {}, agentUUID: {}, registerTime: {}, osInfo: {}", applicationId, agentUUID, registerTime, osInfo);
int instanceId = cacheServiceManager.getInstanceCacheService().getInstanceId(applicationId, agentUUID);
InstanceCacheService service = moduleManager.find(CacheModule.NAME).getService(InstanceCacheService.class);
int instanceId = service.getInstanceId(applicationId, agentUUID);
if (instanceId == 0) {
Instance instance = new Instance("0");
@ -52,12 +60,16 @@ public class InstanceIDService {
instance.setHeartBeatTime(registerTime);
instance.setInstanceId(0);
instance.setOsInfo(osInfo);
GraphManager.INSTANCE.findGraph(RegisterStreamGraph.INSTANCE_REGISTER_GRAPH_ID).start(instance);
}
return instanceId;
}
public void recover(int instanceId, int applicationId, long registerTime, String osInfo) {
public void recover(int instanceId, int applicationId, long registerTime,
String osInfo) throws ModuleNotFoundException, ServiceNotProvidedException {
logger.debug("instance recover, instance id: {}, application id: {}, register time: {}", instanceId, applicationId, registerTime);
DAOService daoService = moduleManager.find(StorageModule.NAME).getService(DAOService.class);
IInstanceStreamDAO dao = (IInstanceStreamDAO)daoService.get(IInstanceStreamDAO.class);
Instance instance = new Instance(String.valueOf(instanceId));

18
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/register/InstanceRegisterRemoteWorker.java
View File

@ -18,10 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.register;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.remote.service.RemoteSenderService;
import org.skywalking.apm.collector.remote.service.Selector;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.register.Instance;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorker;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorkerProvider;
@ -40,8 +39,8 @@ public class InstanceRegisterRemoteWorker extends AbstractRemoteWorker<Instance,
return InstanceRegisterRemoteWorker.class.hashCode();
}
public InstanceRegisterRemoteWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public InstanceRegisterRemoteWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override protected void onWork(Instance instance) throws WorkerException {
@ -55,15 +54,12 @@ public class InstanceRegisterRemoteWorker extends AbstractRemoteWorker<Instance,
public static class Factory extends AbstractRemoteWorkerProvider<Instance, Instance, InstanceRegisterRemoteWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
RemoteSenderService remoteSenderService, int graphId) {
super(daoService, cacheServiceManager, remoteSenderService, graphId);
public Factory(ModuleManager moduleManager, RemoteSenderService remoteSenderService, int graphId) {
super(moduleManager, remoteSenderService, graphId);
}
@Override
public InstanceRegisterRemoteWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new InstanceRegisterRemoteWorker(getDaoService(), getCacheServiceManager());
@Override public InstanceRegisterRemoteWorker workerInstance(ModuleManager moduleManager) {
return new InstanceRegisterRemoteWorker(moduleManager);
}
}
}

29
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/register/InstanceRegisterSerialWorker.java
View File

@ -18,8 +18,11 @@
package org.skywalking.apm.collector.agent.stream.worker.register;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.InstanceCacheService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.dao.IInstanceStreamDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.register.Instance;
@ -36,8 +39,13 @@ public class InstanceRegisterSerialWorker extends AbstractLocalAsyncWorker<Insta
private final Logger logger = LoggerFactory.getLogger(InstanceRegisterSerialWorker.class);
public InstanceRegisterSerialWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
private final InstanceCacheService instanceCacheService;
private final DAOService daoService;
public InstanceRegisterSerialWorker(ModuleManager moduleManager) {
super(moduleManager);
this.instanceCacheService = getModuleManager().find(CacheModule.NAME).getService(InstanceCacheService.class);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
}
@Override public int id() {
@ -46,9 +54,9 @@ public class InstanceRegisterSerialWorker extends AbstractLocalAsyncWorker<Insta
@Override protected void onWork(Instance instance) throws WorkerException {
logger.debug("register instance, application id: {}, agentUUID: {}", instance.getApplicationId(), instance.getAgentUUID());
int instanceId = getCacheServiceManager().getInstanceCacheService().getInstanceId(instance.getApplicationId(), instance.getAgentUUID());
int instanceId = instanceCacheService.getInstanceId(instance.getApplicationId(), instance.getAgentUUID());
if (instanceId == 0) {
IInstanceStreamDAO dao = (IInstanceStreamDAO)getDaoService().get(IInstanceStreamDAO.class);
IInstanceStreamDAO dao = (IInstanceStreamDAO)daoService.get(IInstanceStreamDAO.class);
Instance newInstance;
int min = dao.getMinInstanceId();
@ -76,15 +84,12 @@ public class InstanceRegisterSerialWorker extends AbstractLocalAsyncWorker<Insta
public static class Factory extends AbstractLocalAsyncWorkerProvider<Instance, Instance, InstanceRegisterSerialWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<Instance> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<Instance> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override
public InstanceRegisterSerialWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new InstanceRegisterSerialWorker(getDaoService(), getCacheServiceManager());
@Override public InstanceRegisterSerialWorker workerInstance(ModuleManager moduleManager) {
return new InstanceRegisterSerialWorker(moduleManager);
}
@Override public int queueSize() {

17
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/register/ServiceNameRegisterRemoteWorker.java
View File

@ -18,10 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.register;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.remote.service.RemoteSenderService;
import org.skywalking.apm.collector.remote.service.Selector;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.register.ServiceName;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorker;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorkerProvider;
@ -36,8 +35,8 @@ public class ServiceNameRegisterRemoteWorker extends AbstractRemoteWorker<Servic
private final Logger logger = LoggerFactory.getLogger(ServiceNameRegisterRemoteWorker.class);
public ServiceNameRegisterRemoteWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public ServiceNameRegisterRemoteWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override public int id() {
@ -54,14 +53,12 @@ public class ServiceNameRegisterRemoteWorker extends AbstractRemoteWorker<Servic
public static class Factory extends AbstractRemoteWorkerProvider<ServiceName, ServiceName, ServiceNameRegisterRemoteWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
RemoteSenderService remoteSenderService, int graphId) {
super(daoService, cacheServiceManager, remoteSenderService, graphId);
public Factory(ModuleManager moduleManager, RemoteSenderService remoteSenderService, int graphId) {
super(moduleManager, remoteSenderService, graphId);
}
@Override public ServiceNameRegisterRemoteWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new ServiceNameRegisterRemoteWorker(getDaoService(), getCacheServiceManager());
@Override public ServiceNameRegisterRemoteWorker workerInstance(ModuleManager moduleManager) {
return new ServiceNameRegisterRemoteWorker(moduleManager);
}
}
}

29
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/register/ServiceNameRegisterSerialWorker.java
View File

@ -19,9 +19,12 @@
package org.skywalking.apm.collector.agent.stream.worker.register;
import org.skywalking.apm.collector.agent.stream.IdAutoIncrement;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.ServiceIdCacheService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.Const;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.dao.IServiceNameStreamDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.register.ServiceName;
@ -38,8 +41,13 @@ public class ServiceNameRegisterSerialWorker extends AbstractLocalAsyncWorker<Se
private final Logger logger = LoggerFactory.getLogger(ServiceNameRegisterSerialWorker.class);
public ServiceNameRegisterSerialWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
private final DAOService daoService;
private final ServiceIdCacheService serviceIdCacheService;
public ServiceNameRegisterSerialWorker(ModuleManager moduleManager) {
super(moduleManager);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
this.serviceIdCacheService = getModuleManager().find(CacheModule.NAME).getService(ServiceIdCacheService.class);
}
@Override public int id() {
@ -48,9 +56,9 @@ public class ServiceNameRegisterSerialWorker extends AbstractLocalAsyncWorker<Se
@Override protected void onWork(ServiceName serviceName) throws WorkerException {
logger.debug("register service name: {}, application id: {}", serviceName.getServiceName(), serviceName.getApplicationId());
int serviceId = getCacheServiceManager().getServiceIdCacheService().get(serviceName.getApplicationId(), serviceName.getServiceName());
int serviceId = serviceIdCacheService.get(serviceName.getApplicationId(), serviceName.getServiceName());
if (serviceId == 0) {
IServiceNameStreamDAO dao = (IServiceNameStreamDAO)getDaoService().get(IServiceNameStreamDAO.class);
IServiceNameStreamDAO dao = (IServiceNameStreamDAO)daoService.get(IServiceNameStreamDAO.class);
ServiceName newServiceName;
int min = dao.getMinServiceId();
@ -79,14 +87,13 @@ public class ServiceNameRegisterSerialWorker extends AbstractLocalAsyncWorker<Se
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<ServiceName, ServiceName, ServiceNameRegisterSerialWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<ServiceName> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<ServiceName> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override public ServiceNameRegisterSerialWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new ServiceNameRegisterSerialWorker(getDaoService(), getCacheServiceManager());
@Override public ServiceNameRegisterSerialWorker workerInstance(ModuleManager moduleManager) {
return new ServiceNameRegisterSerialWorker(moduleManager);
}
@Override public int queueSize() {

18
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/register/ServiceNameService.java
View File

@ -18,7 +18,11 @@
package org.skywalking.apm.collector.agent.stream.worker.register;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.agent.stream.graph.RegisterStreamGraph;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.ServiceIdCacheService;
import org.skywalking.apm.collector.core.graph.GraphManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.storage.table.register.ServiceName;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -30,20 +34,24 @@ public class ServiceNameService {
private final Logger logger = LoggerFactory.getLogger(ServiceNameService.class);
private final CacheServiceManager cacheServiceManager;
private final ModuleManager moduleManager;
public ServiceNameService(CacheServiceManager cacheServiceManager) {
this.cacheServiceManager = cacheServiceManager;
public ServiceNameService(ModuleManager moduleManager) {
this.moduleManager = moduleManager;
}
@SuppressWarnings("unchecked")
public int getOrCreate(int applicationId, String serviceName) {
int serviceId = cacheServiceManager.getServiceIdCacheService().get(applicationId, serviceName);
ServiceIdCacheService idCacheService = moduleManager.find(CacheModule.NAME).getService(ServiceIdCacheService.class);
int serviceId = idCacheService.get(applicationId, serviceName);
if (serviceId == 0) {
ServiceName service = new ServiceName("0");
service.setApplicationId(applicationId);
service.setServiceName(serviceName);
service.setServiceId(0);
GraphManager.INSTANCE.findGraph(RegisterStreamGraph.SERVICE_NAME_REGISTER_GRAPH_ID).start(service);
}
return serviceId;
}

23
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/global/GlobalTracePersistenceWorker.java
View File

@ -18,8 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.global;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.dao.IGlobalTracePersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -32,8 +33,11 @@ import org.skywalking.apm.collector.stream.worker.impl.PersistenceWorker;
*/
public class GlobalTracePersistenceWorker extends PersistenceWorker<GlobalTrace, GlobalTrace> {
public GlobalTracePersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
private final DAOService daoService;
public GlobalTracePersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
}
@Override public int id() {
@ -45,20 +49,17 @@ public class GlobalTracePersistenceWorker extends PersistenceWorker<GlobalTrace,
}
@Override protected IPersistenceDAO persistenceDAO() {
return (IGlobalTracePersistenceDAO)getDaoService().get(IGlobalTracePersistenceDAO.class);
return (IGlobalTracePersistenceDAO)daoService.get(IGlobalTracePersistenceDAO.class);
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<GlobalTrace, GlobalTrace, GlobalTracePersistenceWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<GlobalTrace> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<GlobalTrace> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override
public GlobalTracePersistenceWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new GlobalTracePersistenceWorker(getDaoService(), getCacheServiceManager());
@Override public GlobalTracePersistenceWorker workerInstance(ModuleManager moduleManager) {
return new GlobalTracePersistenceWorker(moduleManager);
}
@Override

25
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/instance/InstPerformancePersistenceWorker.java
View File

@ -18,8 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.instance;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.dao.IInstPerformancePersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -32,12 +33,15 @@ import org.skywalking.apm.collector.stream.worker.impl.PersistenceWorker;
*/
public class InstPerformancePersistenceWorker extends PersistenceWorker<InstPerformance, InstPerformance> {
public InstPerformancePersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
private final DAOService daoService;
public InstPerformancePersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
}
@Override public int id() {
return 0;
return InstPerformancePersistenceWorker.class.hashCode();
}
@Override protected boolean needMergeDBData() {
@ -45,18 +49,17 @@ public class InstPerformancePersistenceWorker extends PersistenceWorker<InstPerf
}
@Override protected IPersistenceDAO persistenceDAO() {
return (IPersistenceDAO)getDaoService().get(IInstPerformancePersistenceDAO.class);
return (IPersistenceDAO)daoService.get(IInstPerformancePersistenceDAO.class);
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<InstPerformance, InstPerformance, InstPerformancePersistenceWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<InstPerformance> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<InstPerformance> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override public InstPerformancePersistenceWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new InstPerformancePersistenceWorker(getDaoService(), getCacheServiceManager());
@Override public InstPerformancePersistenceWorker workerInstance(ModuleManager moduleManager) {
return new InstPerformancePersistenceWorker(moduleManager);
}
@Override

20
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/node/NodeComponentAggregationWorker.java
View File

@ -18,9 +18,8 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.node;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.node.NodeComponent;
import org.skywalking.apm.collector.stream.worker.base.AbstractLocalAsyncWorkerProvider;
import org.skywalking.apm.collector.stream.worker.impl.AggregationWorker;
@ -30,23 +29,22 @@ import org.skywalking.apm.collector.stream.worker.impl.AggregationWorker;
*/
public class NodeComponentAggregationWorker extends AggregationWorker<NodeComponent, NodeComponent> {
public NodeComponentAggregationWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public NodeComponentAggregationWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override public int id() {
return 0;
return NodeComponentAggregationWorker.class.hashCode();
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<NodeComponent, NodeComponent, NodeComponentAggregationWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<NodeComponent> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<NodeComponent> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override public NodeComponentAggregationWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new NodeComponentAggregationWorker(getDaoService(), getCacheServiceManager());
@Override public NodeComponentAggregationWorker workerInstance(ModuleManager moduleManager) {
return new NodeComponentAggregationWorker(moduleManager);
}
@Override

24
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/node/NodeComponentPersistenceWorker.java
View File

@ -18,8 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.node;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.dao.INodeComponentPersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -32,12 +33,15 @@ import org.skywalking.apm.collector.stream.worker.impl.PersistenceWorker;
*/
public class NodeComponentPersistenceWorker extends PersistenceWorker<NodeComponent, NodeComponent> {
public NodeComponentPersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
private final DAOService daoService;
public NodeComponentPersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
}
@Override public int id() {
return 0;
return NodeComponentPersistenceWorker.class.hashCode();
}
@Override protected boolean needMergeDBData() {
@ -45,19 +49,17 @@ public class NodeComponentPersistenceWorker extends PersistenceWorker<NodeCompon
}
@Override protected IPersistenceDAO persistenceDAO() {
return (IPersistenceDAO)getDaoService().get(INodeComponentPersistenceDAO.class);
return (IPersistenceDAO)daoService.get(INodeComponentPersistenceDAO.class);
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<NodeComponent, NodeComponent, NodeComponentPersistenceWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<NodeComponent> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<NodeComponent> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override public NodeComponentPersistenceWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new NodeComponentPersistenceWorker(getDaoService(), getCacheServiceManager());
@Override public NodeComponentPersistenceWorker workerInstance(ModuleManager moduleManager) {
return new NodeComponentPersistenceWorker(moduleManager);
}
@Override

19
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/node/NodeComponentRemoteWorker.java
View File

@ -18,10 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.node;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.remote.service.RemoteSenderService;
import org.skywalking.apm.collector.remote.service.Selector;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.node.NodeComponent;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorker;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorkerProvider;
@ -32,8 +31,8 @@ import org.skywalking.apm.collector.stream.worker.base.WorkerException;
*/
public class NodeComponentRemoteWorker extends AbstractRemoteWorker<NodeComponent, NodeComponent> {
public NodeComponentRemoteWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public NodeComponentRemoteWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override public int id() {
@ -49,15 +48,13 @@ public class NodeComponentRemoteWorker extends AbstractRemoteWorker<NodeComponen
}
public static class Factory extends AbstractRemoteWorkerProvider<NodeComponent, NodeComponent, NodeComponentRemoteWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
RemoteSenderService remoteSenderService, int graphId) {
super(daoService, cacheServiceManager, remoteSenderService, graphId);
public Factory(ModuleManager moduleManager, RemoteSenderService remoteSenderService, int graphId) {
super(moduleManager, remoteSenderService, graphId);
}
@Override
public NodeComponentRemoteWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new NodeComponentRemoteWorker(getDaoService(), getCacheServiceManager());
@Override public NodeComponentRemoteWorker workerInstance(ModuleManager moduleManager) {
return new NodeComponentRemoteWorker(moduleManager);
}
}
}

20
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/node/NodeMappingAggregationWorker.java
View File

@ -18,9 +18,8 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.node;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.node.NodeMapping;
import org.skywalking.apm.collector.stream.worker.base.AbstractLocalAsyncWorkerProvider;
import org.skywalking.apm.collector.stream.worker.impl.AggregationWorker;
@ -30,25 +29,22 @@ import org.skywalking.apm.collector.stream.worker.impl.AggregationWorker;
*/
public class NodeMappingAggregationWorker extends AggregationWorker<NodeMapping, NodeMapping> {
public NodeMappingAggregationWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public NodeMappingAggregationWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override public int id() {
return 0;
return NodeMappingAggregationWorker.class.hashCode();
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<NodeMapping, NodeMapping, NodeMappingAggregationWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<NodeMapping> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<NodeMapping> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override
public NodeMappingAggregationWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new NodeMappingAggregationWorker(getDaoService(), getCacheServiceManager());
@Override public NodeMappingAggregationWorker workerInstance(ModuleManager moduleManager) {
return new NodeMappingAggregationWorker(moduleManager);
}
@Override

26
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/node/NodeMappingPersistenceWorker.java
View File

@ -18,8 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.node;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.dao.INodeMappingPersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -32,12 +33,15 @@ import org.skywalking.apm.collector.stream.worker.impl.PersistenceWorker;
*/
public class NodeMappingPersistenceWorker extends PersistenceWorker<NodeMapping, NodeMapping> {
public NodeMappingPersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
private final DAOService daoService;
public NodeMappingPersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
}
@Override public int id() {
return 0;
return NodeMappingPersistenceWorker.class.hashCode();
}
@Override protected boolean needMergeDBData() {
@ -45,19 +49,17 @@ public class NodeMappingPersistenceWorker extends PersistenceWorker<NodeMapping,
}
@Override protected IPersistenceDAO persistenceDAO() {
return (IPersistenceDAO)getDaoService().get(INodeMappingPersistenceDAO.class);
return (IPersistenceDAO)daoService.get(INodeMappingPersistenceDAO.class);
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<NodeMapping, NodeMapping, NodeMappingPersistenceWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<NodeMapping> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<NodeMapping> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override
public NodeMappingPersistenceWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new NodeMappingPersistenceWorker(getDaoService(), getCacheServiceManager());
@Override public NodeMappingPersistenceWorker workerInstance(ModuleManager moduleManager) {
return new NodeMappingPersistenceWorker(moduleManager);
}
@Override

17
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/node/NodeMappingRemoteWorker.java
View File

@ -18,10 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.node;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.remote.service.RemoteSenderService;
import org.skywalking.apm.collector.remote.service.Selector;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.node.NodeMapping;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorker;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorkerProvider;
@ -32,8 +31,8 @@ import org.skywalking.apm.collector.stream.worker.base.WorkerException;
*/
public class NodeMappingRemoteWorker extends AbstractRemoteWorker<NodeMapping, NodeMapping> {
public NodeMappingRemoteWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public NodeMappingRemoteWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override public int id() {
@ -49,14 +48,12 @@ public class NodeMappingRemoteWorker extends AbstractRemoteWorker<NodeMapping, N
}
public static class Factory extends AbstractRemoteWorkerProvider<NodeMapping, NodeMapping, NodeMappingRemoteWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
RemoteSenderService remoteSenderService, int graphId) {
super(daoService, cacheServiceManager, remoteSenderService, graphId);
public Factory(ModuleManager moduleManager, RemoteSenderService remoteSenderService, int graphId) {
super(moduleManager, remoteSenderService, graphId);
}
@Override
public NodeMappingRemoteWorker workerInstance(DAOService daoService, CacheServiceManager cacheServiceManager) {
return new NodeMappingRemoteWorker(getDaoService(), getCacheServiceManager());
@Override public NodeMappingRemoteWorker workerInstance(ModuleManager moduleManager) {
return new NodeMappingRemoteWorker(moduleManager);
}
}
}

20
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/noderef/NodeReferenceAggregationWorker.java
View File

@ -18,9 +18,8 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.noderef;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.noderef.NodeReference;
import org.skywalking.apm.collector.stream.worker.base.AbstractLocalAsyncWorkerProvider;
import org.skywalking.apm.collector.stream.worker.impl.AggregationWorker;
@ -30,23 +29,22 @@ import org.skywalking.apm.collector.stream.worker.impl.AggregationWorker;
*/
public class NodeReferenceAggregationWorker extends AggregationWorker<NodeReference, NodeReference> {
public NodeReferenceAggregationWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public NodeReferenceAggregationWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override public int id() {
return 0;
return NodeReferenceAggregationWorker.class.hashCode();
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<NodeReference, NodeReference, NodeReferenceAggregationWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<NodeReference> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<NodeReference> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override public NodeReferenceAggregationWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new NodeReferenceAggregationWorker(getDaoService(), getCacheServiceManager());
@Override public NodeReferenceAggregationWorker workerInstance(ModuleManager moduleManager) {
return new NodeReferenceAggregationWorker(moduleManager);
}
@Override

23
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/noderef/NodeReferencePersistenceWorker.java
View File

@ -18,8 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.noderef;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.dao.INodeReferencePersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -32,8 +33,11 @@ import org.skywalking.apm.collector.stream.worker.impl.PersistenceWorker;
*/
public class NodeReferencePersistenceWorker extends PersistenceWorker<NodeReference, NodeReference> {
public NodeReferencePersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
private final DAOService daoService;
public NodeReferencePersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
}
@Override public int id() {
@ -45,18 +49,17 @@ public class NodeReferencePersistenceWorker extends PersistenceWorker<NodeRefere
}
@Override protected IPersistenceDAO persistenceDAO() {
return (IPersistenceDAO)getDaoService().get(INodeReferencePersistenceDAO.class);
return (IPersistenceDAO)daoService.get(INodeReferencePersistenceDAO.class);
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<NodeReference, NodeReference, NodeReferencePersistenceWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<NodeReference> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<NodeReference> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override public NodeReferencePersistenceWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new NodeReferencePersistenceWorker(getDaoService(), getCacheServiceManager());
@Override public NodeReferencePersistenceWorker workerInstance(ModuleManager moduleManager) {
return new NodeReferencePersistenceWorker(moduleManager);
}
@Override

18
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/noderef/NodeReferenceRemoteWorker.java
View File

@ -18,10 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.noderef;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.remote.service.RemoteSenderService;
import org.skywalking.apm.collector.remote.service.Selector;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.noderef.NodeReference;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorker;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorkerProvider;
@ -32,8 +31,8 @@ import org.skywalking.apm.collector.stream.worker.base.WorkerException;
*/
public class NodeReferenceRemoteWorker extends AbstractRemoteWorker<NodeReference, NodeReference> {
public NodeReferenceRemoteWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public NodeReferenceRemoteWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override public int id() {
@ -49,15 +48,12 @@ public class NodeReferenceRemoteWorker extends AbstractRemoteWorker<NodeReferenc
}
public static class Factory extends AbstractRemoteWorkerProvider<NodeReference, NodeReference, NodeReferenceRemoteWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
RemoteSenderService remoteSenderService, int graphId) {
super(daoService, cacheServiceManager, remoteSenderService, graphId);
public Factory(ModuleManager moduleManager, RemoteSenderService remoteSenderService, int graphId) {
super(moduleManager, remoteSenderService, graphId);
}
@Override
public NodeReferenceRemoteWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new NodeReferenceRemoteWorker(getDaoService(), getCacheServiceManager());
@Override public NodeReferenceRemoteWorker workerInstance(ModuleManager moduleManager) {
return new NodeReferenceRemoteWorker(moduleManager);
}
}
}

12
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/noderef/NodeReferenceSpanListener.java
View File

@ -25,7 +25,9 @@ import org.skywalking.apm.collector.agent.stream.parser.ExitSpanListener;
import org.skywalking.apm.collector.agent.stream.parser.RefsListener;
import org.skywalking.apm.collector.agent.stream.parser.standardization.ReferenceDecorator;
import org.skywalking.apm.collector.agent.stream.parser.standardization.SpanDecorator;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.InstanceCacheService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.CollectionUtils;
import org.skywalking.apm.collector.core.util.Const;
import org.skywalking.apm.collector.core.util.TimeBucketUtils;
@ -40,14 +42,14 @@ public class NodeReferenceSpanListener implements EntrySpanListener, ExitSpanLis
private final Logger logger = LoggerFactory.getLogger(NodeReferenceSpanListener.class);
private final CacheServiceManager cacheServiceManager;
private final InstanceCacheService instanceCacheService;
private final List<NodeReference> nodeReferences;
private final List<NodeReference> references;
public NodeReferenceSpanListener(CacheServiceManager cacheServiceManager) {
this.cacheServiceManager = cacheServiceManager;
public NodeReferenceSpanListener(ModuleManager moduleManager) {
this.nodeReferences = new LinkedList<>();
this.references = new LinkedList<>();
this.instanceCacheService = moduleManager.find(CacheModule.NAME).getService(InstanceCacheService.class);
}
@Override
@ -93,7 +95,7 @@ public class NodeReferenceSpanListener implements EntrySpanListener, ExitSpanLis
@Override public void parseRef(ReferenceDecorator referenceDecorator, int applicationId, int instanceId,
String segmentId) {
int parentApplicationId = cacheServiceManager.getInstanceCacheService().get(referenceDecorator.getParentApplicationInstanceId());
int parentApplicationId = instanceCacheService.get(referenceDecorator.getParentApplicationInstanceId());
NodeReference referenceSum = new NodeReference(Const.EMPTY_STRING);
referenceSum.setFrontApplicationId(parentApplicationId);

26
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/segment/SegmentCostPersistenceWorker.java
View File

@ -18,8 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.segment;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.dao.ISegmentCostPersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -32,12 +33,15 @@ import org.skywalking.apm.collector.stream.worker.impl.PersistenceWorker;
*/
public class SegmentCostPersistenceWorker extends PersistenceWorker<SegmentCost, SegmentCost> {
public SegmentCostPersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
private final DAOService daoService;
public SegmentCostPersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
}
@Override public int id() {
return 0;
return SegmentCostPersistenceWorker.class.hashCode();
}
@Override protected boolean needMergeDBData() {
@ -45,19 +49,17 @@ public class SegmentCostPersistenceWorker extends PersistenceWorker<SegmentCost,
}
@Override protected IPersistenceDAO persistenceDAO() {
return (IPersistenceDAO)getDaoService().get(ISegmentCostPersistenceDAO.class);
return (IPersistenceDAO)daoService.get(ISegmentCostPersistenceDAO.class);
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<SegmentCost, SegmentCost, SegmentCostPersistenceWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<SegmentCost> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<SegmentCost> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override
public SegmentCostPersistenceWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new SegmentCostPersistenceWorker(getDaoService(), getCacheServiceManager());
@Override public SegmentCostPersistenceWorker workerInstance(ModuleManager moduleManager) {
return new SegmentCostPersistenceWorker(moduleManager);
}
@Override

12
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/segment/SegmentCostSpanListener.java
View File

@ -25,7 +25,9 @@ import org.skywalking.apm.collector.agent.stream.parser.ExitSpanListener;
import org.skywalking.apm.collector.agent.stream.parser.FirstSpanListener;
import org.skywalking.apm.collector.agent.stream.parser.LocalSpanListener;
import org.skywalking.apm.collector.agent.stream.parser.standardization.SpanDecorator;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.ServiceNameCacheService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.Const;
import org.skywalking.apm.collector.core.util.TimeBucketUtils;
import org.skywalking.apm.collector.storage.table.segment.SegmentCost;
@ -40,13 +42,13 @@ public class SegmentCostSpanListener implements EntrySpanListener, ExitSpanListe
private final Logger logger = LoggerFactory.getLogger(SegmentCostSpanListener.class);
private final List<SegmentCost> segmentCosts;
private final CacheServiceManager cacheServiceManager;
private final ServiceNameCacheService serviceNameCacheService;
private boolean isError = false;
private long timeBucket;
public SegmentCostSpanListener(CacheServiceManager cacheServiceManager) {
this.cacheServiceManager = cacheServiceManager;
public SegmentCostSpanListener(ModuleManager moduleManager) {
this.segmentCosts = new ArrayList<>();
this.serviceNameCacheService = moduleManager.find(CacheModule.NAME).getService(ServiceNameCacheService.class);
}
@Override
@ -64,7 +66,7 @@ public class SegmentCostSpanListener implements EntrySpanListener, ExitSpanListe
if (spanDecorator.getOperationNameId() == 0) {
segmentCost.setServiceName(spanDecorator.getOperationName());
} else {
segmentCost.setServiceName(cacheServiceManager.getServiceNameCacheService().getSplitServiceName(cacheServiceManager.getServiceNameCacheService().get(spanDecorator.getOperationNameId())));
segmentCost.setServiceName(serviceNameCacheService.getSplitServiceName(serviceNameCacheService.get(spanDecorator.getOperationNameId())));
}
segmentCosts.add(segmentCost);

20
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/segment/SegmentPersistenceWorker.java
View File

@ -18,8 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.segment;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.dao.ISegmentPersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -32,8 +33,8 @@ import org.skywalking.apm.collector.stream.worker.impl.PersistenceWorker;
*/
public class SegmentPersistenceWorker extends PersistenceWorker<Segment, Segment> {
public SegmentPersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public SegmentPersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override public int id() {
@ -45,18 +46,17 @@ public class SegmentPersistenceWorker extends PersistenceWorker<Segment, Segment
}
@Override protected IPersistenceDAO persistenceDAO() {
return (IPersistenceDAO)getDaoService().get(ISegmentPersistenceDAO.class);
DAOService daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
return (IPersistenceDAO)daoService.get(ISegmentPersistenceDAO.class);
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<Segment, Segment, SegmentPersistenceWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<Segment> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<Segment> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override
public SegmentPersistenceWorker workerInstance(DAOService daoService, CacheServiceManager cacheServiceManager) {
return new SegmentPersistenceWorker(getDaoService(), getCacheServiceManager());
@Override public SegmentPersistenceWorker workerInstance(ModuleManager moduleManager) {
return new SegmentPersistenceWorker(moduleManager);
}
@Override

20
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/service/ServiceEntryAggregationWorker.java
View File

@ -18,9 +18,8 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.service;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.service.ServiceEntry;
import org.skywalking.apm.collector.stream.worker.base.AbstractLocalAsyncWorkerProvider;
import org.skywalking.apm.collector.stream.worker.impl.AggregationWorker;
@ -30,23 +29,22 @@ import org.skywalking.apm.collector.stream.worker.impl.AggregationWorker;
*/
public class ServiceEntryAggregationWorker extends AggregationWorker<ServiceEntry, ServiceEntry> {
public ServiceEntryAggregationWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public ServiceEntryAggregationWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override public int id() {
return 0;
return ServiceEntryAggregationWorker.class.hashCode();
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<ServiceEntry, ServiceEntry, ServiceEntryAggregationWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<ServiceEntry> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<ServiceEntry> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override public ServiceEntryAggregationWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new ServiceEntryAggregationWorker(getDaoService(), getCacheServiceManager());
@Override public ServiceEntryAggregationWorker workerInstance(ModuleManager moduleManager) {
return new ServiceEntryAggregationWorker(moduleManager);
}
@Override

22
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/service/ServiceEntryPersistenceWorker.java
View File

@ -18,8 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.service;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.dao.IServiceEntryPersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -32,8 +33,11 @@ import org.skywalking.apm.collector.stream.worker.impl.PersistenceWorker;
*/
public class ServiceEntryPersistenceWorker extends PersistenceWorker<ServiceEntry, ServiceEntry> {
public ServiceEntryPersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
private final DAOService daoService;
public ServiceEntryPersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
}
@Override public int id() {
@ -45,18 +49,16 @@ public class ServiceEntryPersistenceWorker extends PersistenceWorker<ServiceEntr
}
@Override protected IPersistenceDAO persistenceDAO() {
return (IPersistenceDAO)getDaoService().get(IServiceEntryPersistenceDAO.class);
return (IPersistenceDAO)daoService.get(IServiceEntryPersistenceDAO.class);
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<ServiceEntry, ServiceEntry, ServiceEntryPersistenceWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<ServiceEntry> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<ServiceEntry> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override public ServiceEntryPersistenceWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new ServiceEntryPersistenceWorker(getDaoService(), getCacheServiceManager());
@Override public ServiceEntryPersistenceWorker workerInstance(ModuleManager moduleManager) {
return new ServiceEntryPersistenceWorker(moduleManager);
}
@Override

18
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/service/ServiceEntryRemoteWorker.java
View File

@ -18,10 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.service;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.remote.service.RemoteSenderService;
import org.skywalking.apm.collector.remote.service.Selector;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.service.ServiceEntry;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorker;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorkerProvider;
@ -32,8 +31,8 @@ import org.skywalking.apm.collector.stream.worker.base.WorkerException;
*/
public class ServiceEntryRemoteWorker extends AbstractRemoteWorker<ServiceEntry, ServiceEntry> {
public ServiceEntryRemoteWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public ServiceEntryRemoteWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override public int id() {
@ -49,14 +48,13 @@ public class ServiceEntryRemoteWorker extends AbstractRemoteWorker<ServiceEntry,
}
public static class Factory extends AbstractRemoteWorkerProvider<ServiceEntry, ServiceEntry, ServiceEntryRemoteWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
RemoteSenderService remoteSenderService, int graphId) {
super(daoService, cacheServiceManager, remoteSenderService, graphId);
public Factory(ModuleManager moduleManager, RemoteSenderService remoteSenderService, int graphId) {
super(moduleManager, remoteSenderService, graphId);
}
@Override
public ServiceEntryRemoteWorker workerInstance(DAOService daoService, CacheServiceManager cacheServiceManager) {
return new ServiceEntryRemoteWorker(getDaoService(), getCacheServiceManager());
@Override public ServiceEntryRemoteWorker workerInstance(ModuleManager moduleManager) {
return new ServiceEntryRemoteWorker(moduleManager);
}
}
}

12
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/service/ServiceEntrySpanListener.java
View File

@ -23,7 +23,9 @@ import org.skywalking.apm.collector.agent.stream.parser.FirstSpanListener;
import org.skywalking.apm.collector.agent.stream.parser.RefsListener;
import org.skywalking.apm.collector.agent.stream.parser.standardization.ReferenceDecorator;
import org.skywalking.apm.collector.agent.stream.parser.standardization.SpanDecorator;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.ServiceNameCacheService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.Const;
import org.skywalking.apm.collector.core.util.TimeBucketUtils;
import org.skywalking.apm.collector.storage.table.service.ServiceEntry;
@ -43,10 +45,10 @@ public class ServiceEntrySpanListener implements RefsListener, FirstSpanListener
private int entryServiceId;
private String entryServiceName;
private boolean hasEntry = false;
private final CacheServiceManager cacheServiceManager;
private final ServiceNameCacheService serviceNameCacheService;
public ServiceEntrySpanListener(CacheServiceManager cacheServiceManager) {
this.cacheServiceManager = cacheServiceManager;
public ServiceEntrySpanListener(ModuleManager moduleManager) {
this.serviceNameCacheService = moduleManager.find(CacheModule.NAME).getService(ServiceNameCacheService.class);
}
@Override
@ -54,7 +56,7 @@ public class ServiceEntrySpanListener implements RefsListener, FirstSpanListener
String segmentId) {
this.applicationId = applicationId;
this.entryServiceId = spanDecorator.getOperationNameId();
this.entryServiceName = cacheServiceManager.getServiceNameCacheService().getSplitServiceName(cacheServiceManager.getServiceNameCacheService().get(entryServiceId));
this.entryServiceName = serviceNameCacheService.getSplitServiceName(serviceNameCacheService.get(entryServiceId));
this.hasEntry = true;
}

20
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/serviceref/ServiceReferenceAggregationWorker.java
View File

@ -18,9 +18,8 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.serviceref;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.serviceref.ServiceReference;
import org.skywalking.apm.collector.stream.worker.base.AbstractLocalAsyncWorkerProvider;
import org.skywalking.apm.collector.stream.worker.impl.AggregationWorker;
@ -30,23 +29,22 @@ import org.skywalking.apm.collector.stream.worker.impl.AggregationWorker;
*/
public class ServiceReferenceAggregationWorker extends AggregationWorker<ServiceReference, ServiceReference> {
public ServiceReferenceAggregationWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public ServiceReferenceAggregationWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override public int id() {
return 0;
return ServiceReferenceAggregationWorker.class.hashCode();
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<ServiceReference, ServiceReference, ServiceReferenceAggregationWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<ServiceReference> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<ServiceReference> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override public ServiceReferenceAggregationWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new ServiceReferenceAggregationWorker(getDaoService(), getCacheServiceManager());
@Override public ServiceReferenceAggregationWorker workerInstance(ModuleManager moduleManager) {
return new ServiceReferenceAggregationWorker(moduleManager);
}
@Override

23
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/serviceref/ServiceReferencePersistenceWorker.java
View File

@ -18,8 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.serviceref;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.dao.IServiceReferencePersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -32,8 +33,11 @@ import org.skywalking.apm.collector.stream.worker.impl.PersistenceWorker;
*/
public class ServiceReferencePersistenceWorker extends PersistenceWorker<ServiceReference, ServiceReference> {
public ServiceReferencePersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
private final DAOService daoService;
public ServiceReferencePersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
this.daoService = getModuleManager().find(StorageModule.NAME).getService(DAOService.class);
}
@Override public int id() {
@ -45,18 +49,17 @@ public class ServiceReferencePersistenceWorker extends PersistenceWorker<Service
}
@Override protected IPersistenceDAO persistenceDAO() {
return (IPersistenceDAO)getDaoService().get(IServiceReferencePersistenceDAO.class);
return (IPersistenceDAO)daoService.get(IServiceReferencePersistenceDAO.class);
}
public static class Factory extends AbstractLocalAsyncWorkerProvider<ServiceReference, ServiceReference, ServiceReferencePersistenceWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
QueueCreatorService<ServiceReference> queueCreatorService) {
super(daoService, cacheServiceManager, queueCreatorService);
public Factory(ModuleManager moduleManager, QueueCreatorService<ServiceReference> queueCreatorService) {
super(moduleManager, queueCreatorService);
}
@Override public ServiceReferencePersistenceWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new ServiceReferencePersistenceWorker(getDaoService(), getCacheServiceManager());
@Override public ServiceReferencePersistenceWorker workerInstance(ModuleManager moduleManager) {
return new ServiceReferencePersistenceWorker(moduleManager);
}
@Override

19
apm-collector/apm-collector-agent/collector-agent-stream/src/main/java/org/skywalking/apm/collector/agent/stream/worker/trace/serviceref/ServiceReferenceRemoteWorker.java
View File

@ -18,10 +18,9 @@
package org.skywalking.apm.collector.agent.stream.worker.trace.serviceref;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.remote.service.RemoteSenderService;
import org.skywalking.apm.collector.remote.service.Selector;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.storage.table.serviceref.ServiceReference;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorker;
import org.skywalking.apm.collector.stream.worker.base.AbstractRemoteWorkerProvider;
@ -32,8 +31,8 @@ import org.skywalking.apm.collector.stream.worker.base.WorkerException;
*/
public class ServiceReferenceRemoteWorker extends AbstractRemoteWorker<ServiceReference, ServiceReference> {
public ServiceReferenceRemoteWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public ServiceReferenceRemoteWorker(ModuleManager moduleManager) {
super(moduleManager);
}
@Override public int id() {
@ -49,15 +48,13 @@ public class ServiceReferenceRemoteWorker extends AbstractRemoteWorker<ServiceRe
}
public static class Factory extends AbstractRemoteWorkerProvider<ServiceReference, ServiceReference, ServiceReferenceRemoteWorker> {
public Factory(DAOService daoService, CacheServiceManager cacheServiceManager,
RemoteSenderService remoteSenderService, int graphId) {
super(daoService, cacheServiceManager, remoteSenderService, graphId);
public Factory(ModuleManager moduleManager, RemoteSenderService remoteSenderService, int graphId) {
super(moduleManager, remoteSenderService, graphId);
}
@Override
public ServiceReferenceRemoteWorker workerInstance(DAOService daoService,
CacheServiceManager cacheServiceManager) {
return new ServiceReferenceRemoteWorker(getDaoService(), getCacheServiceManager());
@Override public ServiceReferenceRemoteWorker workerInstance(ModuleManager moduleManager) {
return new ServiceReferenceRemoteWorker(moduleManager);
}
}
}

15
apm-collector/apm-collector-cache/collector-cache-guava-provider/src/main/java/org/skywalking/apm/collector/cache/guava/CacheModuleGuavaProvider.java vendored
View File

@ -29,7 +29,6 @@ import org.skywalking.apm.collector.cache.service.InstanceCacheService;
import org.skywalking.apm.collector.cache.service.ServiceIdCacheService;
import org.skywalking.apm.collector.cache.service.ServiceNameCacheService;
import org.skywalking.apm.collector.core.module.Module;
import org.skywalking.apm.collector.core.module.ModuleNotFoundException;
import org.skywalking.apm.collector.core.module.ModuleProvider;
import org.skywalking.apm.collector.core.module.ServiceNotProvidedException;
import org.skywalking.apm.collector.storage.StorageModule;
@ -52,16 +51,12 @@ public class CacheModuleGuavaProvider extends ModuleProvider {
}
@Override public void start(Properties config) throws ServiceNotProvidedException {
try {
DAOService daoService = getManager().find(StorageModule.NAME).getService(DAOService.class);
DAOService daoService = getManager().find(StorageModule.NAME).getService(DAOService.class);
this.registerServiceImplementation(ApplicationCacheService.class, new ApplicationCacheGuavaService(daoService));
this.registerServiceImplementation(InstanceCacheService.class, new InstanceCacheGuavaService(daoService));
this.registerServiceImplementation(ServiceIdCacheService.class, new ServiceIdCacheGuavaService(daoService));
this.registerServiceImplementation(ServiceNameCacheService.class, new ServiceNameCacheGuavaService(daoService));
} catch (ModuleNotFoundException e) {
throw new ServiceNotProvidedException(e.getMessage());
}
this.registerServiceImplementation(ApplicationCacheService.class, new ApplicationCacheGuavaService(daoService));
this.registerServiceImplementation(InstanceCacheService.class, new InstanceCacheGuavaService(daoService));
this.registerServiceImplementation(ServiceIdCacheService.class, new ServiceIdCacheGuavaService(daoService));
this.registerServiceImplementation(ServiceNameCacheService.class, new ServiceNameCacheGuavaService(daoService));
}
@Override public void notifyAfterCompleted() throws ServiceNotProvidedException {

6
apm-collector/apm-collector-core/src/main/java/org/skywalking/apm/collector/core/module/Module.java
View File

@ -102,11 +102,11 @@ public abstract class Module {
return loadedProviders.getFirst();
}
public final <T extends Service> T getService(Class<T> serviceType) throws ServiceNotProvidedException {
public final <T extends Service> T getService(Class<T> serviceType) throws ServiceNotProvidedRuntimeException {
try {
return provider().getService(serviceType);
} catch (ProviderNotFoundException | DuplicateProviderException e) {
throw new ServiceNotProvidedException(e.getMessage());
} catch (ProviderNotFoundException | DuplicateProviderException | ServiceNotProvidedException e) {
throw new ServiceNotProvidedRuntimeException(e.getMessage());
}
}
}

6
apm-collector/apm-collector-core/src/main/java/org/skywalking/apm/collector/core/module/ModuleManager.java
View File

@ -27,7 +27,7 @@ import java.util.ServiceLoader;
/**
* The <code>ModuleManager</code> takes charge of all {@link Module}s in collector.
*
* @author wu-sheng
* @author wu-sheng, peng-yongsheng
*/
public class ModuleManager {
private Map<String, Module> loadedModules = new HashMap<>();
@ -74,10 +74,10 @@ public class ModuleManager {
return loadedModules.get(moduleName) != null;
}
public Module find(String moduleName) throws ModuleNotFoundException {
public Module find(String moduleName) throws ModuleNotFoundRuntimeException {
Module module = loadedModules.get(moduleName);
if (module != null)
return module;
throw new ModuleNotFoundException(moduleName + " missing.");
throw new ModuleNotFoundRuntimeException(moduleName + " missing.");
}
}

9
apm-collector/apm-collector-naming/collector-naming-jetty-provider/src/main/java/org/skywalking/apm/collector/naming/jetty/NamingModuleJettyProvider.java
View File

@ -21,7 +21,6 @@ package org.skywalking.apm.collector.naming.jetty;
import java.util.Properties;
import org.skywalking.apm.collector.cluster.ClusterModule;
import org.skywalking.apm.collector.core.module.Module;
import org.skywalking.apm.collector.core.module.ModuleNotFoundException;
import org.skywalking.apm.collector.core.module.ModuleProvider;
import org.skywalking.apm.collector.core.module.ServiceNotProvidedException;
import org.skywalking.apm.collector.jetty.manager.JettyManagerModule;
@ -58,12 +57,8 @@ public class NamingModuleJettyProvider extends ModuleProvider {
Integer port = (Integer)config.get(PORT);
String contextPath = config.getProperty(CONTEXT_PATH);
try {
JettyManagerService managerService = getManager().find(JettyManagerModule.NAME).getService(JettyManagerService.class);
managerService.createIfAbsent(host, port, contextPath);
} catch (ModuleNotFoundException e) {
throw new ServiceNotProvidedException(e.getMessage());
}
JettyManagerService managerService = getManager().find(JettyManagerModule.NAME).getService(JettyManagerService.class);
managerService.createIfAbsent(host, port, contextPath);
}
@Override public void notifyAfterCompleted() throws ServiceNotProvidedException {

10
apm-collector/apm-collector-naming/collector-naming-jetty-provider/src/main/java/org/skywalking/apm/collector/naming/jetty/service/NamingJettyHandlerRegisterService.java
View File

@ -19,8 +19,6 @@
package org.skywalking.apm.collector.naming.jetty.service;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.module.ModuleNotFoundException;
import org.skywalking.apm.collector.core.module.ServiceNotProvidedException;
import org.skywalking.apm.collector.jetty.manager.JettyManagerModule;
import org.skywalking.apm.collector.jetty.manager.service.JettyManagerService;
import org.skywalking.apm.collector.naming.service.NamingHandlerRegisterService;
@ -46,11 +44,7 @@ public class NamingJettyHandlerRegisterService implements NamingHandlerRegisterS
}
@Override public void register(ServerHandler namingHandler) {
try {
JettyManagerService managerService = moduleManager.find(JettyManagerModule.NAME).getService(JettyManagerService.class);
managerService.addHandler(this.host, this.port, namingHandler);
} catch (ModuleNotFoundException | ServiceNotProvidedException e) {
logger.error(e.getMessage(), e);
}
JettyManagerService managerService = moduleManager.find(JettyManagerModule.NAME).getService(JettyManagerService.class);
managerService.addHandler(this.host, this.port, namingHandler);
}
}

19
apm-collector/apm-collector-remote/collector-remote-grpc-provider/src/main/java/org/skywalking/apm/collector/remote/grpc/RemoteModuleGRPCProvider.java
View File

@ -5,7 +5,6 @@ import org.skywalking.apm.collector.cluster.ClusterModule;
import org.skywalking.apm.collector.cluster.service.ModuleListenerService;
import org.skywalking.apm.collector.cluster.service.ModuleRegisterService;
import org.skywalking.apm.collector.core.module.Module;
import org.skywalking.apm.collector.core.module.ModuleNotFoundException;
import org.skywalking.apm.collector.core.module.ModuleProvider;
import org.skywalking.apm.collector.core.module.ServiceNotProvidedException;
import org.skywalking.apm.collector.grpc.manager.GRPCManagerModule;
@ -51,19 +50,15 @@ public class RemoteModuleGRPCProvider extends ModuleProvider {
String host = config.getProperty(HOST);
Integer port = (Integer)config.get(PORT);
try {
GRPCManagerService managerService = getManager().find(GRPCManagerModule.NAME).getService(GRPCManagerService.class);
Server gRPCServer = managerService.createIfAbsent(host, port);
gRPCServer.addHandler(new RemoteCommonServiceHandler(listener));
GRPCManagerService managerService = getManager().find(GRPCManagerModule.NAME).getService(GRPCManagerService.class);
Server gRPCServer = managerService.createIfAbsent(host, port);
gRPCServer.addHandler(new RemoteCommonServiceHandler(listener));
ModuleRegisterService moduleRegisterService = getManager().find(ClusterModule.NAME).getService(ModuleRegisterService.class);
moduleRegisterService.register(RemoteModule.NAME, this.name(), new RemoteModuleGRPCRegistration(host, port));
ModuleRegisterService moduleRegisterService = getManager().find(ClusterModule.NAME).getService(ModuleRegisterService.class);
moduleRegisterService.register(RemoteModule.NAME, this.name(), new RemoteModuleGRPCRegistration(host, port));
ModuleListenerService moduleListenerService = getManager().find(ClusterModule.NAME).getService(ModuleListenerService.class);
moduleListenerService.addListener(remoteSenderService);
} catch (ModuleNotFoundException e) {
throw new ServiceNotProvidedException(e.getMessage());
}
ModuleListenerService moduleListenerService = getManager().find(ClusterModule.NAME).getService(ModuleListenerService.class);
moduleListenerService.addListener(remoteSenderService);
}
@Override public void notifyAfterCompleted() throws ServiceNotProvidedException {

13
apm-collector/apm-collector-stream/collector-stream-provider/src/main/java/org/skywalking/apm/collector/stream/StreamModuleProvider.java
View File

@ -21,7 +21,6 @@ package org.skywalking.apm.collector.stream;
import java.util.Properties;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.core.module.Module;
import org.skywalking.apm.collector.core.module.ModuleNotFoundException;
import org.skywalking.apm.collector.core.module.ModuleProvider;
import org.skywalking.apm.collector.core.module.ServiceNotProvidedException;
import org.skywalking.apm.collector.queue.QueueModule;
@ -50,14 +49,10 @@ public class StreamModuleProvider extends ModuleProvider {
@Override public void start(Properties config) throws ServiceNotProvidedException {
PersistenceTimer persistenceTimer = new PersistenceTimer();
try {
QueueCreatorService queueCreatorService = getManager().find(QueueModule.NAME).getService(QueueCreatorService.class);
RemoteSenderService remoteSenderService = getManager().find(RemoteModule.NAME).getService(RemoteSenderService.class);
DAOService daoService = getManager().find(StorageModule.NAME).getService(DAOService.class);
persistenceTimer.start(daoService);
} catch (ModuleNotFoundException e) {
throw new ServiceNotProvidedException(e.getMessage());
}
QueueCreatorService queueCreatorService = getManager().find(QueueModule.NAME).getService(QueueCreatorService.class);
RemoteSenderService remoteSenderService = getManager().find(RemoteModule.NAME).getService(RemoteSenderService.class);
DAOService daoService = getManager().find(StorageModule.NAME).getService(DAOService.class);
persistenceTimer.start(daoService);
}
@Override public void notifyAfterCompleted() throws ServiceNotProvidedException {

7
apm-collector/apm-collector-stream/collector-stream-provider/src/main/java/org/skywalking/apm/collector/stream/worker/base/AbstractLocalAsyncWorker.java
View File

@ -18,9 +18,8 @@
package org.skywalking.apm.collector.stream.worker.base;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.base.QueueExecutor;
import org.skywalking.apm.collector.storage.service.DAOService;
/**
* The <code>AbstractLocalAsyncWorker</code> implementations represent workers,
@ -31,8 +30,8 @@ import org.skywalking.apm.collector.storage.service.DAOService;
*/
public abstract class AbstractLocalAsyncWorker<INPUT, OUTPUT> extends AbstractWorker<INPUT, OUTPUT> implements QueueExecutor<INPUT> {
public AbstractLocalAsyncWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public AbstractLocalAsyncWorker(ModuleManager moduleManager) {
super(moduleManager);
}
/**

9
apm-collector/apm-collector-stream/collector-stream-provider/src/main/java/org/skywalking/apm/collector/stream/worker/base/AbstractLocalAsyncWorkerProvider.java
View File

@ -18,11 +18,10 @@
package org.skywalking.apm.collector.stream.worker.base;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.queue.base.QueueEventHandler;
import org.skywalking.apm.collector.queue.base.QueueExecutor;
import org.skywalking.apm.collector.queue.service.QueueCreatorService;
import org.skywalking.apm.collector.storage.service.DAOService;
/**
* @author peng-yongsheng
@ -33,15 +32,15 @@ public abstract class AbstractLocalAsyncWorkerProvider<INPUT, OUTPUT, WORKER_TYP
private final QueueCreatorService<INPUT> queueCreatorService;
public AbstractLocalAsyncWorkerProvider(DAOService daoService, CacheServiceManager cacheServiceManager,
public AbstractLocalAsyncWorkerProvider(ModuleManager moduleManager,
QueueCreatorService<INPUT> queueCreatorService) {
super(daoService, cacheServiceManager);
super(moduleManager);
this.queueCreatorService = queueCreatorService;
}
@Override
public final WorkerRef create(WorkerCreateListener workerCreateListener) {
WORKER_TYPE localAsyncWorker = workerInstance(getDaoService(), getCacheServiceManager());
WORKER_TYPE localAsyncWorker = workerInstance(getModuleManager());
workerCreateListener.addWorker(localAsyncWorker);
QueueEventHandler<INPUT> queueEventHandler = queueCreatorService.create(queueSize(), localAsyncWorker);
return new LocalAsyncWorkerRef<>(localAsyncWorker, queueEventHandler);

7
apm-collector/apm-collector-stream/collector-stream-provider/src/main/java/org/skywalking/apm/collector/stream/worker/base/AbstractRemoteWorker.java
View File

@ -18,10 +18,9 @@
package org.skywalking.apm.collector.stream.worker.base;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.data.Data;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.remote.service.Selector;
import org.skywalking.apm.collector.storage.service.DAOService;
/**
* The <code>AbstractRemoteWorker</code> implementations represent workers,
@ -34,8 +33,8 @@ import org.skywalking.apm.collector.storage.service.DAOService;
*/
public abstract class AbstractRemoteWorker<INPUT extends Data, OUTPUT extends Data> extends AbstractWorker<INPUT, OUTPUT> {
public AbstractRemoteWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public AbstractRemoteWorker(ModuleManager moduleManager) {
super(moduleManager);
}
public abstract Selector selector();

11
apm-collector/apm-collector-stream/collector-stream-provider/src/main/java/org/skywalking/apm/collector/stream/worker/base/AbstractRemoteWorkerProvider.java
View File

@ -18,10 +18,9 @@
package org.skywalking.apm.collector.stream.worker.base;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.data.Data;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.remote.service.RemoteSenderService;
import org.skywalking.apm.collector.storage.service.DAOService;
/**
* The <code>AbstractRemoteWorkerProvider</code> implementations represent providers,
@ -36,9 +35,9 @@ public abstract class AbstractRemoteWorkerProvider<INPUT extends Data, OUTPUT ex
private final RemoteSenderService remoteSenderService;
private final int graphId;
public AbstractRemoteWorkerProvider(DAOService daoService, CacheServiceManager cacheServiceManager,
RemoteSenderService remoteSenderService, int graphId) {
super(daoService, cacheServiceManager);
public AbstractRemoteWorkerProvider(ModuleManager moduleManager, RemoteSenderService remoteSenderService,
int graphId) {
super(moduleManager);
this.remoteSenderService = remoteSenderService;
this.graphId = graphId;
}
@ -51,7 +50,7 @@ public abstract class AbstractRemoteWorkerProvider<INPUT extends Data, OUTPUT ex
* worker instance, when the worker provider not find then Throw this Exception.
*/
@Override final public RemoteWorkerRef create(WorkerCreateListener workerCreateListener) {
WORKER_TYPE remoteWorker = workerInstance(getDaoService(), getCacheServiceManager());
WORKER_TYPE remoteWorker = workerInstance(getModuleManager());
workerCreateListener.addWorker(remoteWorker);
return new RemoteWorkerRef<>(remoteWorker, remoteSenderService, graphId);
}

19
apm-collector/apm-collector-stream/collector-stream-provider/src/main/java/org/skywalking/apm/collector/stream/worker/base/AbstractWorker.java
View File

@ -18,10 +18,9 @@
package org.skywalking.apm.collector.stream.worker.base;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.graph.Next;
import org.skywalking.apm.collector.core.graph.NodeProcessor;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -32,20 +31,14 @@ public abstract class AbstractWorker<INPUT, OUTPUT> implements NodeProcessor<INP
private final Logger logger = LoggerFactory.getLogger(AbstractWorker.class);
private final DAOService daoService;
private final CacheServiceManager cacheServiceManager;
private final ModuleManager moduleManager;
public AbstractWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.daoService = daoService;
this.cacheServiceManager = cacheServiceManager;
public AbstractWorker(ModuleManager moduleManager) {
this.moduleManager = moduleManager;
}
public final DAOService getDaoService() {
return daoService;
}
public final CacheServiceManager getCacheServiceManager() {
return cacheServiceManager;
public final ModuleManager getModuleManager() {
return moduleManager;
}
private Next<OUTPUT> next;

21
apm-collector/apm-collector-stream/collector-stream-provider/src/main/java/org/skywalking/apm/collector/stream/worker/base/AbstractWorkerProvider.java
View File

@ -18,29 +18,22 @@
package org.skywalking.apm.collector.stream.worker.base;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.core.module.ModuleManager;
/**
* @author peng-yongsheng
*/
public abstract class AbstractWorkerProvider<INPUT, OUTPUT, WORKER_TYPE extends AbstractWorker<INPUT, OUTPUT>> implements Provider {
private final DAOService daoService;
private final CacheServiceManager cacheServiceManager;
private final ModuleManager moduleManager;
public AbstractWorkerProvider(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.daoService = daoService;
this.cacheServiceManager = cacheServiceManager;
public AbstractWorkerProvider(ModuleManager moduleManager) {
this.moduleManager = moduleManager;
}
public final DAOService getDaoService() {
return daoService;
public final ModuleManager getModuleManager() {
return moduleManager;
}
public final CacheServiceManager getCacheServiceManager() {
return cacheServiceManager;
}
public abstract WORKER_TYPE workerInstance(DAOService daoService, CacheServiceManager cacheServiceManager);
public abstract WORKER_TYPE workerInstance(ModuleManager moduleManager);
}

7
apm-collector/apm-collector-stream/collector-stream-provider/src/main/java/org/skywalking/apm/collector/stream/worker/impl/AggregationWorker.java
View File

@ -18,9 +18,8 @@
package org.skywalking.apm.collector.stream.worker.impl;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.data.Data;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.stream.worker.base.AbstractLocalAsyncWorker;
import org.skywalking.apm.collector.stream.worker.base.WorkerException;
import org.skywalking.apm.collector.stream.worker.impl.data.DataCache;
@ -37,8 +36,8 @@ public abstract class AggregationWorker<INPUT extends Data, OUTPUT extends Data>
private DataCache dataCache;
private int messageNum;
public AggregationWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public AggregationWorker(ModuleManager moduleManager) {
super(moduleManager);
this.dataCache = new DataCache();
}

11
apm-collector/apm-collector-stream/collector-stream-provider/src/main/java/org/skywalking/apm/collector/stream/worker/impl/PersistenceWorker.java
View File

@ -21,9 +21,10 @@ package org.skywalking.apm.collector.stream.worker.impl;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.data.Data;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.ObjectUtils;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.base.dao.IBatchDAO;
import org.skywalking.apm.collector.storage.base.dao.IPersistenceDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -41,10 +42,12 @@ public abstract class PersistenceWorker<INPUT extends Data, OUTPUT extends Data>
private final Logger logger = LoggerFactory.getLogger(PersistenceWorker.class);
private final DataCache dataCache;
private final DAOService daoService;
public PersistenceWorker(DAOService daoService, CacheServiceManager cacheServiceManager) {
super(daoService, cacheServiceManager);
public PersistenceWorker(ModuleManager moduleManager) {
super(moduleManager);
this.dataCache = new DataCache();
this.daoService = moduleManager.find(StorageModule.NAME).getService(DAOService.class);
}
public final void flushAndSwitch() {
@ -64,7 +67,7 @@ public abstract class PersistenceWorker<INPUT extends Data, OUTPUT extends Data>
dataCache.switchPointer();
List<?> collection = buildBatchCollection();
IBatchDAO dao = (IBatchDAO)getDaoService().get(IBatchDAO.class);
IBatchDAO dao = (IBatchDAO)daoService.get(IBatchDAO.class);
dao.batchPersistence(collection);
}
} finally {

59
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/jetty/UIModuleJettyProvider.java
View File

@ -20,12 +20,10 @@ package org.skywalking.apm.collector.ui.jetty;
import java.util.Properties;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cluster.ClusterModule;
import org.skywalking.apm.collector.cluster.service.ModuleListenerService;
import org.skywalking.apm.collector.cluster.service.ModuleRegisterService;
import org.skywalking.apm.collector.core.module.Module;
import org.skywalking.apm.collector.core.module.ModuleNotFoundException;
import org.skywalking.apm.collector.core.module.ModuleProvider;
import org.skywalking.apm.collector.core.module.ServiceNotProvidedException;
import org.skywalking.apm.collector.jetty.manager.JettyManagerModule;
@ -34,7 +32,6 @@ import org.skywalking.apm.collector.naming.NamingModule;
import org.skywalking.apm.collector.naming.service.NamingHandlerRegisterService;
import org.skywalking.apm.collector.server.Server;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.ui.UIModule;
import org.skywalking.apm.collector.ui.jetty.handler.SegmentTopGetHandler;
import org.skywalking.apm.collector.ui.jetty.handler.SpanGetHandler;
@ -77,28 +74,20 @@ public class UIModuleJettyProvider extends ModuleProvider {
String host = config.getProperty(HOST);
Integer port = (Integer)config.get(PORT);
String contextPath = config.getProperty(CONTEXT_PATH);
try {
ModuleRegisterService moduleRegisterService = getManager().find(ClusterModule.NAME).getService(ModuleRegisterService.class);
moduleRegisterService.register(UIModule.NAME, this.name(), new UIModuleJettyRegistration(host, port, contextPath));
UIJettyNamingListener namingListener = new UIJettyNamingListener();
ModuleListenerService moduleListenerService = getManager().find(ClusterModule.NAME).getService(ModuleListenerService.class);
moduleListenerService.addListener(namingListener);
ModuleRegisterService moduleRegisterService = getManager().find(ClusterModule.NAME).getService(ModuleRegisterService.class);
moduleRegisterService.register(UIModule.NAME, this.name(), new UIModuleJettyRegistration(host, port, contextPath));
NamingHandlerRegisterService namingHandlerRegisterService = getManager().find(NamingModule.NAME).getService(NamingHandlerRegisterService.class);
namingHandlerRegisterService.register(new UIJettyNamingHandler(namingListener));
UIJettyNamingListener namingListener = new UIJettyNamingListener();
ModuleListenerService moduleListenerService = getManager().find(ClusterModule.NAME).getService(ModuleListenerService.class);
moduleListenerService.addListener(namingListener);
CacheServiceManager cacheServiceManager = new CacheServiceManager();
cacheServiceManager.init(getManager());
NamingHandlerRegisterService namingHandlerRegisterService = getManager().find(NamingModule.NAME).getService(NamingHandlerRegisterService.class);
namingHandlerRegisterService.register(new UIJettyNamingHandler(namingListener));
DAOService daoService = getManager().find(StorageModule.NAME).getService(DAOService.class);
JettyManagerService managerService = getManager().find(JettyManagerModule.NAME).getService(JettyManagerService.class);
Server jettyServer = managerService.createIfAbsent(host, port, contextPath);
addHandlers(daoService, jettyServer, cacheServiceManager);
} catch (ModuleNotFoundException e) {
throw new ServiceNotProvidedException(e.getMessage());
}
JettyManagerService managerService = getManager().find(JettyManagerModule.NAME).getService(JettyManagerService.class);
Server jettyServer = managerService.createIfAbsent(host, port, contextPath);
addHandlers(jettyServer);
}
@Override public void notifyAfterCompleted() throws ServiceNotProvidedException {
@ -109,19 +98,19 @@ public class UIModuleJettyProvider extends ModuleProvider {
return new String[] {ClusterModule.NAME, JettyManagerModule.NAME, NamingModule.NAME, CacheModule.NAME, StorageModule.NAME};
}
private void addHandlers(DAOService daoService, Server jettyServer, CacheServiceManager cacheServiceManager) {
jettyServer.addHandler(new ApplicationsGetHandler(daoService, cacheServiceManager));
jettyServer.addHandler(new InstanceHealthGetHandler(daoService, cacheServiceManager));
jettyServer.addHandler(new InstanceMetricGetOneTimeBucketHandler(daoService, cacheServiceManager));
jettyServer.addHandler(new InstanceMetricGetRangeTimeBucketHandler(daoService, cacheServiceManager));
jettyServer.addHandler(new InstanceOsInfoGetHandler(daoService, cacheServiceManager));
jettyServer.addHandler(new EntryServiceGetHandler(daoService, cacheServiceManager));
jettyServer.addHandler(new ServiceTreeGetByIdHandler(daoService, cacheServiceManager));
jettyServer.addHandler(new AllInstanceLastTimeGetHandler(daoService, cacheServiceManager));
jettyServer.addHandler(new OneInstanceLastTimeGetHandler(daoService, cacheServiceManager));
jettyServer.addHandler(new SegmentTopGetHandler(daoService, cacheServiceManager));
jettyServer.addHandler(new SpanGetHandler(daoService, cacheServiceManager));
jettyServer.addHandler(new TraceDagGetHandler(daoService, cacheServiceManager));
jettyServer.addHandler(new TraceStackGetHandler(daoService, cacheServiceManager));
private void addHandlers(Server jettyServer) {
jettyServer.addHandler(new ApplicationsGetHandler(getManager()));
jettyServer.addHandler(new InstanceHealthGetHandler(getManager()));
jettyServer.addHandler(new InstanceMetricGetOneTimeBucketHandler(getManager()));
jettyServer.addHandler(new InstanceMetricGetRangeTimeBucketHandler(getManager()));
jettyServer.addHandler(new InstanceOsInfoGetHandler(getManager()));
jettyServer.addHandler(new EntryServiceGetHandler(getManager()));
jettyServer.addHandler(new ServiceTreeGetByIdHandler(getManager()));
jettyServer.addHandler(new AllInstanceLastTimeGetHandler(getManager()));
jettyServer.addHandler(new OneInstanceLastTimeGetHandler(getManager()));
jettyServer.addHandler(new SegmentTopGetHandler(getManager()));
jettyServer.addHandler(new SpanGetHandler(getManager()));
jettyServer.addHandler(new TraceDagGetHandler(getManager()));
jettyServer.addHandler(new TraceStackGetHandler(getManager()));
}
}

7
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/jetty/handler/SegmentTopGetHandler.java
View File

@ -20,12 +20,11 @@ package org.skywalking.apm.collector.ui.jetty.handler;
import com.google.gson.JsonElement;
import javax.servlet.http.HttpServletRequest;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.StringUtils;
import org.skywalking.apm.collector.server.jetty.ArgumentsParseException;
import org.skywalking.apm.collector.server.jetty.JettyHandler;
import org.skywalking.apm.collector.storage.dao.ISegmentCostUIDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.ui.service.SegmentTopService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -43,8 +42,8 @@ public class SegmentTopGetHandler extends JettyHandler {
private final SegmentTopService service;
public SegmentTopGetHandler(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.service = new SegmentTopService(daoService, cacheServiceManager);
public SegmentTopGetHandler(ModuleManager moduleManager) {
this.service = new SegmentTopService(moduleManager);
}
@Override protected JsonElement doGet(HttpServletRequest req) throws ArgumentsParseException {

7
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/jetty/handler/SpanGetHandler.java
View File

@ -20,10 +20,9 @@ package org.skywalking.apm.collector.ui.jetty.handler;
import com.google.gson.JsonElement;
import javax.servlet.http.HttpServletRequest;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.server.jetty.ArgumentsParseException;
import org.skywalking.apm.collector.server.jetty.JettyHandler;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.ui.service.SpanService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -41,8 +40,8 @@ public class SpanGetHandler extends JettyHandler {
private final SpanService service;
public SpanGetHandler(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.service = new SpanService(daoService, cacheServiceManager);
public SpanGetHandler(ModuleManager moduleManager) {
this.service = new SpanService(moduleManager);
}
@Override protected JsonElement doGet(HttpServletRequest req) throws ArgumentsParseException {

7
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/jetty/handler/TraceDagGetHandler.java
View File

@ -20,10 +20,9 @@ package org.skywalking.apm.collector.ui.jetty.handler;
import com.google.gson.JsonElement;
import javax.servlet.http.HttpServletRequest;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.server.jetty.ArgumentsParseException;
import org.skywalking.apm.collector.server.jetty.JettyHandler;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.ui.service.TraceDagService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -41,8 +40,8 @@ public class TraceDagGetHandler extends JettyHandler {
private final TraceDagService service;
public TraceDagGetHandler(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.service = new TraceDagService(daoService, cacheServiceManager);
public TraceDagGetHandler(ModuleManager moduleManager) {
this.service = new TraceDagService(moduleManager);
}
@Override protected JsonElement doGet(HttpServletRequest req) throws ArgumentsParseException {

7
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/jetty/handler/TraceStackGetHandler.java
View File

@ -20,10 +20,9 @@ package org.skywalking.apm.collector.ui.jetty.handler;
import com.google.gson.JsonElement;
import javax.servlet.http.HttpServletRequest;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.server.jetty.ArgumentsParseException;
import org.skywalking.apm.collector.server.jetty.JettyHandler;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.ui.service.TraceStackService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -41,8 +40,8 @@ public class TraceStackGetHandler extends JettyHandler {
private final TraceStackService service;
public TraceStackGetHandler(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.service = new TraceStackService(daoService, cacheServiceManager);
public TraceStackGetHandler(ModuleManager moduleManager) {
this.service = new TraceStackService(moduleManager);
}
@Override protected JsonElement doGet(HttpServletRequest req) throws ArgumentsParseException {

7
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/jetty/handler/application/ApplicationsGetHandler.java
View File

@ -20,11 +20,10 @@ package org.skywalking.apm.collector.ui.jetty.handler.application;
import com.google.gson.JsonElement;
import javax.servlet.http.HttpServletRequest;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.server.jetty.ArgumentsParseException;
import org.skywalking.apm.collector.server.jetty.JettyHandler;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.ui.service.ApplicationService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -41,8 +40,8 @@ public class ApplicationsGetHandler extends JettyHandler {
private final ApplicationService applicationService;
public ApplicationsGetHandler(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.applicationService = new ApplicationService(daoService, cacheServiceManager);
public ApplicationsGetHandler(ModuleManager moduleManager) {
this.applicationService = new ApplicationService(moduleManager);
}
@Override protected JsonElement doGet(HttpServletRequest req) throws ArgumentsParseException {

7
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/jetty/handler/instancehealth/InstanceHealthGetHandler.java
View File

@ -22,10 +22,9 @@ import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import javax.servlet.http.HttpServletRequest;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.server.jetty.ArgumentsParseException;
import org.skywalking.apm.collector.server.jetty.JettyHandler;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.ui.service.InstanceHealthService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -43,8 +42,8 @@ public class InstanceHealthGetHandler extends JettyHandler {
private final InstanceHealthService service;
public InstanceHealthGetHandler(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.service = new InstanceHealthService(daoService, cacheServiceManager);
public InstanceHealthGetHandler(ModuleManager moduleManager) {
this.service = new InstanceHealthService(moduleManager);
}
@Override protected JsonElement doGet(HttpServletRequest req) throws ArgumentsParseException {

7
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/jetty/handler/instancemetric/InstanceMetricGetOneTimeBucketHandler.java
View File

@ -22,10 +22,9 @@ import com.google.gson.JsonElement;
import java.util.LinkedHashSet;
import java.util.Set;
import javax.servlet.http.HttpServletRequest;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.server.jetty.ArgumentsParseException;
import org.skywalking.apm.collector.server.jetty.JettyHandler;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.ui.service.InstanceJVMService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -43,8 +42,8 @@ public class InstanceMetricGetOneTimeBucketHandler extends JettyHandler {
private final InstanceJVMService service;
public InstanceMetricGetOneTimeBucketHandler(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.service = new InstanceJVMService(daoService, cacheServiceManager);
public InstanceMetricGetOneTimeBucketHandler(ModuleManager moduleManager) {
this.service = new InstanceJVMService(moduleManager);
}
@Override protected JsonElement doGet(HttpServletRequest req) throws ArgumentsParseException {

7
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/jetty/handler/instancemetric/InstanceMetricGetRangeTimeBucketHandler.java
View File

@ -22,10 +22,9 @@ import com.google.gson.JsonElement;
import java.util.LinkedHashSet;
import java.util.Set;
import javax.servlet.http.HttpServletRequest;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.server.jetty.ArgumentsParseException;
import org.skywalking.apm.collector.server.jetty.JettyHandler;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.ui.service.InstanceJVMService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -43,8 +42,8 @@ public class InstanceMetricGetRangeTimeBucketHandler extends JettyHandler {
private final InstanceJVMService service;
public InstanceMetricGetRangeTimeBucketHandler(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.service = new InstanceJVMService(daoService, cacheServiceManager);
public InstanceMetricGetRangeTimeBucketHandler(ModuleManager moduleManager) {
this.service = new InstanceJVMService(moduleManager);
}
@Override protected JsonElement doGet(HttpServletRequest req) throws ArgumentsParseException {

7
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/jetty/handler/instancemetric/InstanceOsInfoGetHandler.java
View File

@ -20,10 +20,9 @@ package org.skywalking.apm.collector.ui.jetty.handler.instancemetric;
import com.google.gson.JsonElement;
import javax.servlet.http.HttpServletRequest;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.server.jetty.ArgumentsParseException;
import org.skywalking.apm.collector.server.jetty.JettyHandler;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.ui.service.InstanceJVMService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -41,8 +40,8 @@ public class InstanceOsInfoGetHandler extends JettyHandler {
private final InstanceJVMService service;
public InstanceOsInfoGetHandler(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.service = new InstanceJVMService(daoService, cacheServiceManager);
public InstanceOsInfoGetHandler(ModuleManager moduleManager) {
this.service = new InstanceJVMService(moduleManager);
}
@Override protected JsonElement doGet(HttpServletRequest req) throws ArgumentsParseException {

7
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/jetty/handler/servicetree/EntryServiceGetHandler.java
View File

@ -20,10 +20,9 @@ package org.skywalking.apm.collector.ui.jetty.handler.servicetree;
import com.google.gson.JsonElement;
import javax.servlet.http.HttpServletRequest;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.server.jetty.ArgumentsParseException;
import org.skywalking.apm.collector.server.jetty.JettyHandler;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.ui.service.ServiceTreeService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -41,8 +40,8 @@ public class EntryServiceGetHandler extends JettyHandler {
private final ServiceTreeService service;
public EntryServiceGetHandler(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.service = new ServiceTreeService(daoService, cacheServiceManager);
public EntryServiceGetHandler(ModuleManager moduleManager) {
this.service = new ServiceTreeService(moduleManager);
}
@Override protected JsonElement doGet(HttpServletRequest req) throws ArgumentsParseException {

7
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/jetty/handler/servicetree/ServiceTreeGetByIdHandler.java
View File

@ -20,10 +20,9 @@ package org.skywalking.apm.collector.ui.jetty.handler.servicetree;
import com.google.gson.JsonElement;
import javax.servlet.http.HttpServletRequest;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.server.jetty.ArgumentsParseException;
import org.skywalking.apm.collector.server.jetty.JettyHandler;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.ui.service.ServiceTreeService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -41,8 +40,8 @@ public class ServiceTreeGetByIdHandler extends JettyHandler {
private final ServiceTreeService service;
public ServiceTreeGetByIdHandler(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.service = new ServiceTreeService(daoService, cacheServiceManager);
public ServiceTreeGetByIdHandler(ModuleManager moduleManager) {
this.service = new ServiceTreeService(moduleManager);
}
@Override protected JsonElement doGet(HttpServletRequest req) throws ArgumentsParseException {

7
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/jetty/handler/time/AllInstanceLastTimeGetHandler.java
View File

@ -22,11 +22,10 @@ import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import java.util.Calendar;
import javax.servlet.http.HttpServletRequest;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.TimeBucketUtils;
import org.skywalking.apm.collector.server.jetty.ArgumentsParseException;
import org.skywalking.apm.collector.server.jetty.JettyHandler;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.ui.service.TimeSynchronousService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -44,8 +43,8 @@ public class AllInstanceLastTimeGetHandler extends JettyHandler {
private final TimeSynchronousService service;
public AllInstanceLastTimeGetHandler(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.service = new TimeSynchronousService(daoService, cacheServiceManager);
public AllInstanceLastTimeGetHandler(ModuleManager moduleManager) {
this.service = new TimeSynchronousService(moduleManager);
}
@Override protected JsonElement doGet(HttpServletRequest req) throws ArgumentsParseException {

7
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/jetty/handler/time/OneInstanceLastTimeGetHandler.java
View File

@ -21,10 +21,9 @@ package org.skywalking.apm.collector.ui.jetty.handler.time;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import javax.servlet.http.HttpServletRequest;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.server.jetty.ArgumentsParseException;
import org.skywalking.apm.collector.server.jetty.JettyHandler;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.ui.service.TimeSynchronousService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -42,8 +41,8 @@ public class OneInstanceLastTimeGetHandler extends JettyHandler {
private final TimeSynchronousService service;
public OneInstanceLastTimeGetHandler(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.service = new TimeSynchronousService(daoService, cacheServiceManager);
public OneInstanceLastTimeGetHandler(ModuleManager moduleManager) {
this.service = new TimeSynchronousService(moduleManager);
}
@Override protected JsonElement doGet(HttpServletRequest req) throws ArgumentsParseException {

15
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/service/ApplicationService.java
View File

@ -20,7 +20,10 @@ package org.skywalking.apm.collector.ui.service;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.ApplicationCacheService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.dao.IInstanceUIDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -30,11 +33,11 @@ import org.skywalking.apm.collector.storage.service.DAOService;
public class ApplicationService {
private final DAOService daoService;
private final CacheServiceManager cacheServiceManager;
private final ApplicationCacheService applicationCacheService;
public ApplicationService(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.daoService = daoService;
this.cacheServiceManager = cacheServiceManager;
public ApplicationService(ModuleManager moduleManager) {
this.daoService = moduleManager.find(StorageModule.NAME).getService(DAOService.class);
this.applicationCacheService = moduleManager.find(CacheModule.NAME).getService(ApplicationCacheService.class);
}
public JsonArray getApplications(long startTime, long endTime) {
@ -44,7 +47,7 @@ public class ApplicationService {
applications.forEach(jsonElement -> {
JsonObject application = jsonElement.getAsJsonObject();
int applicationId = application.get("applicationId").getAsInt();
String applicationCode = cacheServiceManager.getApplicationCacheService().get(applicationId);
String applicationCode = applicationCacheService.get(applicationId);
application.addProperty("applicationCode", applicationCode);
});
return applications;

15
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/service/InstanceHealthService.java
View File

@ -21,8 +21,11 @@ package org.skywalking.apm.collector.ui.service;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import java.util.List;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.ApplicationCacheService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.TimeBucketUtils;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.dao.IGCMetricUIDAO;
import org.skywalking.apm.collector.storage.dao.IInstPerformanceUIDAO;
import org.skywalking.apm.collector.storage.dao.IInstanceUIDAO;
@ -39,11 +42,11 @@ public class InstanceHealthService {
private final Logger logger = LoggerFactory.getLogger(InstanceHealthService.class);
private final DAOService daoService;
private final CacheServiceManager cacheServiceManager;
private final ApplicationCacheService applicationCacheService;
public InstanceHealthService(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.daoService = daoService;
this.cacheServiceManager = cacheServiceManager;
public InstanceHealthService(ModuleManager moduleManager) {
this.daoService = moduleManager.find(StorageModule.NAME).getService(DAOService.class);
this.applicationCacheService = moduleManager.find(CacheModule.NAME).getService(ApplicationCacheService.class);
}
public JsonObject getInstances(long timeBucket, int applicationId) {
@ -58,7 +61,7 @@ public class InstanceHealthService {
response.add("instances", instances);
instanceList.forEach(instance -> {
response.addProperty("applicationCode", cacheServiceManager.getApplicationCacheService().get(applicationId));
response.addProperty("applicationCode", applicationCacheService.get(applicationId));
response.addProperty("applicationId", applicationId);
IInstPerformanceUIDAO instPerformanceDAO = (IInstPerformanceUIDAO)daoService.get(IInstPerformanceUIDAO.class);

9
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/service/InstanceJVMService.java
View File

@ -21,9 +21,10 @@ package org.skywalking.apm.collector.ui.service;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import java.util.Set;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.UnexpectedException;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.ObjectUtils;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.dao.ICpuMetricUIDAO;
import org.skywalking.apm.collector.storage.dao.IGCMetricUIDAO;
import org.skywalking.apm.collector.storage.dao.IInstPerformanceUIDAO;
@ -46,11 +47,9 @@ public class InstanceJVMService {
private final Gson gson = new Gson();
private final DAOService daoService;
private final CacheServiceManager cacheServiceManager;
public InstanceJVMService(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.daoService = daoService;
this.cacheServiceManager = cacheServiceManager;
public InstanceJVMService(ModuleManager moduleManager) {
this.daoService = moduleManager.find(StorageModule.NAME).getService(DAOService.class);
}
public JsonObject getInstanceOsInfo(int instanceId) {

9
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/service/SegmentTopService.java
View File

@ -21,8 +21,9 @@ package org.skywalking.apm.collector.ui.service;
import com.google.gson.JsonObject;
import java.util.LinkedList;
import java.util.List;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.StringUtils;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.dao.IGlobalTraceUIDAO;
import org.skywalking.apm.collector.storage.dao.ISegmentCostUIDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -37,11 +38,9 @@ public class SegmentTopService {
private final Logger logger = LoggerFactory.getLogger(SegmentTopService.class);
private final DAOService daoService;
private final CacheServiceManager cacheServiceManager;
public SegmentTopService(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.daoService = daoService;
this.cacheServiceManager = cacheServiceManager;
public SegmentTopService(ModuleManager moduleManager) {
this.daoService = moduleManager.find(StorageModule.NAME).getService(DAOService.class);
}
public JsonObject loadTop(long startTime, long endTime, long minCost, long maxCost, String operationName,

15
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/service/ServiceTreeService.java
View File

@ -23,10 +23,13 @@ import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import java.util.Iterator;
import java.util.Map;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.ApplicationCacheService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.ColumnNameUtils;
import org.skywalking.apm.collector.core.util.Const;
import org.skywalking.apm.collector.core.util.ObjectUtils;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.dao.IServiceEntryUIDAO;
import org.skywalking.apm.collector.storage.dao.IServiceReferenceUIDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -39,11 +42,11 @@ import org.skywalking.apm.collector.storage.table.serviceref.ServiceReferenceTab
public class ServiceTreeService {
private final DAOService daoService;
private final CacheServiceManager cacheServiceManager;
private final ApplicationCacheService applicationCacheService;
public ServiceTreeService(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.daoService = daoService;
this.cacheServiceManager = cacheServiceManager;
public ServiceTreeService(ModuleManager moduleManager) {
this.daoService = moduleManager.find(StorageModule.NAME).getService(DAOService.class);
this.applicationCacheService = moduleManager.find(CacheModule.NAME).getService(ApplicationCacheService.class);
}
public JsonObject loadEntryService(int applicationId, String entryServiceName, long startTime, long endTime,
@ -55,7 +58,7 @@ public class ServiceTreeService {
for (JsonElement element : entryServices) {
JsonObject entryService = element.getAsJsonObject();
int respApplication = entryService.get(ColumnNameUtils.INSTANCE.rename(ServiceEntryTable.COLUMN_APPLICATION_ID)).getAsInt();
String applicationCode = cacheServiceManager.getApplicationCacheService().get(respApplication);
String applicationCode = applicationCacheService.get(respApplication);
entryService.addProperty("applicationCode", applicationCode);
}

20
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/service/SpanService.java
View File

@ -21,9 +21,13 @@ package org.skywalking.apm.collector.ui.service;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import java.util.List;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.ApplicationCacheService;
import org.skywalking.apm.collector.cache.service.ServiceNameCacheService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.Const;
import org.skywalking.apm.collector.core.util.StringUtils;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.dao.ISegmentUIDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.skywalking.apm.network.proto.KeyWithStringValue;
@ -38,11 +42,13 @@ import org.skywalking.apm.network.trace.component.ComponentsDefine;
public class SpanService {
private final DAOService daoService;
private final CacheServiceManager cacheServiceManager;
private final ServiceNameCacheService serviceNameCacheService;
private final ApplicationCacheService applicationCacheService;
public SpanService(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.daoService = daoService;
this.cacheServiceManager = cacheServiceManager;
public SpanService(ModuleManager moduleManager) {
this.daoService = moduleManager.find(StorageModule.NAME).getService(DAOService.class);
this.serviceNameCacheService = moduleManager.find(CacheModule.NAME).getService(ServiceNameCacheService.class);
this.applicationCacheService = moduleManager.find(CacheModule.NAME).getService(ApplicationCacheService.class);
}
public JsonObject load(String segmentId, int spanId) {
@ -55,7 +61,7 @@ public class SpanService {
if (spanId == spanObject.getSpanId()) {
String operationName = spanObject.getOperationName();
if (spanObject.getOperationNameId() != 0) {
String serviceName = cacheServiceManager.getServiceNameCacheService().get(spanObject.getOperationNameId());
String serviceName = serviceNameCacheService.get(spanObject.getOperationNameId());
if (StringUtils.isNotEmpty(serviceName)) {
operationName = serviceName.split(Const.ID_SPLIT)[1];
}
@ -103,7 +109,7 @@ public class SpanService {
if (spanObject.getPeerId() == 0) {
peerJson.addProperty("value", spanObject.getPeer());
} else {
peerJson.addProperty("value", cacheServiceManager.getServiceNameCacheService().get(spanObject.getPeerId()));
peerJson.addProperty("value", applicationCacheService.get(spanObject.getPeerId()));
}
tagsArray.add(peerJson);

9
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/service/TimeSynchronousService.java
View File

@ -18,7 +18,8 @@
package org.skywalking.apm.collector.ui.service;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.dao.IInstanceUIDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
import org.slf4j.Logger;
@ -32,11 +33,9 @@ public class TimeSynchronousService {
private final Logger logger = LoggerFactory.getLogger(TimeSynchronousService.class);
private final DAOService daoService;
private final CacheServiceManager cacheServiceManager;
public TimeSynchronousService(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.daoService = daoService;
this.cacheServiceManager = cacheServiceManager;
public TimeSynchronousService(ModuleManager moduleManager) {
this.daoService = moduleManager.find(StorageModule.NAME).getService(DAOService.class);
}
public Long allInstanceLastTime() {

9
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/service/TraceDagService.java
View File

@ -20,7 +20,8 @@ package org.skywalking.apm.collector.ui.service;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.dao.INodeComponentUIDAO;
import org.skywalking.apm.collector.storage.dao.INodeMappingUIDAO;
import org.skywalking.apm.collector.storage.dao.INodeReferenceUIDAO;
@ -36,11 +37,9 @@ public class TraceDagService {
private final Logger logger = LoggerFactory.getLogger(TraceDagService.class);
private final DAOService daoService;
private final CacheServiceManager cacheServiceManager;
public TraceDagService(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.daoService = daoService;
this.cacheServiceManager = cacheServiceManager;
public TraceDagService(ModuleManager moduleManager) {
this.daoService = moduleManager.find(StorageModule.NAME).getService(DAOService.class);
}
public JsonObject load(long startTime, long endTime) {

20
apm-collector/apm-collector-ui/collector-ui-jetty-provider/src/main/java/org/skywalking/apm/collector/ui/service/TraceStackService.java
View File

@ -22,11 +22,15 @@ import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import java.util.ArrayList;
import java.util.List;
import org.skywalking.apm.collector.cache.CacheServiceManager;
import org.skywalking.apm.collector.cache.CacheModule;
import org.skywalking.apm.collector.cache.service.ApplicationCacheService;
import org.skywalking.apm.collector.cache.service.ServiceNameCacheService;
import org.skywalking.apm.collector.core.module.ModuleManager;
import org.skywalking.apm.collector.core.util.CollectionUtils;
import org.skywalking.apm.collector.core.util.Const;
import org.skywalking.apm.collector.core.util.ObjectUtils;
import org.skywalking.apm.collector.core.util.StringUtils;
import org.skywalking.apm.collector.storage.StorageModule;
import org.skywalking.apm.collector.storage.dao.IGlobalTraceUIDAO;
import org.skywalking.apm.collector.storage.dao.ISegmentUIDAO;
import org.skywalking.apm.collector.storage.service.DAOService;
@ -41,11 +45,13 @@ import org.skywalking.apm.network.proto.UniqueId;
public class TraceStackService {
private final DAOService daoService;
private final CacheServiceManager cacheServiceManager;
private final ApplicationCacheService applicationCacheService;
private final ServiceNameCacheService serviceNameCacheService;
public TraceStackService(DAOService daoService, CacheServiceManager cacheServiceManager) {
this.daoService = daoService;
this.cacheServiceManager = cacheServiceManager;
public TraceStackService(ModuleManager moduleManager) {
this.daoService = moduleManager.find(StorageModule.NAME).getService(DAOService.class);
this.applicationCacheService = moduleManager.find(CacheModule.NAME).getService(ApplicationCacheService.class);
this.serviceNameCacheService = moduleManager.find(CacheModule.NAME).getService(ServiceNameCacheService.class);
}
public JsonArray load(String globalTraceId) {
@ -124,14 +130,14 @@ public class TraceStackService {
String operationName = spanObject.getOperationName();
if (spanObject.getOperationNameId() != 0) {
String serviceName = cacheServiceManager.getServiceNameCacheService().get(spanObject.getOperationNameId());
String serviceName = serviceNameCacheService.get(spanObject.getOperationNameId());
if (StringUtils.isNotEmpty(serviceName)) {
operationName = serviceName.split(Const.ID_SPLIT)[1];
} else {
operationName = Const.EMPTY_STRING;
}
}
String applicationCode = cacheServiceManager.getApplicationCacheService().get(segment.getApplicationId());
String applicationCode = applicationCacheService.get(segment.getApplicationId());
long cost = spanObject.getEndTime() - spanObject.getStartTime();
if (cost == 0) {