<?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
 *******************************************************************************/

#*****************************************************************************
#
# faq.php
#
# Author: 		Wayne Beaton
# Date:			June 5, 2006
#
# Description:
#
#
#****************************************************************************

# Begin: page-specific settings.  Change these.
$pageTitle 		= "UDC Technical FAQ";
$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>
<p>This FAQ is concerned with questions of technical nature. Questions
concerning the capture and use of the data by The Eclipse Foundation can
be found <a href="/org/usagedata/faq.php">UDC Data Capture and Use FAQ</a>.</p>


	<h4>What releases of Eclipse does the Usage Data Collector support?</h4>
	<dd>
	<p>The Usage Data Collector can be installed into the Europa (Eclipse
	Top Level Project SDK 3.3.x) or Ganymede (Eclipse Top Level Project SDK
	3.4.x) Eclipse releases and milestone builds.</p>
	

	<h4>How do I install the Usage Data Collector?</h4>
	<dd>
	<p>The Usage Data Collector is included as part of the &quot;UDC&quot;
	packages produced by the EPP. An automated build process generates a
	new build that can be installed into Eclipse by pointing the update
	manager to:</p>

	<pre>http://download.eclipse.org/technology/epp/updates/1.0</pre>

	<p>For more information about the build process and status, please see
	<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=215060">Bug
	215060</a>.</p>
	

	<h4>How do I get the code?</h4>
	<dd>
	<p>If you want to load the code as projects into your workspace, it is
	available in the Technology Project's CVS repository. Use this <a
		href="UsageData.psf">Team Project Set</a> to add the Usage Data
	Monitor to your workspace.</p>

	<p>You can also <a
		href="http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.epp/?root=Technology_Project">browse
	the code online</a>.</p>
	

	<h4>How do I turn off the Usage Data Collector?</h4>
	<dd>
	<p>There is an option on the &quot;Usage Data Collection&quot;
	preferences page labeled &quot;Enable Capture&quot;. Turn this option <em>off</em>.</p>
	

	<h4>Where is the information stored?</h4>
	<dd>
	<p>As the usage data is collected, it is stored locally in the <em><?= $tempdir ?></em>
	directory of the Eclipse workspace. After data has been successfully
	uploaded and the data has been transferred into the Eclipse
	Foundation's database, the local files are deleted.</p>
	

	<h4>What information is captured?</h4>
	<dd>
	<p>The UDC captures the the following information:</p>
	<ol>
		<li>Bundles (also known as plug-ins) that are started by the system.</li>
		<li>Commands accessed via keyboard shortcuts, and actions invoked via
		menus or toolbars.</li>
		<li>Perspective changes</li>
		<li>View and editor open, close, and activation events (activations
		occur when a view or editor is given focus).</li>
		<li>System information, such as JVM name and version, operating
		system, and window system (new with version 1.1.0).</li>
		<li>The description of internal errors (exceptions logged with
		a severity of &quot;ERROR&quot;).</li>
	</ol>
	<p>For each item captured, we also capture the idenfier and version of
	the bundle that contributes the item. When information is uploaded, we
	further capture the country from which the upload originated.</p>

	<p>It's valuable to also note what we <em>do not</em> capture. We <em>do
	not capture any personal information</em>. We <em>do not capture IP
	addresses</em>. We <em>do not capture any information that will allows
	us to identify the source of the information</em>.</p>

	<p>Two different keys are used to identify the source of the uploaded
	data. The first key identifies the workstation; this key is stored
	locally in your &quot;user home&quot; directory. The second key
	identifies the workspace; this key is stored in the <em><?= $tempdir ?></em>
	directory for the workspace. These keys are uploaded along with the
	usage data. These keys allow us to correlate data.</p>
	

	<h4>How do we change the upload target?</h4>
	<dd>
	<p>The server to which the UDC uploads data can be configured using the
	<code>org.eclipse.epp.usagedata.recording.upload-url</code> system
	property. This property can be set either on the command-line for
	Eclipse, or in the <code>eclipse.ini</code> file. For example:</p>
	<pre>-Dorg.eclipse.epp.usagedata.recording.upload-url=http://myserver/...</pre>
	<p>Note that &quot;-D&quot; parameters should follow &quot;-vmargs&quot; on the
	command-line.</p>
</div>

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