<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
/*******************************************************************************
 * Copyright (c) 2006 Eclipse Foundation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Wayne Beaton (Eclipse Foundation)- initial API and implementation
 *******************************************************************************/

#*****************************************************************************
#
# template.php
#
# Author: 		Wayne Beaton
# Date:			February 16, 2006
#
# Description:
#
#
#****************************************************************************

# Begin: page-specific settings.  Change these.
$pageTitle 		= "Usage Data Collector";
$pageKeywords	= "Eclipse, usage data, usagedata, cortez";
$pageAuthor		= "Wayne Beaton";

$tempdir = "./.metadata/.plugins/org.eclipse.epp.usagedata.recording";

ob_start();
?>
<link
	rel="stylesheet" type="text/css" href="layout.css" media="screen" />
<div id="maincontent">
<div id="midcolumn">

<h1><?= $pageTitle ?></h1>
<style>
.homeitem li {
	border-style: none
}
</style>

<p>The Usage Data Collector (UDC) is a framework for collecting usage data information.
It is a lightweight framework that installs listeners on various aspects of the Eclipse
workbench, and&mdash;from those listeners&mdash;gathers information about the kinds of 
things that the user is doing (i.e. activating views, editors, etc.).</p>

<p>At present, the UDC does not expose any official APIs, though there are several under
consideration. The UDC has a notion of <em>monitors</em>. Monitors are Java classes that
install various listeners, make sense of what they're listening do and post <em>events</em> 
to the UDC (which currently manifests as an OSGi service). We have three different
monitors: one monitors bundle events, one monitors workbench events, and a third monitors
commands. None of the included monitors captures information that we consider private
or personal. These monitors do capture the identifiers (ids) of the commands, views, editors, bundles,
etc. that are the source of the various events.</p>

<p>The Eclipse Foundation is making use of the UDC to gather information
about how the community is making use of Eclipse technology. The Foundation's immediate interest is to
provide feedback to the project teams about the use of their technology in the field. The
UDC is currently implemented with this purpose in mind (i.e. the exemplary application of the
UDC technology is concerned with providing data to the Foundation).</p>

<p>This site is concerned with the technical aspects of the UDC. The Eclipse Foundation has
a <a href="/org/usagedata">separate site</a> that is concerned with the issues of data collection, 
storage on Foundation servers, terms of use, etc.</p>

<p>Please post any questions you have about the UDC on the 
<a href="news://news.eclipse.org/eclipse.technology.packaging">EPP newsgroup</a>.
Open bugs raised against the UDC can be found in 
<a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&classification=Technology&product=EPP&component=Usage+Data+Collector&bug_status=NEW&bug_status=REOPENED">Eclipse Bugzilla</a>.
Or you can <a href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=EPP&component=Usage+Data+Collector">open a new bug</a> 
(or better yet, use <a href="/mylyn">Mylyn</a> to do it!).</p>

<p>If you'd like to help out with the UDC, please join the 
<a href="http://dev.eclipse.org/mailman/listinfo/epp-dev">EPP mailing list</a>.
Links to the right (which are better described in the <a href="faq.php">FAQ</a>) 
will help find the code.</p>
</div>

<? include "rightcol.php"; ?>

</div>
<?php
$html = ob_get_contents();
ob_end_clean();
$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>