public BadQueryEntry(String sql, String adj, long startTime, float runningSec, String server, String thread, String user, String queryId) { this.updateRandomUuid(); this.adj = adj; this.sql = sql; this.startTime = startTime; this.runningSec = runningSec; this.server = server; this.thread = thread; this.user = user; this.queryId = queryId; }
public BadQueryHistory(String project) { this.updateRandomUuid(); this.project = project; }
static BadQueryHistoryManager newInstance(KylinConfig config) throws IOException { return new BadQueryHistoryManager(config); }
@Test public void testAddEntryToProject() throws IOException { KylinConfig kylinConfig = getTestConfig(); BadQueryHistoryManager manager = BadQueryHistoryManager.getInstance(kylinConfig); BadQueryEntry entry = new BadQueryEntry("sql", "adj", 1459362239992L, 100, "server", "t-0", "user", RandomUtil.randomUUID().toString()); BadQueryHistory history = manager.upsertEntryToProject(entry, "default"); NavigableSet<BadQueryEntry> entries = history.getEntries(); assertEquals(4, entries.size()); BadQueryEntry newEntry = entries.last(); System.out.println(newEntry); assertEquals("sql", newEntry.getSql()); assertEquals("adj", newEntry.getAdj()); assertEquals(1459362239992L, newEntry.getStartTime()); assertEquals("server", newEntry.getServer()); assertEquals("user", newEntry.getUser()); assertEquals("t-0", newEntry.getThread()); for (int i = 0; i < kylinConfig.getBadQueryHistoryNum(); i++) { BadQueryEntry tmp = new BadQueryEntry("sql", "adj", 1459362239993L + i, 100 + i, "server", "t-0", "user", RandomUtil.randomUUID().toString()); history = manager.upsertEntryToProject(tmp, "default"); } assertEquals(kylinConfig.getBadQueryHistoryNum(), history.getEntries().size()); }
@Test public void testBasics() throws Exception { BadQueryHistory history = BadQueryHistoryManager.getInstance(getTestConfig()) .getBadQueriesForProject("default"); System.out.println(JsonUtil.writeValueAsIndentString(history)); NavigableSet<BadQueryEntry> entries = history.getEntries(); assertEquals(3, entries.size()); BadQueryEntry entry1 = entries.first(); assertEquals("Pushdown", entry1.getAdj()); assertEquals("sandbox.hortonworks.com", entry1.getServer()); assertEquals("select * from test_kylin_fact limit 10", entry1.getSql()); entries.pollFirst(); BadQueryEntry entry2 = entries.first(); assertTrue(entry2.getStartTime() > entry1.getStartTime()); }
@Test public void testUpdateEntryToProject() throws IOException { KylinConfig kylinConfig = getTestConfig(); BadQueryHistoryManager manager = BadQueryHistoryManager.getInstance(kylinConfig); String queryId = RandomUtil.randomUUID().toString(); manager.upsertEntryToProject( new BadQueryEntry("sql", "adj", 1459362239000L, 100, "server", "t-0", "user", queryId), "default"); BadQueryHistory history = manager.upsertEntryToProject( new BadQueryEntry("sql", "adj2", 1459362239000L, 120, "server2", "t-1", "user", queryId), "default"); NavigableSet<BadQueryEntry> entries = history.getEntries(); BadQueryEntry newEntry = entries .floor(new BadQueryEntry("sql", "adj2", 1459362239000L, 120, "server2", "t-1", "user", queryId)); System.out.println(newEntry); assertEquals("adj2", newEntry.getAdj()); assertEquals("server2", newEntry.getServer()); assertEquals("t-1", newEntry.getThread()); assertEquals("user", newEntry.getUser()); assertEquals(120, (int) newEntry.getRunningSec()); }
public BadQueryHistory upsertEntryToProject(BadQueryEntry badQueryEntry, String project) throws IOException { if (StringUtils.isEmpty(project) || badQueryEntry.getAdj() == null || badQueryEntry.getSql() == null) throw new IllegalArgumentException(); BadQueryHistory badQueryHistory = getBadQueriesForProject(project); NavigableSet<BadQueryEntry> entries = badQueryHistory.getEntries(); entries.remove(badQueryEntry); // in case the entry already exists and this call means to update entries.add(badQueryEntry); int maxSize = kylinConfig.getBadQueryHistoryNum(); if (entries.size() > maxSize) { entries.pollFirst(); } getStore().checkAndPutResource(badQueryHistory.getResourcePath(), badQueryHistory, BAD_QUERY_INSTANCE_SERIALIZER); return badQueryHistory; }
@Test public void testDiagnosisService() throws IOException { BadQueryHistory history = BadQueryHistoryManager.getInstance(getTestConfig()) .getBadQueriesForProject("default"); List<BadQueryEntry> allEntries = new ArrayList<>(); allEntries.addAll(history.getEntries()); DiagnosisService diagnosisService = new DiagnosisService(); Object obj = diagnosisService.getQueries(0, 10, BadQueryEntry.ADJ_PUSHDOWN, allEntries).get("badQueries"); List<BadQueryEntry> pushDownList = (List<BadQueryEntry>) obj; Assert.assertEquals(1, pushDownList.size()); obj = diagnosisService.getQueries(0, 10, BadQueryEntry.ADJ_SLOW, allEntries).get("badQueries"); List<BadQueryEntry> slowList = (List<BadQueryEntry>) obj; Assert.assertEquals(2, slowList.size()); } }
public BadQueryHistory getBadQueriesForProject(String project) throws IOException { BadQueryHistory badQueryHistory = getStore().getResource(getResourcePathForProject(project), BAD_QUERY_INSTANCE_SERIALIZER); if (badQueryHistory == null) { badQueryHistory = new BadQueryHistory(project); } logger.debug("Loaded " + badQueryHistory.getEntries().size() + " Bad Query(s)"); return badQueryHistory; }
private void requireProject(ProjectInstance projectInstance) throws IOException { addRequired(projectInstance.getResourcePath()); List<RealizationEntry> realizationEntries = projectInstance.getRealizationEntries(); for (RealizationEntry realizationEntry : realizationEntries) { retrieveResourcePath(getRealization(realizationEntry)); } List<DataModelDesc> modelDescs = metadataManager.getModels(projectInstance.getName()); for (DataModelDesc modelDesc : modelDescs) { addRequired(DataModelDesc.concatResourcePath(modelDesc.getName())); } addOptional(badQueryHistoryManager.getBadQueriesForProject(projectInstance.getName()).getResourcePath()); }
public BadQueryHistoryManager getBadQueryHistoryManager() { return BadQueryHistoryManager.getInstance(getConfig()); }
public ProjectInstance dropProject(String projectName) throws IOException { try (AutoLock lock = prjMapLock.lockForWrite()) { if (projectName == null) throw new IllegalArgumentException("Project name not given"); ProjectInstance projectInstance = getProject(projectName); if (projectInstance == null) { throw new IllegalStateException("The project named " + projectName + " does not exist"); } if (projectInstance.getRealizationCount(null) != 0) { throw new IllegalStateException("The project named " + projectName + " can not be deleted because there's still realizations in it. Delete them first."); } logger.info("Dropping project '" + projectInstance.getName() + "'"); crud.delete(projectInstance); BadQueryHistoryManager.getInstance(config).removeBadQueryHistory(projectName); clearL2Cache(projectName); return projectInstance; } }
public BadQueryHistory getProjectBadQueryHistory(String project) throws IOException { aclEvaluate.checkProjectOperationPermission(project); return getBadQueryHistoryManager().getBadQueriesForProject(project); }
@Override public void badQueryFound(String adj, float runningSec, long startTime, String project, String sql, String user, Thread t, String queryId) { try { BadQueryEntry entry = new BadQueryEntry(sql, adj, startTime, runningSec, serverHostname, t.getName(), user, queryId); badQueryManager.upsertEntryToProject(entry, project); } catch (IOException e) { logger.error("Error in bad query persistence.", e); } } }
/** * Get bad query history */ @RequestMapping(value = "/{project}/sql", method = { RequestMethod.GET }, produces = { "application/json" }) @ResponseBody public List<BadQueryEntry> getBadQuerySql(@PathVariable String project) { List<BadQueryEntry> badEntry = Lists.newArrayList(); try { BadQueryHistory badQueryHistory = dgService.getProjectBadQueryHistory(project); badEntry.addAll(badQueryHistory.getEntries()); } catch (IOException e) { throw new InternalErrorException("Failed to get bad queries.", e); } return badEntry; }
public List<BadQueryEntry> getQueriesByType(List<BadQueryEntry> allBadEntries, String queryType) throws IOException { List<BadQueryEntry> filteredEntries = Lists.newArrayList(); for (BadQueryEntry entry : allBadEntries) { if (null != entry && entry.getAdj().equals(queryType)) { filteredEntries.add(entry); } } return filteredEntries; }
public void removeBadQueryHistory(String project) throws IOException { getStore().deleteResource(getResourcePathForProject(project)); }
@Before public void setUp() throws Exception { this.createTestMetadata(); }
@After public void after() throws Exception { this.cleanupTestMetadata(); }
executableDao = ExecutableDao.getInstance(kylinConfig); realizationRegistry = RealizationRegistry.getInstance(kylinConfig); badQueryHistoryManager = BadQueryHistoryManager.getInstance(kylinConfig);