Adobe AD0-E128 Adobe Experience Manager Sites Developer Professional Exam Practice Test

Comprehensive Explanation

Log-file rotation is an operational mechanism used in Adobe Experience Manager to prevent continuously growing log files from consuming excessive filesystem capacity.

AEM uses the Apache Sling logging infrastructure, which supports configurable rotation policies based on maximum file size or elapsed time.

Option B represents a principal benefit of size-based rotation. When the active log file reaches its configured threshold, the logging system rotates it and creates a new active log file.

Option C describes the storage-management benefit when rotation is combined with a suitable retention policy. By limiting the number of historical log files retained, administrators can prevent uncontrolled accumulation of diagnostic data.

Option A requires qualification. Rotation does not necessarily delete all previous log files. Instead, older files may be retained as rotated versions, with files beyond the configured retention limit subsequently removed.

Adobe documents configurable settings for the number of log-file versions retained, rotation intervals, and maximum file sizes.

These controls are especially important when DEBUG-level logging is enabled, because verbose diagnostic output can rapidly consume storage.

For production environments, rotation thresholds and retention limits should be selected according to storage capacity, troubleshooting requirements, and applicable log-retention policies.

Verification finding: All three selections match the intended question, but option A is imprecise. Log deletion depends on retention settings, and size limitation depends on the configured rotation strategy.

Official Adobe Reference: Logging — Global Logging; Loggers and Writers for Individual Services.

Batch 5 • Questions 41–50

Comprehensive Explanation

Adobe Experience Manager uses Access Control Lists (ACLs) to manage repository permissions for users and groups.

In the traditional AEM Author-Publish architecture, ACLs should be configured independently on the Author and Publish environments because these instances serve different security and operational purposes.

The Author environment manages content creation, editing, approvals, and administrative operations. Its ACLs typically grant content authors, editors, and administrators access to designated repository locations and functions.

The Publish environment serves content to website visitors and external applications. Its permissions generally require a more restrictive configuration to prevent unauthorized modification or exposure of repository content.

Adobe explicitly documents that page permissions are not replicated during user activation because ACL entries are stored under the repository nodes where access is granted rather than being maintained exclusively within user profiles.

Option B refers to a Preview environment, which is not one of the two traditional environments addressed by this replication behavior.

Option C identifies an editing activity rather than a separate AEM environment.

Therefore, ACLs must be maintained separately on the Author and Publish instances.

Adobe recommends this separation because automatically copying Author permissions to Publish could expose content-management capabilities that should remain inaccessible to public users.

Official Adobe Reference: Troubleshooting Replication — Page Permissions Are Not Replicated on User Activation.

Comprehensive Explanation

A Lucene index is the appropriate choice for asynchronously indexing multiple properties in Adobe Experience Manager.

AEM uses Apache Jackrabbit Oak as its repository implementation. Oak supports several index types, but Lucene indexes are particularly suitable for complex queries involving multiple properties, full-text searches, and structured content filtering.

A Lucene index is defined under /oak:index with an index definition specifying its indexed properties, applicable node types, and operational settings. Asynchronous indexing can be enabled through the async property, allowing repository changes to be processed independently of the original content-writing transaction.

This architecture reduces the overhead associated with maintaining complex indexes during content modifications. However, asynchronous indexes are eventually consistent, meaning that recently committed changes may not immediately appear in query results.

Option A is unsuitable because the historical Ordered index is not the recommended mechanism for modern AEM indexing requirements. Option C refers to a Property index, which is generally appropriate for simpler property-based equality queries rather than complex asynchronous indexing.

Adobe recommends Lucene-based indexes for custom indexing requirements, with carefully defined index rules and property definitions to maintain query efficiency.

Official Adobe Reference: Indexing Best Practices in AEM — Lucene Index Definitions and Asynchronous Indexing.

Comprehensive Explanation

Adobe Experience Manager provides the wcmmode object within HTL to identify the current Web Content Management rendering mode.

The wcmmode.edit property evaluates to true when a page is rendered in AEM's Edit mode. This enables developers to conditionally display authoring-specific markup without including that markup in normal published-page output.

The data-sly-test block statement evaluates a Boolean expression and renders its host element only when the expression is true.

The correct implementation is:

< p data-sly-test="${wcmmode.edit}" >

Hello World

< /p >

When an author opens the page in Edit mode, the paragraph is rendered. In other modes where wcmmode.edit evaluates to false, the paragraph is omitted.

Option A is incorrect because wcm.edit is not the documented HTL property for detecting the current authoring mode.

Option B is incorrect because wcmmode.editor is not the recognized mode property.

Adobe also documents wcmmode.preview for conditions that must apply specifically to Preview mode.

A common practical application involves displaying component placeholders when a component has no configured content. Such placeholders help authors identify and select components that would otherwise appear empty.

The wcmmode.edit condition is therefore the correct mechanism for rendering content exclusively in Edit mode.

Official Adobe Reference: Adobe Experience Manager Components — The Basics, Component Placeholders; Components Reference Guide — Authoring Mode.

Comprehensive Explanation

The AEM Project Archetype uses the aemVersion property to determine the target Adobe Experience Manager runtime environment for the generated project.

When generating a project intended for Adobe Managed Services (AMS), developers must specify a compatible AEM 6.5 version rather than selecting the Cloud Service target.

For example:

-DaemVersion=6.5.8

Adobe explicitly documents 6.5.8 as an example value for Adobe Managed Services or on-premises environments. The actual value should correspond to the AEM version targeted by the implementation.

If aemVersion is not specified, current archetype versions default to cloud , which generates an AEM as a Cloud Service-oriented project.

Option A controls the generated Java source package and does not identify the target AEM runtime.

Option B specifies the Maven project version, commonly initialized with a snapshot value.

Option C specifies an AEM SDK version when targeting the Cloud Service environment. It does not determine whether the project is intended for Adobe Managed Services.

The aemVersion property influences generated dependencies and deployment-related configuration. It is therefore essential when targeting an AMS environment rather than AEM as a Cloud Service.

Official Adobe Reference: AEM Project Archetype — Usage and Available Properties.

Comprehensive Explanation

Adobe Experience Manager provides an Operations Dashboard for monitoring repository health and managing routine maintenance tasks.

The Automated Maintenance Tasks interface is available through the specified URL:

/libs/granite/operations/content/maintenance.html

This interface includes predefined maintenance scheduling cards, including the Daily Maintenance Window and the Weekly Maintenance Window.

The Daily Maintenance Window is used for operations that should execute regularly to maintain repository performance and stability.

Adobe documents the default Daily Maintenance Window as running from 2:00 A.M. to 5:00 A.M. Tasks associated with this window include Revision Cleanup and Lucene Binaries Cleanup, depending on the AEM version and repository configuration.

The Weekly Maintenance Window normally operates during a separately configured interval and supports tasks such as workflow purging, audit-log maintenance, and data-store garbage collection.

Option A is not the best answer because monthly scheduling is an available configuration capability in certain AEM versions, but it is not the primary default timing card referenced in the question.

Option B is incorrect because Quarterly Maintenance Window is not one of the documented default cards.

The Daily Maintenance Window enables administrators to schedule repository maintenance during periods of reduced system activity, minimizing the impact of maintenance operations on production workloads.

Official Adobe Reference: Operations Dashboard — Automated Maintenance Tasks; Revision Cleanup — How to Run Online Revision Cleanup.

Comprehensive Explanation

Adobe has deprecated the JavaScript Use API for AEM as a Cloud Service and explicitly identifies the Java Use API as its recommended replacement.

The JavaScript Use API historically allowed developers to implement server-side component logic using JavaScript files referenced through HTL's data-sly-use mechanism.

The Java Use API provides an alternative architecture that separates presentation markup from application logic through Java classes and Sling Models.

Java-based implementations can provide stronger compile-time type checking, dependency injection, reusable service integrations, and more structured unit-testing capabilities.

The HTL layer remains responsible for rendering presentation markup, while Java classes handle data processing and application-specific functionality.

Option A, the JCR API, provides repository access and content-manipulation capabilities. It does not replace the component-level HTL Use API.

Option C, the Jackrabbit Oak API, relates to the underlying content repository implementation and is not the recommended replacement.

Option D, the Assets HTTP API, provides asset-related operations and is unrelated to the JavaScript Use API's primary purpose.

Adobe's AEM as a Cloud Service documentation explicitly lists JavaScript Use API under deprecated Sites functionality and identifies Java Use API as its replacement.

For new development, developers should implement business logic using Java-backed components and appropriate Sling Models rather than creating new dependencies on deprecated server-side JavaScript implementations.

Official Adobe Reference: Deprecated and Removed Features — Sites, JavaScript Use API; Getting Started with HTL — Java Use API.

Comprehensive Explanation

When an AEM Sites page experiences unusually long loading times or intermittent timeouts, examining the application error log is an appropriate initial diagnostic step among the available choices.

The AEM error.log records exceptions, warnings, component-rendering failures, repository-query problems, and application-level errors that may explain why a particular page is failing or taking too long to render.

For example, a defective Sling Model, expensive repository query, unavailable backend integration, or component exception may generate log entries identifying the affected Java class or service.

Option A is incorrect because the Audit Log records content-management and administrative actions rather than diagnosing application execution failures.

Option C is useful when the problem involves Dispatcher caching, connection failures, or communication with AEM Publish instances. However, it is not necessarily the most direct source of application-level diagnostic information.

Option D provides request-access information but generally does not expose the internal application exceptions responsible for page failures.

Important qualification: Adobe specifically identifies request.log as the starting point for measuring slow AEM requests. That option is missing from this question. Adobe also recommends reviewing error.log and access.log when troubleshooting slow or unresponsive pages.

Therefore, B is the best available answer for investigating potential application-level causes, but the question does not have a universally correct first log without additional diagnostic context.

Official Adobe Reference: Troubleshooting Slow Response and Unresponsive Pages in AEM 6.5; How to Analyze Common Critical AEM Issues.

Comprehensive Explanation

Adobe Experience Manager uses Apache Sling's logging infrastructure to manage application log files, including log rotation, logging levels, file destinations, and retention settings.

Log rotation prevents an active log file from growing indefinitely by periodically creating a new file based on a configured time interval or size threshold.

Adobe distinguishes between the Apache Sling Logging Logger Configuration and the Apache Sling Logging Writer Configuration.

The Logger Configuration determines which logging categories produce messages, their severity levels, and their associated log destinations. The Writer Configuration controls how individual log files are written and rotated.

For central logging, the Apache Sling Logging Configuration provides settings for the number of retained log versions and rotation thresholds.

Option B is the closest answer because it belongs to the Sling logging infrastructure. However, configuring a logger alone does not explicitly establish the required rotation policy. A corresponding writer or global logging configuration is necessary.

Options A, C, and D do not represent the appropriate logging rotation configuration.

Verification finding: The technically correct option should be Apache Sling Logging Writer Configuration, or Apache Sling Logging Configuration when configuring the root logger. Neither appears in the question.

Additionally, Adobe warns that AEM as a Cloud Service restricts modifications to the default logging configuration. These settings should not be changed indiscriminately in managed cloud environments.

Official Adobe Reference: Logging — Global Logging and Loggers and Writers for Individual Services; OSGi Configuration Settings.

Comprehensive Explanation

Editable templates in Adobe Experience Manager separate template configuration into Structure, Initial Content, Content Policies, and Layout.

The Structure section defines components that must remain consistent across pages created from the template. Components placed in this section can be locked to prevent page authors from modifying, moving, or deleting them.

When a component is locked in the template structure, it remains visible on resulting pages but cannot be edited directly by ordinary page authors.

This capability is particularly useful for mandatory page elements such as standardized headers, regulatory notices, branding elements, and structural containers.

Option A is incorrect because removing a component from the allowed-components policy restricts its availability for insertion; it does not establish an existing, non-editable component.

Option B is incorrect because Initial Content provides starting content that authors can subsequently modify on individual pages.

Option C does not provide the required template-level editing restriction.

The appropriate implementation is therefore to place the component in the editable template's Structure section and maintain it in a locked state.

Adobe's editable-template documentation explicitly distinguishes locked structure components from editable initial content, establishing the correct behavior for this requirement.

Official Adobe Reference: Editable Templates — Structure and Initial Content; Templates to Create Pages That Are Editable with the Page Editor.

Comprehensive Explanation

Adobe Experience Manager Dispatcher provides request-level security filtering through the /filter section of its configuration. This mechanism determines which incoming HTTP requests are permitted to reach an AEM rendering instance.

When an incoming request matches a rule explicitly configured with /type "deny" , Dispatcher rejects the request and returns an HTTP 404 Not Found response.

The response is intentionally different from the HTTP 403 Forbidden status commonly associated with authorization failures. Dispatcher filtering operates as an access-control layer that can prevent external clients from discovering restricted repository endpoints.

For example:

/filter {

/0001 { /type "deny" /url "*" }

/0002 { /type "allow" /url "/content/*" }

}

This configuration denies requests by default and permits requests matching the specified content path.

Option B is incorrect for the documented default response to a denied Dispatcher filter request. HTTP 403 can occur in other authorization or security contexts, but it is not the expected filter-denial response here.

Option C indicates a malformed client request and is unrelated to the normal Dispatcher filtering behavior.

Adobe explicitly documents the 404 response for requests rejected through Dispatcher filter rules.

Official Adobe Reference: Configure AEM Dispatcher — Configure Access to Content, Example Filter: Deny All.

Comprehensive Explanation

Adobe Experience Manager as a Cloud Service includes AEM Core Components as part of the managed platform, eliminating the requirement for developers to install the Core Components package manually.

Core Components provide standardized, extensible implementations of common website functionality, including text, images, titles, navigation, containers, and other presentation components.

Adobe maintains the Core Components within AEM as a Cloud Service and provides compatible component versions as part of platform updates.

In contrast, traditional AEM 6.5 deployments and Adobe Managed Services environments may require Core Components to be included as application dependencies or installed as part of the deployment process.

Option B is therefore not the most appropriate choice because Adobe Managed Services environments do not provide the same automatic Core Components availability model as AEM as a Cloud Service.

Option C is incorrect because AEM 6.3 predates the modern Core Components architecture supported by current AEM implementations.

The requirement to avoid sample content is also compatible with AEM as a Cloud Service. Developers can configure their AEM project without deploying optional demonstration content.

One important distinction remains: although Core Components are installed automatically, project developers must still configure their availability through appropriate proxy components, editable templates, and content policies.

Official Adobe Reference: Core Components Introduction — System Requirements and Cloud Service Availability; AEM Project Archetype.

Comprehensive Explanation

Adobe Experience Manager supports determining the initial instance run mode and listening port through the naming convention of its Quickstart JAR file.

For traditional AEM installations, the filename can include the instance type and port number.

The filename cq5-author-p4502.jar identifies an Author instance configured to start on port 4502.

The author component determines the instance role, while -p4502 identifies the configured HTTP port.

Option A is incorrect because it includes two port-related numeric values, making the naming structure unnecessarily ambiguous.

Option C does not follow Adobe's documented convention for specifying the instance type and port.

Option D also fails to follow the recommended convention and includes additional port-related information that is not required.

Adobe's standalone installation documentation explicitly provides examples using names such as cq5-publish-p4503.jar and cq5-author-p6754.jar .

The default ports for a traditional AEM installation are typically 4502 for Author and 4503 for Publish.

Version distinction: AEM as a Cloud Service development environments commonly use the newer aem-author-p4502.jar naming pattern. The cq5 prefix in this question reflects the traditional Quickstart naming convention and is appropriate among the supplied choices.

Official Adobe Reference: Custom Standalone Install — Changing the Port Number by Renaming the File; Setting Up a Local AEM Development Environment.

Comprehensive Explanation

Adobe Experience Manager Dispatcher controls external HTTP request access through the /filter section of its farm configuration. This section can permit or reject requests according to their HTTP method, URL, selectors, extensions, and query strings.

When Dispatcher rejects a request containing query parameters, the developer should inspect its access-filter rules to determine whether an appropriate /query condition has been configured.

For example:

/filter {

/0001 {

/type "allow"

/method "GET"

/url "/content/site/*"

/query "q=*"

}

}

This rule permits matching GET requests containing the designated query parameter.

Option A controls the AEM rendering instances and does not determine whether query strings are permitted. Option B generally refers to cache rules, which govern cache eligibility. Option C controls caching behavior, including /ignoreUrlParams , rather than request authorization.

Technical qualification: The actual Dispatcher configuration directive is /filter , not /filters . Therefore, option D contains a naming error.

Additionally, if the problem concerns pages with query parameters bypassing the cache rather than being rejected, option C would be relevant because /cache/ignoreUrlParams controls query-parameter caching behavior.

For requests being denied, D identifies the intended configuration area.

Official Adobe Reference: Configure Dispatcher — Restrict Query Strings and Ignore URL Parameters.

Comprehensive Explanation

The -agentlib:jdwp Java Virtual Machine parameter activates the Java Debug Wire Protocol (JDWP), enabling a debugger to connect to a running Java process.

In Adobe Experience Manager, this configuration is commonly used when debugging Java code through an IDE such as Eclipse or IntelliJ IDEA.

The parameter transport=dt_socket specifies socket-based communication between the JVM and debugging client.

The address=8000 setting identifies the port used for debugger connections, while server=y instructs the JVM to listen for incoming debugger connections.

The suspend=n setting is particularly important because it allows the AEM instance to continue starting without waiting for a debugger to attach.

Option A is incorrect because suspending startup would require suspend=y . Even then, startup would wait for a debugger rather than necessarily fail.

Option C is incorrect because the debug-agent settings do not determine the AEM instance's Author or Publish run mode.

Option B correctly identifies that the instance starts with remote debugging enabled.

Technical distinction: Remote JVM debugging is different from setting the AEM application log level to DEBUG . The JDWP parameter enables debugger attachment, breakpoints, and Java execution inspection.

Adobe recommends avoiding unnecessary remote debugging in production because it can introduce performance and security risks.

Official Adobe Reference: How to Debug an AEM App Using Eclipse — Add the Remote Debugging JVM Parameter.